Duplicate from SciCode/SciCode-Domain-Code

Co-authored-by: SciCodePile <SciCode@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,190 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+data/dataset_2D.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_3D.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_AMR.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Ab_initio.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Absorption.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Activation.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Agent_based_model.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Anomaly_detection.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Antagonist.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Antibody.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Antigen.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Autoregressive.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Bio.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Bioinformatics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Biologics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Biology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Biomarker.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Biomedical.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Biotechnology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Cell_atlas.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Chemical_space.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Cheminformatics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Chemistry.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Compartmental_model.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Computational_Chemistry.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Computational_Materials.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Coupled_cluster.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Crystal.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Cycle.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_DFT.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_DNA.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_De_novo.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Design.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Diagnostics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Diffusion.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Discovery.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Disease.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Docking.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Drug.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Drug_repurpose.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Dynamics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Electronic_structure.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Ensemble.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Enzyme.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Evolution.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Explainable_AI.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Finite_element_method.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_First_principles_based_DFT.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Flow_matching.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Folding.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Free_energy_perturbation.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_GAN.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Gene.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Gene_editing.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Generate.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Generative.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Genomics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Genotype.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Hartree_Fock.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Heterogeneity.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_High_throughput.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Human.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Hydrophobic.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Imaging.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Immunology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Integration.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Ion.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Kinetics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Lead_discovery.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Lead_optimization.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Ligand.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Lipid.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Marker.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Material.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Mechanism.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Medicine.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Metabolomics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Metagenomics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Microbial.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Modeling.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Molecular_biology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Monte_Carlo.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Multi_omics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Networks.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Next_generation_sequencing.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Omics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Pandemic.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Pathology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Pathway.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Personalized.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Pharmaceutics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Pharmacokinetics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Pharmacology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Pharmacometrics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Phase_field_technique.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Phenotype.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Physiology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Porous.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Potential.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Prediction.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Profiling.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Protein.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Protein_Protein_Interactions.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Protein_protein.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Proteomics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_QM_MM.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Quantum_biology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Quantum_mechanics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_RNA.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Reaction.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Redox.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Reinforcement_learning.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Reproduction_number.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Rosettafold.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Score.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Screening.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Sensors.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Sequencing.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Signaling.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Single_cell.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Spatial_Transcriptomics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Spatial_biology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Spectrometry.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Stochastic_modeling.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_System_biology.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Transcription.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Transcriptomics.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Transformer.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Translation.csv filter=lfs diff=lfs merge=lfs -text
+data/dataset_Variational_autoencoders.csv filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,150 @@
+---
+license: apache-2.0
+task_categories:
+  - text-generation
+language:
+  - code
+tags:
+  - code
+  - scientific-computing
+  - domain-specific
+  - chemistry
+  - biology
+  - physics
+size_categories:
+  - 1M<n<10M
+---
+
+# DATA1: Domain-Specific Code Dataset
+
+## Dataset Overview
+
+DATA1 is a large-scale domain-specific code dataset focusing on code samples from interdisciplinary fields such as biology, chemistry, materials science, and related areas. The dataset is collected and organized from GitHub repositories, covering 178 different domain topics with over 1.1 billion lines of code.
+
+## Dataset Statistics
+
+- **Total Datasets**: 178 CSV files
+- **Total Data Size**: ~115 GB
+- **Total Lines of Code**: Over 1.1 billion lines
+- **Data Format**: CSV (Comma-Separated Values)
+- **Encoding**: UTF-8
+
+## Dataset Structure
+
+Each CSV file corresponds to a specific domain topic, with the naming format `dataset_{Topic}.csv`, where `{Topic}` is the domain keyword (e.g., Protein, Drug, Genomics).
+
+### Data Field Description
+
+Each CSV file contains the following fields:
+
+| Field Name | Type | Description |
+|------------|------|-------------|
+| `keyword` | String | Domain keyword used to identify the domain of the code sample |
+| `repo_name` | String | GitHub repository name (format: owner/repo) |
+| `file_path` | String | Relative path of the file in the repository |
+| `file_extension` | String | File extension (e.g., .py, .java, .cpp) |
+| `file_size` | Integer | File size in bytes |
+| `line_count` | Integer | Number of lines of code in the file |
+| `content` | String | Complete file content |
+| `language` | String | Programming language (e.g., Python, Java, C++) |
+
+## Domain Categories
+
+The dataset covers the following major domain categories:
+
+### Biology-Related
+- **Molecular Biology**: Protein, DNA, RNA, Gene, Enzyme, Receptor, Ligand
+- **Cell Biology**: Cell_biology, Single_cell, Cell_atlas, Organoid
+- **Genomics**: Genomics, Genotype, Phenotype, Epigenetics, Metagenomics
+- **Transcriptomics**: Transcriptomics, Spatial_Transcriptomics, Transcription, Translation
+- **Proteomics**: Proteomics, Protein_Protein_Interactions, Folding
+- **Metabolomics**: Metabolomics, Metabolic, Lipidomics, Glycomics
+- **Systems Biology**: System_biology, Signaling, Pathway, Networks
+
+### Chemistry-Related
+- **Computational Chemistry**: Computational_Chemistry, Quantum_Chemistry, DFT, QM_MM
+- **Medicinal Chemistry**: Drug, ADMET, QSAR, Docking, Lead_discovery, Lead_optimization
+- **Materials Chemistry**: Material, Crystal, Conformation, Chemical_space
+- **Reaction Chemistry**: Reaction, Kinetics, Mechanism, Redox
+
+### Medicine and Pharmacology
+- **Pharmacology**: Pharmacology, Pharmacokinetics, Pharmacogenomics, Pharmacogenetics
+- **Medicine**: Medicine, Disease, Diagnostics, Pathology, Vaccine
+- **Toxicology**: Toxicology, Biomarker, Marker
+
+### Computational Methods
+- **Machine Learning**: Transformer, GAN, VAE, Diffusion, Flow_matching, Reinforcement_learning
+- **Quantum Computing**: Quantum_mechanics, Quantum_biology, Electronic_structure
+- **Modeling Methods**: Modeling, Multi_scale_modeling, Agent_based_model, Stochastic_modeling
+- **Numerical Methods**: Monte_Carlo, Finite_element_method, Phase_field_technique
+
+### Other Specialized Fields
+- **Bioinformatics**: Bioinformatics, Cheminformatics, Next_generation_sequencing
+- **Bioengineering**: Bioengineering, Biotechnology, Biosensors
+- **Immunology**: Immunology, Antibody, Antigen, Antagonist
+- **Virology**: Viral, Pandemic, Pathogens, AMR (Antimicrobial Resistance)
+
+## Data Source
+
+The data is collected from open-source repositories on GitHub through the following process:
+
+1. **Keyword Search**: Search for relevant repositories on GitHub using domain-specific keywords
+2. **Repository Filtering**: Filter repositories based on relevance scores and code quality
+3. **File Extraction**: Extract code files from filtered repositories
+4. **Categorization**: Classify files into corresponding topic datasets based on keywords and domain characteristics
+
+## Dataset Characteristics
+
+1. **Wide Domain Coverage**: Covers multiple interdisciplinary fields including biology, chemistry, materials science, and medicine
+2. **Diverse Code Types**: Includes multiple programming languages such as Python, Java, C++, R, and MATLAB
+3. **Large Scale**: Over 1.1 billion lines of code with a total data size of 115 GB
+4. **Structured Storage**: Each domain topic is stored independently as a CSV file for convenient on-demand usage
+5. **Rich Metadata**: Contains comprehensive metadata including repository information, file paths, and language types
+
+## Usage Guidelines
+
+### Data Loading
+
+```python
+import pandas as pd
+
+# Load dataset for a specific domain
+df = pd.read_csv('dataset_Protein.csv')
+
+# View basic dataset information
+print(f"Dataset size: {len(df)} files")
+print(f"Programming language distribution: {df['language'].value_counts()}")
+print(f"File type distribution: {df['file_extension'].value_counts()}")
+```
+
+### Data Filtering
+
+```python
+# Filter by programming language
+python_files = df[df['language'] == 'Python']
+
+# Filter by file size (e.g., files smaller than 100KB)
+small_files = df[df['file_size'] < 100000]
+
+# Filter by line count
+medium_files = df[(df['line_count'] > 50) & (df['line_count'] < 1000)]
+```
+
+### Domain-Specific Analysis
+
+```python
+# Analyze code characteristics for a specific domain
+protein_df = pd.read_csv('dataset_Protein.csv')
+print(f"Number of code files in Protein domain: {len(protein_df)}")
+print(f"Average file size: {protein_df['file_size'].mean():.2f} bytes")
+print(f"Average line count: {protein_df['line_count'].mean():.2f} lines")
+```
+
+## Important Notes
+
+1. **File Size**: Some dataset files are large (up to several GB), please be mindful of memory usage when loading
+2. **Encoding**: All files use UTF-8 encoding; ensure proper handling of special characters if encountered
+3. **Data Quality**: Data is sourced from public repositories and may vary in code quality; preprocessing is recommended before use
+4. **License Compliance**: Please comply with the license requirements of the original repositories when using the data
+
+

data/dataset_2D.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0620bded2a39990458f05c32a8b48c1cde5b128c7d1e5cd60cca23f03526c5b
+size 114408225

data/dataset_3D.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9465cfacec422939059b5315ff0a200f254f8f9cc78ea4c78707186b2d751aba
+size 4534234376

data/dataset_AMR.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac9cdc76976729284244511d29efa15cd5714a2801788f6e5735d658157beb64
+size 115785642

data/dataset_Ab_initio.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c265a75ded3a89baddc37405f88278118ae5ea69bfcbcb501111b40b8fda2a5
+size 126307508

data/dataset_Absorption.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79b0d1163d9016986276dc615f6968d0abdd25351e506b362613c0a3e93fa1c5
+size 161543122

data/dataset_Activation.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b20717efa055c630d0fb3fbf5173381212b3267dde1200e803e42b9ebe0b732b
+size 5981782032

data/dataset_Agent_based_model.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21295c6bbbc80ce1713f0ef17e047a6073b2bb602830eb7ef50fcff281a0991d
+size 182081411

data/dataset_Anomaly_detection.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5e8830c4f43fc668123a5a8fa6bc8d19578b454613a4a1c285b11db8f1f0773
+size 98558570

data/dataset_Antagonist.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b22ddc4a72da52bb1f48987e22bfd78c298bcc083ca6cc831eca9acf93b1714
+size 18356896

data/dataset_Antibody.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f345d73b836ed1336ebfa3e4926fa13b66cbfd93ee2633dc8d30d47b8844881
+size 848909782

data/dataset_Antigen.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dcaeb7286f3fc7da58de322b271239a583ccbce6c9884df4893afac05595384
+size 142704238

data/dataset_Autoregressive.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:509947ff6d9c605f84d427b1c68f088b01ff87793f7ba8bff51a9c9ad1545a9c
+size 149122966

data/dataset_Bio.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97605fb27851febe0dd70d540a23b625c8c21022526950df00afd227d0e12f17
+size 52464173

data/dataset_Biochemistry.csv

@@ -0,0 +1,968 @@
+"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language"
+"Biochemistry","Bin-Cao/TCLRmodel","Template/Execution template/template.py",".py","5138","104","#coding=utf-8
+from TCLR import TCLRalgorithm as model
+
+
+""""""
+    :param correlation : {'PearsonR(+)','PearsonR(-)',''MIC','R2'}，default PearsonR(+).
+            Methods:
+            * PearsonR: (+)(-). for linear relationship.
+            * MIC for no-linear relationship.
+            * R2 for no-linear relationship.
+
+    :param tolerance_list: constraints imposed on features, default is null
+            list shape in two dimensions, viz., [[constraint_1,tol_1],[constraint_2,tol_2]...]
+            constraint_1, constraint_2 （string） are the feature name ; 
+            tol_1, tol_2 （float）are feature's tolerance ratios;
+            relative variation range of features must be within the tolerance;
+            example: tolerance_list = [['feature_name1',0.2],['feature_name2',0.1]].
+    
+    :param gpl_dummyfea: dummy features in gpleran regression, default is null
+            list shape in one dimension, viz., ['feature_name1','feature_name2',...]
+            dummy features : 'feature_name1','feature_name2',... are not used anymore in gpleran regression     
+            
+    :param minsize : a int number (default=3), minimum unique values for linear features of data on each leaf.
+    
+    :param threshold : a float (default=0.9), less than or equal to 1, default 0.95 for PearsonR.
+            In the process of dividing the dataset, the smallest relevant index allowed in the you research.
+            To avoid overfitting, threshold = 0.5 is suggested for MIC 0.5.
+    
+    :param mininc : Minimum expected gain of objective function (default=0.01)
+    
+    :param split_tol : a float (default=0.8), constrained features value shound be narrowed in a minmimu ratio of split_tol on split path
+
+    :param gplearn : Whether to call the embedded gplearn package of TCLR to regress formula (default=False).
+    
+    :param population_size : integer, optional (default=500), the number of programs in each generation.
+    
+    :param generations : integer, optional (default=100),the number of generations to evolve.
+
+    :param verbose : int, optional (default=0). Controls the verbosity of the evolution building process.
+    
+    :param metric : str, optional (default='mean absolute error')
+            The name of the raw fitness metric. Available options include:
+            - 'mean absolute error'.
+            - 'mse' for mean squared error.
+            - 'rmse' for root mean squared error.
+            - 'pearson', for Pearson's product-moment correlation coefficient.
+            - 'spearman' for Spearman's rank-order correlation coefficient.
+    
+    :param function_set : iterable, optional (default=['add', 'sub', 'mul', 'div', 'log', 'sqrt', 
+                                               'abs', 'neg','inv','sin','cos','tan', 'max', 'min'])
+            The functions to use when building and evolving programs. This iterable can include strings 
+            to indicate either individual functions as outlined below.
+            Available individual functions are:
+            - 'add' : addition, arity=2.
+            - 'sub' : subtraction, arity=2.
+            - 'mul' : multiplication, arity=2.
+            - 'div' : protected division where a denominator near-zero returns 1.,
+                arity=2.
+            - 'sqrt' : protected square root where the absolute value of the
+                argument is used, arity=1.
+            - 'log' : protected log where the absolute value of the argument is
+                used and a near-zero argument returns 0., arity=1.
+            - 'abs' : absolute value, arity=1.
+            - 'neg' : negative, arity=1.
+            - 'inv' : protected inverse where a near-zero argument returns 0.,
+                arity=1.
+            - 'max' : maximum, arity=2.
+            - 'min' : minimum, arity=2.
+            - 'sin' : sine (radians), arity=1.
+            - 'cos' : cosine (radians), arity=1.
+            - 'tan' : tangent (radians), arity=1.
+
+    Algorithm Patent No. : 2021SR1951267, China
+    Reference : Domain knowledge guided interpretive machine learning ——  Formula discovery for the oxidation behavior of Ferritic-Martensitic steels in supercritical water. Bin Cao et al., 2022, JMI, journal paper.
+    DOI : 10.20517/jmi.2022.04
+""""""
+
+
+dataSet = ""testdata.csv""
+correlation = 'PearsonR(+)'
+tolerance_list = [
+    ['E_Cr_split_feature_1',0.001],
+]
+
+gpl_dummyfea = ['ln(t)_split_feature_4',]
+minsize = 3
+threshold = 0.9
+mininc = 0.01
+split_tol = 0.8
+gplearn = True
+population_size = 500
+generations = 100
+verbose = 1 
+metric = 'mean absolute error'
+function_set = ['add', 'sub', 'mul', 'div', 'log', 'sqrt', 'abs', 'neg','inv','sin','cos','tan', 'max', 'min']
+
+
+model.start(filePath = dataSet, correlation = correlation, tolerance_list = tolerance_list, gpl_dummyfea = gpl_dummyfea, minsize = minsize, threshold = threshold,
+            mininc = mininc ,split_tol = split_tol, gplearn = gplearn,  population_size = population_size,
+            generations = generations,verbose = verbose, metric =metric, function_set =function_set)
+
+
+
+","Python"
+"Biochemistry","Bin-Cao/TCLRmodel","TCLR/TCLRalgorithm.py",".py","38792","861","""""""
+    Tree Classifier for Linear Regression (TCLR) 
+    Author : Bin CAO (binjacobcao@gmail.com) 
+
+    TCLR is a new tree model proposed by Professor T-Y Zhang and Mr. Bin Cao et al. for capturing the functional relationships 
+    between features and target variables. The model partitions the feature space into a set of rectangles, with each partition
+    embodying a specific function. This approach is conceptually simple, yet powerful for distinguishing mechanisms. The entire
+    feature space is divided into disjointed unit intervals by hyperplanes parallel to the coordinate axes. Within each partition,
+    the target variable y is modeled as a linear function of a feature xj (j = 1,⋯,m), which is the linear function used in our studied problem.
+    
+    Patent No. : 2021SR1951267, China
+    Reference : Domain knowledge guided interpretive machine learning ——  Formula discovery for the oxidation behavior of Ferritic-Martensitic steels in supercritical water. Bin Cao et al., 2022, JMI, journal paper.
+    DOI : 10.20517/jmi.2022.04
+""""""
+
+import math
+import re
+from tabnanny import check
+from textwrap import indent
+import time
+import copy
+import os
+import warnings
+import random
+from typing import List
+import numpy as np
+import pandas as pd
+from graphviz import Digraph
+from scipy import stats
+from gplearn import genetic
+from minepy import MINE
+
+
+# Define the basic structure of a Tree Model - Node
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.lc = None
+        self.rc = None
+        self.slope = None
+        self.intercept = None
+        self.size = data.shape[0]
+        self.R = 0
+        self.bestFeature = 0
+        self.bestValue = 0
+        self.leaf_no = -1
+
+
+def start(filePath, correlation='PearsonR(+)', minsize=3, threshold=0.95, mininc=0.01, split_tol = 0.8, epochs = 5,random_seed=42, Generate_Features = True, tolerance_list = None , weight=True,
+         gplearn = False, gpl_dummyfea = None, population_size = 500, generations = 100, verbose = 1, 
+         metric = 'mean absolute error',
+         function_set = ['add', 'sub', 'mul', 'div', 'log', 'sqrt', 'abs', 'neg','inv','sin','cos','tan',]):
+    
+    """"""
+    Tree Classifier for Linear Regression (TCLR) 
+
+    TCLR is a new tree model proposed by Professor T-Y Zhang and Mr. Bin Cao et al. for capturing the functional relationships 
+    between features and target variables. The model partitions the feature space into a set of rectangles, with each partition
+    embodying a specific function. This approach is conceptually simple, yet powerful for distinguishing mechanisms. The entire
+    feature space is divided into disjointed unit intervals by hyperplanes parallel to the coordinate axes. Within each partition,
+    the target variable y is modeled as a linear function of a feature xj (j = 1,⋯,m), which is the linear function used in our studied problem.
+    
+    Patent No. : 2021SR1951267, China
+    Reference : Domain knowledge guided interpretive machine learning ——  Formula discovery for the oxidation behavior of Ferritic-Martensitic steels in supercritical water. Bin Cao et al., 2022, JMI, journal paper.
+    DOI : 10.20517/jmi.2022.04
+
+    :param correlation : {'PearsonR(+)','PearsonR(-)',''MIC','R2'}, default PearsonR(+).
+            Methods:
+            * PearsonR: (+)(-). for linear relationship.
+            * MIC for no-linear relationship.
+            * R2 for no-linear relationship.
+
+            The evaluation factor for capture the functional relationship between feature and response
+            1>
+            PearsonR:
+            Pearson correlation coefficient, also known as Pearson's r, the Pearson product-moment correlation coefficient.
+            PearsonR is a measure of linear correlation between two sets of data. 
+            PearsonR = Cov(X,Y) / (sigmaX * sigmaY)
+        
+            2>
+            MIC:
+            The maximal information coefficient (MIC). MIC captures a wide range of associations both functional and not, 
+            and for functional relationships provides a score that roughly equals the coefficient of determination (R2) of 
+            the data relative to the regression function.  MIC belongs to a larger class of maximal information-based 
+            nonparametric exploration (MINE) statistics for identifying and classifying relationship.  
+            Reference : Reshef, D. N., Reshef, Y. A., Finucane, H. K., Grossman, S. R., McVean, G., Turnbaugh, P. J., ... 
+            and Sabeti, P. C. (2011). Detecting novel associations in large data sets. science, 334(6062), 1518-1524.
+            
+            3>
+            R2:
+            In statistics, the coefficient of determination, denoted R2 or r2 and pronounced ""R squared"", 
+            is the proportion of the variation in the dependent variable that is predictable from the independent variable(s).
+            t is a statistic used in the context of statistical models whose main purpose is either the prediction of future 
+            outcomes or the testing of hypotheses, on the basis of other related information. It provides a measure of how well
+            observed outcomes are replicated by the model, based on the proportion of total variation of outcomes explained by the model.
+            Definition from Wikipedia : https://en.wikipedia.org/wiki/Coefficient_of_determination
+            R2 = 1 - SSres / SStot. Its value may be a negative one for poor correlation.
+ 
+  
+    :param minsize : 
+            a int number (default=3), minimum unique values for linear features of data on each leaf.
+    
+    :param threshold : 
+            a float (default=0.9), less than or equal to 1, default 0.95 for PearsonR.
+            In the process of dividing the dataset, the smallest relevant index allowed in the you research.
+            To avoid overfitting, threshold = 0.5 is suggested for MIC 0.5.
+    
+    :param mininc : Minimum expected gain of objective function (default=0.01)
+
+    :param split_tol : a float (default=0.8), constrained features value shound be narrowed in a minmimu ratio of split_tol on split path
+
+    :param epochs : an integer (default=5), see parameter Generate_Features (below)
+
+    :param random_seed :  an integer (default=42), see parameter Generate_Features (below)
+
+    :param Generate_Features : boole (default=True). When Generate_Features = True, TCLR will generate new features by operating  
+        the ['+','-','*'] on original features. Iterating [param : epoachs] times, and each time generating 3 new features.  [param : random_seed]
+        is used to control the randomness.
+        When Generate_Features = False, TCLR will apply the original features
+
+    :param tolerance_list: 
+            constraints imposed on features, default is null
+            list shape in two dimensions, viz., [['feature_name1',tol_1],['feature_name2',tol_2]...]
+            'feature_name1', 'feature_name2' (string) are names of input features;
+            tol_1, tol_2 (float, between 0 to 1) are feature's tolerance ratios;
+            the variations of feature values on each leaf must be in the tolerance;
+            if tol_1 = 0, the value of feature 'feature_name1' must be a constant on each leaf,
+            if tol_1 = 1, there is no constraints on value of feature 'feature_name1';
+            example: tolerance_list = [['feature_name1',0.2],['feature_name2',0.1]].
+
+    :param weight:
+            The weight of the gain function, default is True.
+            When weight is True: linear_gain = R(father node) - ( W_l * R(left child node) + W_r * R(right child node)) / 2
+            Where W_l is the ratio of the number of samples in the left child node to the total number of samples ;
+                  W_r is the ratio of the number of samples in the right child node to the total number of samples.
+            When weight is False: linear_gain = R(father node) - ( R(left child node) + R(right child node)) / 2
+
+    :param gplearn : Whether to call the embedded gplearn package of TCLR to regress formula (default=False).
+    
+    :param gpl_dummyfea: 
+            dummy features in gpleran regression, default is null
+            list shape in one dimension, viz., ['feature_name1','feature_name2',...]
+            dummy features : 'feature_name1','feature_name2',... are not used anymore in gpleran regression 
+
+    :param population_size : integer, optional (default=500), the number of programs in each generation.
+    
+    :param generations : integer, optional (default=100),the number of generations to evolve.
+
+    :param verbose : int, optional (default=0). Controls the verbosity of the evolution building process.
+    
+    :param metric : 
+            str, optional (default='mean absolute error')
+            The name of the raw fitness metric. Available options include:
+            - 'mean absolute error'.
+            - 'mse' for mean squared error.
+            - 'rmse' for root mean squared error.
+            - 'pearson', for Pearson's product-moment correlation coefficient.
+            - 'spearman' for Spearman's rank-order correlation coefficient.
+    
+    :param function_set : 
+            iterable, optional (default=['add', 'sub', 'mul', 'div', 'log', 'sqrt', 
+                                               'abs', 'neg','inv','sin','cos','tan', 'max', 'min'])
+            The functions to use when building and evolving programs. This iterable can include strings 
+            to indicate either individual functions as outlined below.
+            Available individual functions are:
+            - 'add' : addition, arity=2.
+            - 'sub' : subtraction, arity=2.
+            - 'mul' : multiplication, arity=2.
+            - 'div' : protected division where a denominator near-zero returns 1.,
+                arity=2.
+            - 'sqrt' : protected square root where the absolute value of the
+                argument is used, arity=1.
+            - 'log' : protected log where the absolute value of the argument is
+                used and a near-zero argument returns 0., arity=1.
+            - 'abs' : absolute value, arity=1.
+            - 'neg' : negative, arity=1.
+            - 'inv' : protected inverse where a near-zero argument returns 0.,
+                arity=1.
+            - 'max' : maximum, arity=2.
+            - 'min' : minimum, arity=2.
+            - 'sin' : sine (radians), arity=1.
+            - 'cos' : cosine (radians), arity=1.
+            - 'tan' : tangent (radians), arity=1.
+    
+    Exampel :
+    #coding=utf-8
+    from TCLR import TCLRalgorithm as model
+
+    dataSet = ""testdata.csv""
+    correlation = 'PearsonR(+)'
+    minsize = 3
+    threshold = 0.9
+    mininc = 0.01
+    split_tol = 0.8
+
+    model.start(filePath = dataSet, correlation = correlation, minsize = minsize, threshold = threshold,
+                mininc = mininc ,split_tol = split_tol,)
+    """"""
+
+    os.makedirs('Segmented', exist_ok=True)
+    # global var. for statisticaling  results
+    global record
+    record = 0
+    timename = time.localtime(time.time())
+    namey, nameM, named, nameh, namem = timename.tm_year, timename.tm_mon, timename.tm_mday, timename.tm_hour, timename.tm_min
+
+    read_csvData = pd.read_csv(filePath)
+
+    input_csvData = read_csvData.iloc[:,:-2]
+    if Generate_Features == True:
+        # cal an appropriate value of batch
+        if len(input_csvData) - 1 <= 3:
+            batch = 1
+        else:
+            batch = 3
+        # generate new dataset
+        for epoch in range(epochs):
+            # for increasing the randomness
+            random_seed += 1
+            input_csvData = generate_random_features(input_csvData,[column for column in input_csvData],batch,random_seed)
+           
+        input_csvData = input_csvData.assign(linear_X=read_csvData.iloc[:,-2])
+        csvData = input_csvData.assign(linear_Y=read_csvData.iloc[:,-1])
+
+    else:
+        csvData = read_csvData
+    
+    
+    copy_csvData = copy.deepcopy(csvData)
+    copy_csvData['slope'] = None
+    copy_csvData['intercept'] = None
+    copy_csvData[correlation] = None
+    copy_csvData.to_csv('Segmented/all_dataset.csv', index=False)
+
+    feats = [column for column in csvData]
+    csvData = np.array(csvData)
+    root, _ = createTree(csvData, csvData, feats, 0, correlation,tolerance_list, minsize, threshold, mininc, split_tol,weight)
+    
+    print('All non-image results have been successfully saved!')
+    print('#'*80,'\n')
+   
+    # excute gplearn 
+    if gplearn == True :
+        if correlation == 'MIC' or correlation == 'R2':
+            print('{name} is a non-linear correlation metrics'.format(name = correlation ))
+            print('This is illegal, linear slopes are only allowed to generate when PearsonR is chosen')
+        elif correlation == 'PearsonR(+)' or correlation == 'PearsonR(-)':
+            sr_data = pd.read_csv('Segmented/all_dataset.csv')
+            sr_featurname = sr_data.columns
+            sr_data = np.array(sr_data)
+
+            if gpl_dummyfea == None: 
+
+                gpmodel = genetic.SymbolicRegressor(
+                    population_size = population_size, generations = generations, 
+                    verbose = verbose,feature_names = sr_featurname[:-4],function_set = function_set,
+                    metric = metric
+                    )
+                formula = gpmodel.fit(sr_data[:,:-4], sr_data[:,-3])
+                score = gpmodel.score(sr_data[:,:-4], sr_data[:,-3])
+                print( 'slope = ' + str(formula))
+
+            else:
+                # fea_num --> fea_loc
+                dummyfea = []
+                for i in range(len(gpl_dummyfea)):
+                    index = feats.index(gpl_dummyfea[i])
+                    dummyfea.append(index)
+                # remove fea_loc
+                index_array = [i for i in range(len(sr_featurname)-4)]
+                for i in range(len(gpl_dummyfea)):
+                    index_array.remove(dummyfea[i])
+                
+                gpmodel = genetic.SymbolicRegressor(
+                    population_size = population_size, generations = generations, 
+                    verbose = verbose,feature_names = sr_featurname[index_array],function_set = function_set,
+                    metric = metric
+                    )
+                formula = gpmodel.fit(sr_data[:,index_array], sr_data[:,-3])
+                score = gpmodel.score(sr_data[:,index_array], sr_data[:,-3])
+                print( 'slope = ' + str(formula))
+
+          
+            with open(os.path.join('Segmented', 'A_formula derived by gplearn.txt'), 'w') as wfid:
+                    print('Formula : ', file=wfid)
+                    print(str(formula), file=wfid)
+                    print('Fitness : ', file=wfid)
+                    print(str(metric) + ' = ' + str(score), file=wfid)
+                    print('\n', file=wfid)
+                    print('#'*80, file=wfid)
+                    print('Symbols annotation:', file=wfid)
+                    print('- add : addition, arity=2.', file=wfid)
+                    print('- sub : subtraction, arity=2.', file=wfid) 
+                    print('- mul : multiplication, arity=2.', file=wfid) 
+                    print('- div : protected division where a denominator near-zero returns 1.', file=wfid) 
+                    print('- sqrt : protected square root where the absolute value of the argument is used.', file=wfid) 
+                    print('- log : protected log where the absolute value of the argument is used.', file=wfid) 
+                    print('- abs : absolute value, arity=1.', file=wfid) 
+                    print('- neg : negative, arity=1.', file=wfid) 
+                    print('- inv : protected inverse where a near-zero argument returns 0.', file=wfid)  
+                    print('- max : maximum, arity=2.', file=wfid) 
+                    print('- sin : sine (radians), arity=1.', file=wfid) 
+                    print('- cos : cosine (radians), arity=1.', file=wfid)
+                    print('- tan : tangent (radians), arity=1.', file=wfid)  
+                 
+                        
+            
+    elif gplearn == False:
+        pass
+    
+
+    try:
+        # generate figure in pdf
+        warnings.filterwarnings('ignore')
+        dot = Digraph(comment='Result of TCLR')
+        render('A', root, dot, feats)
+        dot.render(
+            'Result of TCLR {year}.{month}.{day}-{hour}.{minute}'.format(year=namey, month=nameM, day=named, hour=nameh,
+                                                                        minute=namem))
+        return True
+    except :
+        print('Can not generate the Tree plot !')
+        print('Please ensure that the executable files of Graphviz are present on your system.')
+        print('See : https://github.com/Bin-Cao/TCLRmodel/tree/main/User%20Guide')
+        return True 
+  
+
+
+# Capture the functional relationships between features and target
+# Partitions the feature space into a set of rectangles,
+def createTree(dataSet, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight):
+    # It is a  positive linear relationship
+    if correlation == 'PearsonR(+)':
+        node = Node(dataSet)
+        # Initial R0
+        bestR = PearsonR(dataSet[:, -2], dataSet[:, -1])
+        node.R = bestR
+        __slope = stats.linregress(dataSet[:, -2], dataSet[:, -1])[0]
+        node.slope = __slope
+        node.intercept = stats.linregress(dataSet[:, -2], dataSet[:, -1])[1]
+        if bestR >= threshold and fea_tol(dataSet,ori_dataset,feats,tolerance_list) == True:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            write_csv(node, feats, True, correlation)
+            return node, leaf_no
+        # Leave the last two columns of DataSet, a feature of interest and a response
+        numFeatures = len(dataSet[0]) - 2
+        splitSuccess = False
+        bestFeature = -1
+        bestValue = 0
+
+        check_valve = False
+        for i in range(numFeatures):
+            featList = [example[i] for example in dataSet]
+            uniqueVals = sorted(list(set(featList)))
+            for value in range(len(uniqueVals) - 1):
+                # constraints imposed on features  (greater tolerance in split process)
+                if not fea_tol_split(dataSet,ori_dataset,feats,tolerance_list,split_tol):
+                    continue
+                subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+                
+                if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                        subDataSetB[:, -2]).size <= minsize - 1:
+                    continue
+                
+                R = weight_gain(subDataSetA,subDataSetB,weight,0)
+
+                if R - bestR >= mininc:
+                    check_valve = True
+                    splitSuccess = True
+                    bestR = R
+                    lc = subDataSetA
+                    rc = subDataSetB
+                    bestFeature = i
+                    bestValue = uniqueVals[value]
+                
+        if check_valve == False:
+            for i in range(numFeatures):
+                featList = [example[i] for example in dataSet]
+                uniqueVals = sorted(list(set(featList)))
+                for value in range(len(uniqueVals) - 1):
+                    subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+                    
+                    if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                            subDataSetB[:, -2]).size <= minsize - 1:
+                        continue
+
+                    R = weight_gain(subDataSetA,subDataSetB,weight,0)
+
+                    if R - bestR >= mininc:
+                        splitSuccess = True
+                        bestR = R
+                        lc = subDataSetA
+                        rc = subDataSetB
+                        bestFeature = i
+                        bestValue = uniqueVals[value]
+            else:
+                pass
+                        
+
+        # The recursive boundary is unable to find a division node that can increase factor(R, MIC, R2) by mininc or more.
+        if splitSuccess:
+            node.lc, leaf_no = createTree(lc, ori_dataset,feats, leaf_no, correlation, tolerance_list,minsize, threshold, mininc,split_tol,weight)
+            node.rc, leaf_no = createTree(rc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.bestFeature, node.bestValue = bestFeature, bestValue
+
+        # This node is leaf
+        if node.lc is None:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            # determine if this node is to save in all_dataset.csv
+            save_in_all = False
+            if node.R >= threshold and fea_tol(node.data,ori_dataset,feats,tolerance_list) == True:
+                save_in_all = True 
+            write_csv(node, feats, save_in_all, correlation)
+
+        return node, leaf_no
+
+    # It is a negative linear relationship
+    elif correlation == 'PearsonR(-)':
+        node = Node(dataSet)
+        bestR = PearsonR(dataSet[:, -2], dataSet[:, -1])
+        node.R = bestR
+        __slope = stats.linregress(dataSet[:, -2], dataSet[:, -1])[0]
+        node.slope = __slope
+        node.intercept = stats.linregress(dataSet[:, -2], dataSet[:, -1])[1]
+        if bestR <= -threshold and fea_tol(dataSet,ori_dataset,feats,tolerance_list) == True:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            write_csv(node, feats, True, correlation)
+            return node, leaf_no
+
+        numFeatures = len(dataSet[0]) - 2
+        splitSuccess = False
+        bestFeature = -1
+        bestValue = 0
+
+        check_valve = False
+        for i in range(numFeatures):
+            featList = [example[i] for example in dataSet]
+            uniqueVals = sorted(list(set(featList)))
+            for value in range(len(uniqueVals) - 1):
+                # constraints imposed on features  (greater tolerance in split process)
+                if not fea_tol_split(dataSet,ori_dataset,feats,tolerance_list,split_tol):
+                    continue
+                subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+
+                if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                        subDataSetB[:, -2]).size <= minsize - 1:
+                    continue
+
+                
+                R = weight_gain(subDataSetA,subDataSetB,weight,0)
+
+                if R - bestR <= - mininc:
+                    check_valve = True
+                    splitSuccess = True
+                    bestR = R
+                    lc = subDataSetA
+                    rc = subDataSetB
+                    bestFeature = i
+                    bestValue = uniqueVals[value]
+
+        if check_valve == False:
+            for i in range(numFeatures):
+                featList = [example[i] for example in dataSet]
+                uniqueVals = sorted(list(set(featList)))
+                for value in range(len(uniqueVals) - 1):
+                    subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+
+                    if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                            subDataSetB[:, -2]).size <= minsize - 1:
+                        continue
+                    
+                    R = weight_gain(subDataSetA,subDataSetB,weight,0)
+
+                    if R - bestR <= - mininc:
+                        splitSuccess = True
+                        bestR = R
+                        lc = subDataSetA
+                        rc = subDataSetB
+                        bestFeature = i
+                        bestValue = uniqueVals[value]
+        else: pass
+
+        if splitSuccess:
+            node.lc, leaf_no = createTree(lc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.rc, leaf_no = createTree(rc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.bestFeature, node.bestValue = bestFeature, bestValue
+
+        if node.lc is None:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            # determine if this node is to save in all_dataset.csv
+            save_in_all = False
+            if node.R >= threshold and fea_tol(node.data,ori_dataset,feats,tolerance_list) == True:
+                save_in_all = True 
+            write_csv(node, feats, save_in_all, correlation)
+
+        return node, leaf_no
+
+    elif correlation == 'MIC':
+        node = Node(dataSet)
+        bestR = MIC(dataSet[:, -2], dataSet[:, -1])
+        node.R = bestR
+        node.slope == None
+        if bestR >= threshold and fea_tol(dataSet,ori_dataset,feats,tolerance_list) == True:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            write_csv(node, feats, True, correlation)
+            return node, leaf_no
+
+        numFeatures = len(dataSet[0]) - 2
+        splitSuccess = False
+        bestFeature = -1
+        bestValue = 0
+
+        check_valve = False
+        for i in range(numFeatures):
+            featList = [example[i] for example in dataSet]
+            uniqueVals = sorted(list(set(featList)))
+            for value in range(len(uniqueVals) - 1):
+                # constraints imposed on features  (greater tolerance in split process)
+                if not fea_tol_split(dataSet,ori_dataset,feats,tolerance_list,split_tol):
+                    continue
+                subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+                if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                        subDataSetB[:, -2]).size <= minsize - 1:
+                    continue
+                
+                R = weight_gain(subDataSetA,subDataSetB,weight,1)
+
+                if R - bestR >= mininc:
+                    check_valve = True
+                    splitSuccess = True
+                    bestR = R
+                    lc = subDataSetA
+                    rc = subDataSetB
+                    bestFeature = i
+                    bestValue = uniqueVals[value]
+
+        if check_valve == False:
+            for i in range(numFeatures):
+                featList = [example[i] for example in dataSet]
+                uniqueVals = sorted(list(set(featList)))
+                for value in range(len(uniqueVals) - 1):
+                    subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+                    if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                            subDataSetB[:, -2]).size <= minsize - 1:
+                        continue
+    
+                    R = weight_gain(subDataSetA,subDataSetB,weight,1)
+
+                    if R - bestR >= mininc:
+                        splitSuccess = True
+                        bestR = R
+                        lc = subDataSetA
+                        rc = subDataSetB
+                        bestFeature = i
+                        bestValue = uniqueVals[value]
+        else: pass
+
+        if splitSuccess:
+            node.lc, leaf_no = createTree(lc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.rc, leaf_no = createTree(rc,ori_dataset, feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.bestFeature, node.bestValue = bestFeature, bestValue
+
+        if node.lc is None:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            # determine if this node is to save in all_dataset.csv
+            save_in_all = False
+            if node.R >= threshold and fea_tol(node.data,ori_dataset,feats,tolerance_list) == True:
+                save_in_all = True 
+            write_csv(node, feats, save_in_all, correlation)
+
+        return node, leaf_no
+
+    elif correlation == 'R2':
+        node = Node(dataSet)
+        bestR = R2(dataSet[:, -2], dataSet[:, -1])
+        node.R = bestR
+        node.slope == None
+        if bestR >= threshold and fea_tol(dataSet,ori_dataset,feats,tolerance_list) == True:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            write_csv(node, feats, True, correlation)
+            return node, leaf_no
+
+        numFeatures = len(dataSet[0]) - 2
+        splitSuccess = False
+        bestFeature = -1
+        bestValue = 0
+
+        check_valve = False
+        for i in range(numFeatures):
+            featList = [example[i] for example in dataSet]
+            uniqueVals = sorted(list(set(featList)))
+            for value in range(len(uniqueVals) - 1):
+                # constraints imposed on features  (greater tolerance in split process)
+                if not fea_tol_split(dataSet,ori_dataset,feats,tolerance_list,split_tol):
+                    continue
+
+                subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+
+                if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                        subDataSetB[:, -2]).size <= minsize - 1:
+                    continue
+
+                R = weight_gain(subDataSetA,subDataSetB,weight,2)
+
+                if R - bestR >= mininc:
+                    check_valve = True
+                    splitSuccess = True
+                    bestR = R
+                    lc = subDataSetA
+                    rc = subDataSetB
+                    bestFeature = i
+                    bestValue = uniqueVals[value]
+
+        if check_valve == False:
+            for i in range(numFeatures):
+                featList = [example[i] for example in dataSet]
+                uniqueVals = sorted(list(set(featList)))
+
+                for value in range(len(uniqueVals) - 1):
+                    if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                            subDataSetB[:, -2]).size <= minsize - 1:
+                        continue
+
+                    R = weight_gain(subDataSetA,subDataSetB,weight,2)
+
+                    if R - bestR >= mininc:
+                        splitSuccess = True
+                        bestR = R
+                        lc = subDataSetA
+                        rc = subDataSetB
+                        bestFeature = i
+                        bestValue = uniqueVals[value]
+        else: pass
+        
+        if splitSuccess:
+            node.lc, leaf_no = createTree(lc, ori_dataset,feats, leaf_no, correlation, tolerance_list,minsize, threshold, mininc,split_tol)
+            node.rc, leaf_no = createTree(rc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol)
+            node.bestFeature, node.bestValue = bestFeature, bestValue
+
+        if node.lc is None:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            # determine if this node is to save in all_dataset.csv
+            save_in_all = False
+            if node.R >= threshold and fea_tol(node.data,feats,tolerance_list) == True:
+                save_in_all = True 
+            write_csv(node, feats, save_in_all, correlation)
+
+        return node, leaf_no
+
+
+def PearsonR(X, Y):
+    xBar = np.mean(X)
+    yBar = np.mean(Y)
+    SSR = 0
+    varX = 0
+    varY = 0
+    if len(X) > 1:
+        for i in range(0, len(X)):
+            diffXXBar = X[i] - xBar
+            diffYYBar = Y[i] - yBar
+            SSR += (diffXXBar * diffYYBar)
+            varX += diffXXBar ** 2
+            varY += diffYYBar ** 2
+        SST = math.sqrt(varX * varY)
+    else:
+        SST = 1
+        SSR = 0
+    if SST == 0:
+        return 0
+    return SSR / SST
+
+
+def MIC(X, Y):
+    if len(X) > 0:
+        mine = MINE(alpha=0.6, c=15)
+        mine.compute_score(X, Y)
+        return mine.mic()
+    else:
+        MICs = 0
+        return MICs
+
+
+def R2(X, Y):
+    X = np.array(X)
+    Y = np.array(Y)
+    if len(X) > 0:
+        a = (X - np.mean(Y)) ** 2
+        SStot = np.sum(a)
+        b = (X - Y) ** 2
+        SSres = np.sum(b)
+        r2 = 1 - SSres / SStot
+        return r2
+    else:
+        r2 = -10
+        return r2
+
+
+# Split the DataSet in a specific node
+def splitDataSet(dataSet, axis, value):
+    retDataSetA = []
+    retDataSetB = []
+    for featVec in dataSet:
+        if featVec[axis] <= value:
+            retDataSetA.append(featVec)
+        else:
+            retDataSetB.append(featVec)
+    return np.array(retDataSetA), np.array(retDataSetB)
+
+def fea_tol(dataSet,ori_dataSet,feats,tolerance_list):
+    if tolerance_list == None: return True
+    else:
+        record = 0
+        for i in range(len(tolerance_list)):
+            __feaname = tolerance_list[i][0]
+            __tolratio = float(tolerance_list[i][1])
+            index = feats.index(__feaname)
+            if (dataSet[:,index].max() - dataSet[:,index].min()) / (ori_dataSet[:,index].max()- ori_dataSet[:,index].min()) <= __tolratio:
+                record += 1
+        if record == len(tolerance_list):
+            return True
+
+def fea_tol_split(dataSet,ori_dataSet,feats,tolerance_list,split_tol):
+    if tolerance_list == None: return True
+    else:
+        record = 0
+        for i in range(len(tolerance_list)):
+            __feaname = tolerance_list[i][0]
+            __tolratio = float(tolerance_list[i][1])
+            criter = max(split_tol,__tolratio)
+            index = feats.index(__feaname)
+            if (dataSet[:,index].max() - dataSet[:,index].min()) / (ori_dataSet[:,index].max()- ori_dataSet[:,index].min()) <= criter:
+                record += 1
+        if record > int(0.5*len(tolerance_list)):
+            return True
+
+
+# Use graphviz to visualize the TCLR
+def render(label, node, dot, feats):
+    mark = ''
+    if node.slope == None:
+        mark = ""#="" + str(node.size) + "" , ρ="" + str(round(node.R, 3))
+    else:
+        mark = ""#="" + str(node.size) + "" , ρ="" + str(round(node.R, 3)) + ' , slope=' + str(
+            round(node.slope, 3)) + ' , intercept=' + str(round(node.intercept, 3))
+
+    if node.lc is None:
+        mark = 'No_{}, '.format(node.leaf_no) + mark
+    dot.node(label, mark)
+
+    if node.lc is not None:
+        render(label + 'A', node.lc, dot, feats)
+        render(label + 'B', node.rc, dot, feats)
+        dot.edge(label, label + 'A', feats[node.bestFeature] + ""≤"" + str(node.bestValue))
+        dot.edge(label, label + 'B', feats[node.bestFeature] + "">"" + str(node.bestValue))
+
+
+def write_csv(node, feats, save_in_all, correlation):
+    global record
+
+    frame = {}
+    for i in range(len(feats)):
+        frame[feats[i]] = node.data[:, i]
+    frame = pd.DataFrame(frame)
+
+    if node.slope == None:
+        frame['slope'] = None
+        frame['intercept'] = None
+        frame[correlation] = np.repeat(node.R, node.size)
+        frame.to_csv('Segmented/subdataset_{}.csv'.format(str(node.leaf_no)))
+    else:
+        frame['slope'] = node.slope
+        frame['intercept'] = node.intercept
+        frame[correlation] = np.repeat(node.R, node.size)
+        frame.to_csv('Segmented/subdataset_{}.csv'.format(str(node.leaf_no)))
+
+    frame.to_csv('Segmented/subdataset_{}.csv'.format(str(node.leaf_no)))
+
+    if not save_in_all:  # do not save in the all_dataset.csv
+        _all_dataset = pd.read_csv('./Segmented/all_dataset.csv')
+        _all_dataset.drop(index=range(record, record+node.size), axis=0, inplace=True)
+        _all_dataset.to_csv('Segmented/all_dataset.csv', index=False)
+        return
+
+    _all_dataset = pd.read_csv('./Segmented/all_dataset.csv')
+    for item in range(len(frame.iloc[:, 0])):
+        _all_dataset.iloc[item + record, :] = frame.iloc[item, :]
+    record += len(frame.iloc[:, 0])
+    _all_dataset.to_csv('Segmented/all_dataset.csv', index=False)
+
+def weight_gain(subDataSetA,subDataSetB,weight,matrix):
+    if matrix == 0:
+        newRa = PearsonR(subDataSetA[:, -2], subDataSetA[:, -1])
+        newRb = PearsonR(subDataSetB[:, -2], subDataSetB[:, -1])
+    elif matrix == 1:
+        newRa = MIC(subDataSetA[:, -2], subDataSetA[:, -1])
+        newRb = MIC(subDataSetB[:, -2], subDataSetB[:, -1])
+    elif matrix == 2:
+        newRa = R2(subDataSetA[:, -2], subDataSetA[:, -1])
+        newRb = R2(subDataSetB[:, -2], subDataSetB[:, -1])
+  
+
+    if weight == False:
+        R = (newRa + newRb) / 2
+        return R
+    elif weight == True:
+        weightRa = len(subDataSetA[:, -1]) / (len(subDataSetA[:, -1]) + len(subDataSetB[:, -1]))
+        weightRb = len(subDataSetB[:, -1]) / (len(subDataSetA[:, -1]) + len(subDataSetB[:, -1]))
+        R = weightRa * newRa + weightRb * newRb
+        return R
+    else:
+        print('Parameter error | weight')
+
+
+# code on 2023 May 9, Bin Cao
+def generate_random_features(df: pd.DataFrame, 
+                            feature_list: List[str],
+                            num_combinations: int,
+                             random_seed:int) -> pd.DataFrame:
+    """"""
+    randomly generates new feature combinations.
+
+    :param df: DataFrame containing the original features.
+    :param feature_list: List of original features.
+    :param num_combinations: Number of combination features to generate.
+    :return: DataFrame containing the new features.
+    """"""
+    new_features = []
+    random.seed(random_seed)
+    # randomly generates combination features
+    for i in range(num_combinations):
+        # randomly chooses two features
+        f1 = random.choice(feature_list)
+        f2 = random.choice(feature_list)
+        
+        # choose a operator
+        op = random.choice(['+', '-', '*',])
+
+        self_op1 = random.choice(['*1', '*2', '*3','*4','**2','**3'])
+        self_op2 = random.choice(['*1', '*2', '*3','*4','**2','**3'])
+        
+        new_f1 = f'{f1} {self_op1}'
+        new_f2 = f'{f2} {self_op2}'
+
+        # new feature name
+        new_feature = f'({new_f1} {op} {new_f2})'
+        
+        new_features.append(new_feature)
+        
+        # cal new features
+        df[new_feature] = eval(f'(df[""{f1}""] {self_op1}) {op} (df[""{f2}""] {self_op2})')
+    
+    # reture DataFrame 
+    return df","Python"
+"Biochemistry","Bin-Cao/TCLRmodel","Researches/Note.md",".md","38","2","# Relevant researches applied of TCLR
+","Markdown"

data/dataset_Bioinformatics.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7568d53619cdad685ef5d0593de391aaeaf60de36448791f2a4cd4e80619ab94
+size 1053278348

data/dataset_Biologics.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:651d86e23d790a0818a076c5461d4e5b2caaffc8313ab31ab57a573ed41e3782
+size 719907555

data/dataset_Biology.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:464d2634df001ff502b538b52c3826fbcd674e1b755312aade441887871ea037
+size 345150375

data/dataset_Biomarker.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e43c7f13f678ba395e1ea202a41a0535c7869cc64226d9006bb91591b64abddb
+size 26337596

data/dataset_Biomedical.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2336d0e2542c72e76f98648c0b008b24554b6d3c4e703fbf1563d3dbe4521de
+size 1104666414

data/dataset_Biosensors.csv

@@ -0,0 +1,1614 @@
+"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language"
+"Biosensors","Cassey2016/PPG_Peak_Detection","main.m",".m","3040","58","% =========================================================================
+% Below functions are the implementation for the comparison methods in
+% paper:
+% Han, Dong, Syed K. Bashar, Jesús Lázaro, Fahimeh Mohagheghian, 
+% Andrew Peitzsch, Nishat Nishita, Eric Ding, Emily L. Dickson, 
+% Danielle DiMezza, Jessica Scott, Cody Whitcomb, Timothy P. Fitzgibbons, 
+% David D. McManus, and Ki H. Chon. 2022. 
+% ""A Real-Time PPG Peak Detection Method for Accurate Determination of 
+% Heart Rate during Sinus Rhythm and Cardiac Arrhythmia"" 
+% Biosensors 12, no. 2: 82. https://doi.org/10.3390/bios12020082 
+%
+% Please cite our paper if you used our implementation code. Thank you.
+% Author: Dong Han (dong.han@uconn.edu), 01/31/2022.
+% =========================================================================
+
+% -------------------------------------------------------------------------
+% Input: 
+% PPG_raw_buffer: should be 30-sec segment.
+% fs_PPG_raw: the sampling frequency of the PPG_raw_buffer.
+% -------------------------------------------------------------------------
+%% Preparation of PPG signal:
+addpath('.\func')
+[PPG_buffer,fs_PPG] = my_func_prep_PPG_buffer(PPG_raw_buffer,fs_PPG_raw);
+
+%% Method 1: implemented method 1-a
+V_max_flag = true; % true == upper peak detection.
+addpath('.\method_01_and_02');
+output_upper_Shin_2009 = my_peak_compare_Shin_2009(PPG_buffer,fs_PPG,V_max_flag); % Implementation of Shin 2009 paper.
+
+%% Method 2: implemented method 1-b
+V_max_flag = false; % false == lower peak detection.
+output_lower_Shin_2009 = my_peak_compare_Shin_2009(PPG_buffer,fs_PPG,V_max_flag); % Implementation of Shin 2009 paper.
+
+%% Method 3 & 4: implemented method 2, it has two output peaks in ""output_Elgendi_1_2013""
+delta = 0.5; % it was 0.1 as mentioned in the paper. But I think 0.5 works better (0.5 is in the billauer's website).
+addpath('.\method_03_and_04');
+[output_Elgendi_1_2013] = my_Elgendi_2013_method_I_peakdet(PPG_buffer, delta, fs_PPG);
+
+%% Method 5: first derivative and adaptive thresholding method in Li et al. [4] and Elgendi's paper [3]
+abpsig = resample(PPG_buffer,fs_abpsig,fs_PPG_buffer); % upsampling it to 125 Hz.
+addpath('.\method_05');
+[output_Elgendi_2_2013] = my_func_ppg_peakdet_method_05_Elgendi_2013_method_II(abpsig,fs_abpsig);
+
+%% Method 6: implemented method 4
+fs_abp = 250; % Hz.
+abp = resample(PPG_buffer,fs_abp,fs_PPG); % upsampling it to 125 Hz.
+addpath('.\method_06');
+[output_Elgendi_3_2013] = my_Elgendi_2013_method_III_peakdet(abp,fs_abp);
+            
+%% Method 7: event-related moving averages with dynamic threshold method in Elgendi et al.'s paper [3] 
+addpath('.\method_07');
+[output_Elgendi_4_2013] = my_func_ppg_peakdet_method_07_Elgendi_2013_method_IV(-PPG_raw_buffer,fs_PPG_raw);
+
+%% Method 8 & 9: peak detection on Stationary Wavelet Transform of PPG signal
+fs_swt = 125; % Hz.
+PPG_swt = resample(PPG_buffer,fs_swt,fs_PPG); % upsampling it to 125 Hz.
+addpath('.\method_08_and_09');
+[output_Vadrevu_1_2019,output_Vadrevu_2_2019] = my_Vadrevu_2019_peakdet(PPG_swt,fs_swt);","MATLAB"
+"Biosensors","Cassey2016/PPG_Peak_Detection","method_07/my_func_ppg_peakdet_method_07_Elgendi_2013_method_IV.m",".m","6505","156","function output_Elgendi_4_2013 = my_func_ppg_peakdet_method_07_Elgendi_2013_method_IV(raw_PPG,fs_PPG)
+% =========================================================================
+% This is my implementation of the method IV in this paper:
+% Elgendi, Mohamed, et al. 
+% ""Systolic peak detection in acceleration photoplethysmograms measured from 
+% emergency responders in tropical conditions."" PLoS One 8.10 (2013): e76585.
+%
+% Implemented by Dong Han on 03/02/2020.
+%
+% Please cite our paper if you used this code:
+% Han, Dong, Syed K. Bashar, Jesús Lázaro, Fahimeh Mohagheghian, 
+% Andrew Peitzsch, Nishat Nishita, Eric Ding, Emily L. Dickson, 
+% Danielle DiMezza, Jessica Scott, Cody Whitcomb, Timothy P. Fitzgibbons, 
+% David D. McManus, and Ki H. Chon. 2022. 
+% ""A Real-Time PPG Peak Detection Method for Accurate Determination of 
+% Heart Rate during Sinus Rhythm and Cardiac Arrhythmia"" 
+% Biosensors 12, no. 2: 82. https://doi.org/10.3390/bios12020082 
+%
+% Please cite our paper if you used our code. Thank you.
+% =========================================================================
+%% pre-processing - bandpass filtering
+    [b, a] = butter(2,[0.5 8]/(fs_PPG/2)); % 2nd order bandpass filter 0.5-8Hz;
+    filtered_PPG = filtfilt(b, a, raw_PPG); % zero-phase filter.
+    filtered_PPG = filtered_PPG ./ std(filtered_PPG); % normalizing data is very important for my peak detection.
+    filtered_PPG = filtered_PPG - mean(filtered_PPG);
+    
+    debugging_plot_flag = false; % only for plotting debugging figures. 
+    
+    % clip the signal by keeping the signal above zero.
+    % I do not want to do this, so i will move all signal above zero.
+    S_n = filtered_PPG;
+% ---- Not following the paper to clip signal but move all signal above zero:
+%     if min(S_n) < 0
+%         Z_n = S_n - min(S_n); % elevate signal above zero.
+%     else
+%         % the minimum of S_n is still above zero, so do nothing.
+%         Z_n = S_n;
+%     end
+% ---- Following the paper: only keep the positive value:
+    Z_n = S_n;
+    Z_n(Z_n < 0) = 0; 
+%% pre-processing - squaring
+    y_n = (Z_n).^2; % element-wise power.
+%% feature extraction - generating potential blocks using two moving averages
+    W_1 = round(0.111 * fs_PPG); % mentioned as the paper by brute-force search.
+    % first moving average:
+%     MA_peak = y_n; % for the beginning and ending signal, use the original signal.
+%     for nn = 1+round(W_1/2):length(raw_PPG)-round(W_1/2)
+%         temp_range = (nn-round(W_1/2)):(nn+round(W_1/2));
+%         MA_peak(nn) = sum(y_n(temp_range))/W_1;
+%     end
+    MA_peak = movmean(y_n,W_1);
+    
+    % second moving average: 
+    W_2 = round(0.667 * fs_PPG);
+%     MA_beat = y_n;
+%     for nn = 1+round(W_2/2):length(raw_PPG)-round(W_2/2)
+%         temp_range = (nn-round(W_2/2)):(nn+round(W_2/2));
+%         MA_beat(nn) = sum(y_n(temp_range))/W_2;
+%     end
+    MA_beat = movmean(y_n,W_2);
+%% classification - thresholding
+    beta = 0.02; % from the paper, by brute force search.
+    z_bar = mean(y_n);
+    alpha = beta * z_bar; % offset level.
+    THR_1 = MA_beat + alpha;
+
+    Blocks_Of_Interest = zeros(size(MA_peak)); % I initial it as zero.
+    for nn = 1:length(MA_peak)
+        if MA_peak(nn) > THR_1(nn) % I think it is THR_1(nn).
+            Blocks_Of_Interest(nn) = 0.1;
+        else
+            % since I inital block of interest as zero, so I do not need to
+            % assign zero again.
+        end
+    end
+    
+    % searh for onset and offset of each block.
+    count_blocks = 0;
+    block_onset = NaN(size(MA_peak));
+    block_offset = NaN(size(MA_peak));
+    if any(Blocks_Of_Interest > 0) % there is a block exist.
+        for nn = 1:length(MA_peak)
+            if nn == 1 && Blocks_Of_Interest(nn) > 0
+               % the first point is a block;
+               count_blocks = count_blocks + 1; % since the block start from zero, I have to add the counter first.
+               block_onset(count_blocks,1) = nn;
+            elseif nn == length(MA_peak) && Blocks_Of_Interest(nn) > 0
+                % end with a block:
+                % no need to add count_blocks;
+                block_offset(count_blocks,1) = nn;
+            else
+                if nn > 1
+                    if Blocks_Of_Interest(nn-1) == 0 && Blocks_Of_Interest(nn) > 0 % a jump means a new block.
+                        count_blocks = count_blocks + 1;
+                        block_onset(count_blocks,1) = nn;
+                    elseif Blocks_Of_Interest(nn-1) > 0 && Blocks_Of_Interest(nn) == 0 % a drop means the end of previous block.
+                        block_offset(count_blocks,1) = nn;
+                    end
+                end
+            end
+        end
+    else
+        % there is no block existed. Check why.
+%        keyboard;
+       HR_Elgendi_4_2013 = 0; % there is no peak location.
+        S_peaks = 1;
+    output_Elgendi_4_2013 = struct('filtered_PPG_Elgendi_4_2013',S_n,...
+        'PPG_peak_loc_Elgendi_4_2013',S_peaks,...
+        'HR_Elgendi_4_2013',HR_Elgendi_4_2013);
+    return
+    end
+    
+    block_onset(isnan(block_onset)) = []; % remove extra elements.
+    block_offset(isnan(block_offset)) = []; % remove extra elements.
+    if size(block_onset,1) ~= size(block_offset,1)
+        % not same number of onset and offset, check here.
+        keyboard;
+    end
+    
+    if size(block_onset,1) ~= count_blocks
+        keyboard;
+    end
+    S_peaks = NaN(count_blocks,1);
+    THR_2 = W_1;
+    
+    for jj = 1:count_blocks
+        block_idx = [block_onset(jj,1):block_offset(jj,1)];
+        [~,I] = max(y_n(block_idx));
+        S_peaks(jj,1) = block_onset(jj,1) + I - 1;
+    end
+    
+    if debugging_plot_flag
+        figure;
+        plot(filtered_PPG);hold on;
+        plot(S_peaks,y_n(S_peaks),'r.','markersize',10);
+        plot(y_n);
+        plot(MA_peak,'k:');
+        plot(MA_beat,'r--');
+        plot(THR_1,'g.-');
+        plot(Blocks_Of_Interest*max(y_n)*10,'color',[0.5,0.5,0.5]); % grey color. I want to make block more obvious.
+        
+        legend('filtered PPG','peaks', 'squared PPG with clip to zero', 'MA peak', 'MA beat','THR 1', 'Blocks of Interest');
+    end
+    
+    if isempty(S_peaks)
+        HR_Elgendi_4_2013 = 0; % there is no peak location.
+        S_peaks = 1;
+    else
+        HR_Elgendi_4_2013 = 60 * fs_PPG ./ diff(S_peaks); % calculate the HR.
+    end
+    
+    output_Elgendi_4_2013 = struct('filtered_PPG_Elgendi_4_2013',S_n,...
+        'PPG_peak_loc_Elgendi_4_2013',S_peaks,...
+        'HR_Elgendi_4_2013',HR_Elgendi_4_2013);
+end","MATLAB"
+"Biosensors","Cassey2016/PPG_Peak_Detection","method_01_and_02/my_peak_compare_Shin_2009.m",".m","21523","388","function [output_Shin_2009] = my_peak_compare_Shin_2009(raw_PPG,fs_PPG,V_max_flag)
+% =========================================================================
+% This function is the implementation of this paper:
+% Shin, Hang Sik, Chungkeun Lee, and Myoungho Lee. 
+% ""Adaptive threshold method for the peak detection of 
+% photoplethysmographic waveform."" 
+% Computers in biology and medicine 
+% 39.12 (2009): 1145-1152.
+% 
+% Implemented by: Dong Han, on 02/10/2020.
+%
+% Please cite our paper if you used this code:
+% Han, Dong, Syed K. Bashar, Jesús Lázaro, Fahimeh Mohagheghian, 
+% Andrew Peitzsch, Nishat Nishita, Eric Ding, Emily L. Dickson, 
+% Danielle DiMezza, Jessica Scott, Cody Whitcomb, Timothy P. Fitzgibbons, 
+% David D. McManus, and Ki H. Chon. 2022. 
+% ""A Real-Time PPG Peak Detection Method for Accurate Determination of 
+% Heart Rate during Sinus Rhythm and Cardiac Arrhythmia"" 
+% Biosensors 12, no. 2: 82. https://doi.org/10.3390/bios12020082 
+%
+% Please cite our paper if you used our code. Thank you.
+% =========================================================================
+    debugging_plot_flag = false; % debugging plot. Can be false if don't want to plot anything.
+%% Section 2.4 PPG frequency analysis and filtering.
+
+    % (1): high pass >= 0.5 Hz.
+    [b, a] = butter(6,[0.5 20]/(fs_PPG/2)); % bandpass filter 0.5-10Hz, changed from 0.5-20 to 0.5-9 Hz at 11/21/2018
+    raw_PPG = filtfilt(b, a, raw_PPG); % -> AC component
+    raw_PPG = raw_PPG ./ std(raw_PPG); % normalizing data is very important for my peak detection.
+    raw_PPG = raw_PPG - mean(raw_PPG);
+%% Section 2.5 & 2.6 Peak detection algorithm & Adaptive threshold detection
+
+    % (1): bandpass filtering, no moving average filter or wavelet
+    % decomposition.
+    filtered_PPG = raw_PPG;
+    Fs = fs_PPG;
+
+    % % ===== interpolation to 1kHz of PPG: =====
+    % x = 1:length(filtered_PPG);
+    % v = filtered_PPG;
+    % 
+    % upsample_Fs = 250;
+    % xq = 1:Fs/upsample_Fs:length(filtered_PPG);
+    % vq1 = interp1(x,v,xq);
+    % 
+    % filtered_PPG = vq1;
+    % Fs = upsample_Fs; % upsampled to 1000 Hz.
+
+    % figure
+    % plot(x,v,'o',xq,vq1,':.');
+    % xlim([0 max(xq)]);
+    % title('(Default) Linear Interpolation');
+
+    % (2): V_max
+    % slope_k: k-th slope amplitude;
+    % s_r: slope changing rate (empirically: V_max = -0.6);
+    % V_n_1: previous peak amplitude;
+    % std_PPG: standard deviation of entire PPG signal;
+    % Fs: sampling frequency.
+
+    filtered_PPG = filtered_PPG(:);
+    slope_k = NaN(size(filtered_PPG)); % should be a column vector.
+    peak_loc = NaN(size(filtered_PPG)); % the array to store PPG peak index.
+    pk_idx = 1; % the counter of peaks.
+    %% Section 2.7: Peak Correction
+    refractory_period = 0.6 * Fs; % sec * sampling frequency, initial refractory period is 0.6 sec.
+
+    temp_win_left = round(0.15 * Fs); % sec * sampling frequency. This is the search region for local minima or maxima detection. chose 0.15 sec because 0.3 sec == 200 BPM.
+    temp_win_right = round(0.15 * Fs);
+
+
+    if V_max_flag % doing upper peak detection.
+        s_r = -0.6; 
+    else
+        s_r = 0.6;%0.6; % not positive because my signal is zero mean.
+        % I need to make all bottom signal positive, so I am moving them up.
+    %     move_filter_amp = min(filtered_PPG) * (-1);
+    %     filtered_PPG = filtered_PPG + move_filter_amp + std(raw_PPG); % move the lowest value more than zero.
+    end
+
+
+    slope_meet_PPG_flag = false; % mark if the slope meet PPG.
+    slope_lower_PPG_flag = false; % mark if slope is lower than PPG, once PPG amp is lower than slope, mark it back.
+    prev_slope = NaN; % First, I want to test not decreasing with PPG amplitude.
+    if debugging_plot_flag % debugging plot
+       figure;
+       plot(filtered_PPG);
+       hold on;
+    end
+    for kk = 1:length(filtered_PPG)
+        % this is for debugging:
+        if kk == 2
+            my_stop = 1;
+        end
+        if kk == 1 % initial the slope value
+            if V_max_flag
+                slope_k(1,1) = 0.2 * max(filtered_PPG);
+                std_PPG = std(filtered_PPG);
+            else
+                slope_k(1,1) = 0.2 * min(filtered_PPG); % since my signal is zero mean, I start from the negative amp. % I added what I moved.
+                std_PPG = -std(filtered_PPG);
+            end
+    %         std_PPG = std(filtered_PPG);
+            V_n_1 = slope_k(1,1);
+        else
+            if slope_meet_PPG_flag % slope has met PPG before.
+                slope_k(kk,1) = filtered_PPG(kk,1);
+                if V_max_flag % upper peak detection.
+                    if kk < 2 % in the second point of signal
+                        turn_point_flag = (slope_k(kk,1) < slope_k(kk-1,1)); % we met local maximum.
+                    else
+                        turn_point_flag = (slope_k(kk,1) < slope_k(kk-1,1)) & (slope_k(kk - 1,1) > slope_k(kk-2,1)); % we met local maximum.
+                    end
+                else
+                    if kk < 2 % in the second point of signal
+                        turn_point_flag = (slope_k(kk,1) > slope_k(kk-1,1)); % we met local minimum.
+                    else
+                        turn_point_flag = (slope_k(kk,1) > slope_k(kk-1,1)) & (slope_k(kk - 1,1) < slope_k(kk-2,1)); % we met local minimum.
+                    end
+                end
+
+                if turn_point_flag % there is a turning point.
+                    if pk_idx > 1 % not the first peak
+                        % check local maxima or minima:
+                        if (kk - temp_win_left) < 1
+                            temp_left = 1;
+                        else
+                            temp_left = kk - temp_win_left;
+                        end
+
+                        if (kk + temp_win_right) > length(filtered_PPG)
+                            temp_right = length(filtered_PPG);
+                        else
+                            temp_right = kk + temp_win_right;
+                        end
+                        temp_win = temp_left:temp_right;
+                        local_m_check = filtered_PPG(temp_win);
+                        if V_max_flag
+                            temp_m_idx = find(local_m_check > slope_k(kk - 1,1)); % check if there is another maximum than detected, remember use k-1.
+                        else
+                            temp_m_idx = find(local_m_check < slope_k(kk - 1,1)); % check if there is another minimum than detected
+                        end
+
+                        if isempty(temp_m_idx) % there is no more max or min than this peak
+                            if (kk - peak_loc(pk_idx-1,1) > refractory_period) % it is not the first peak, and the second peak is outside refractory period. It should be kk, because I have not assign the peak to the array.
+                                peak_loc(pk_idx,1) = kk-1;
+                                V_n_1 = filtered_PPG(peak_loc(pk_idx-1,1),1);% previous peak amplitude %slope_k(kk-1,1);
+                                % update refractory period:
+                                refractory_period = 0.6 * (kk - peak_loc(pk_idx-1,1)); % current index minus peak location. update the refractory peroid before updating the peak counting.
+                                pk_idx = pk_idx + 1;
+
+                                % reset slope meet flag:
+                                slope_meet_PPG_flag = false;
+                                slope_k(kk,1) = slope_k(kk - 1,1) + s_r * ((V_n_1 + std_PPG) / Fs); 
+
+                                % ---- for checking lower slope -------
+                                temp_slope_check = s_r * ((V_n_1 + std_PPG) / Fs);
+                                if V_max_flag
+                                    if temp_slope_check > 0 % upper peaks should be decreasing with negative slope.
+                                        temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
+                                        slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
+                                    end
+                                else
+                                    if temp_slope_check < 0 % upper peaks should be decreasing with negative slope.
+                                        temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
+                                        slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
+                                    end
+                                end
+                                % -------------------------------------------
+                                if V_max_flag
+                                    temp_slope_below_PPG_flag = slope_k(kk,1) < filtered_PPG(kk,1); % upper peak detection, so slope below signal.
+                                else
+                                    temp_slope_below_PPG_flag = slope_k(kk,1) > filtered_PPG(kk,1); % lower peak detection, so slope above signal.
+                                end
+                                if temp_slope_below_PPG_flag % if slope is below PPG signal, we will reset slope value to PPG amplitude.
+                                    slope_lower_PPG_flag = true; % slope is lower than PPG signal.
+                                    prev_slope = slope_k(kk,1); % store the slope value now.
+                                    slope_k(kk,1) = filtered_PPG(kk,1);
+                                end
+                                if debugging_plot_flag % debugging plot
+                                    plot(kk,slope_k(kk,1),'r.');
+                                end
+
+                            else
+                                if (kk - peak_loc(pk_idx-1,1) <= refractory_period) % it is because of the refractory period that cause the no peak. It should be kk, because I have not assign the peak to the array.                      
+                                    slope_k(kk,1) = filtered_PPG(kk,1);% from the fig.3(c) in the paper, I see they are using the signal amplitude, not slope. 
+                                    % no need to reset slope meet flag, waiting for
+                                    % next turning point.
+                                    if debugging_plot_flag % debugging plot
+                                        plot(kk,slope_k(kk,1),'r.');
+                                    end
+                                end
+                            end
+                        else % there are more peaks higher then current kk peak.
+                            if debugging_plot_flag % debugging plot
+                                plot(kk,slope_k(kk,1),'r.');
+                            end
+                        end
+                    else % the first peak, no need to check refractory period.
+                                            % check local maxima or minima:
+                        if (kk - temp_win_left) < 1
+                            temp_left = 1;
+                        else
+                            temp_left = kk - temp_win_left;
+                        end
+
+                        if (kk + temp_win_right) > length(filtered_PPG)
+                            temp_right = length(filtered_PPG);
+                        else
+                            temp_right = kk + temp_win_right;
+                        end
+                        temp_win = temp_left:temp_right;
+                        local_m_check = filtered_PPG(temp_win);
+                        if V_max_flag
+                            temp_m_idx = find(local_m_check > slope_k(kk-1,1)); % check if there is another maximum than detected, always detect previous peak.
+                        else
+                            temp_m_idx = find(local_m_check < slope_k(kk-1,1)); % check if there is another minimum than detected
+                        end
+
+                        if isempty(temp_m_idx)
+                            peak_loc(pk_idx,1) = kk-1;
+                            if pk_idx > 1
+                                V_n_1 = filtered_PPG(peak_loc(pk_idx-1,1),1);
+                            else
+                                V_n_1 = slope_k(kk-1,1);% previous peak amplitude %slope_k(kk-1,1);
+                            end
+                            pk_idx = pk_idx + 1;
+
+                            % reset slope meet flag:
+                            slope_meet_PPG_flag = false;
+                            slope_k(kk,1) = slope_k(kk - 1,1) + s_r * ((V_n_1 + std_PPG) / Fs); 
+                            % ---- for checking lower slope -------
+                            temp_slope_check = s_r * ((V_n_1 + std_PPG) / Fs);
+                            if V_max_flag
+                                if temp_slope_check > 0 % upper peaks should be decreasing with negative slope.
+                                    temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
+                                    slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
+                                end
+                            else
+                                if temp_slope_check < 0 % upper peaks should be decreasing with negative slope.
+                                    temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
+                                    slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
+                                end
+                            end
+                            % -------------------------------------------
+                            if V_max_flag
+                                temp_slope_below_PPG_flag = slope_k(kk,1) < filtered_PPG(kk,1); % upper peak detection, so slope below signal.
+                            else
+                                temp_slope_below_PPG_flag = slope_k(kk,1) > filtered_PPG(kk,1); % lower peak detection, so slope above signal.
+                            end
+
+                            if temp_slope_below_PPG_flag % if slope is below PPG signal, we will reset slope value to PPG amplitude.
+                                slope_k(kk,1) = filtered_PPG(kk,1);
+                            end
+                                if debugging_plot_flag % debugging plot
+                                    plot(kk,slope_k(kk,1),'r.');
+                                end
+                        else % there are more peaks higher then current kk peak.
+                            if debugging_plot_flag % debugging plot
+                                plot(kk,slope_k(kk,1),'r.');
+                            end
+                        end        
+                        % no need to calculate refractory period, because there is only one peak, at least two peaks can give this correctly:
+                    end
+                else
+                    % turning point did not meet, so keep decreasing or
+                    % increasing the slope.
+    %                 slope_k(kk,1) = slope_k(kk - 1,1) + s_r * ((V_n_1 + std_PPG) / Fs); 
+                    if debugging_plot_flag % debugging plot
+                        plot(kk,slope_k(kk,1),'r.');
+                    end
+                end
+            else % slope has not met PPG before. Keep decresing or increasing according to 'V_max_flag'.
+    %             if slope_lower_PPG_flag % if there is a slope lower than PPG before:
+    %                 slope_k(kk,1) = prev_slope;
+    %             else
+                    slope_k(kk,1) = slope_k(kk - 1,1) + s_r * ((V_n_1 + std_PPG) / Fs);
+                            % ---- for checking lower slope -------
+                            temp_slope_check = s_r * ((V_n_1 + std_PPG) / Fs);
+                            if V_max_flag
+                                if temp_slope_check > 0 % upper peaks should be decreasing with negative slope.
+                                    temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
+                                    slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
+                                end
+                            else
+                                if temp_slope_check < 0 % upper peaks should be decreasing with negative slope.
+                                    temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
+                                    slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
+                                end
+                            end
+                            % -------------------------------------------
+
+    %             end
+    %             if slope_k(kk,1) < filtered_PPG(kk,1) % if slope is below PPG signal, we will reset slope value to PPG amplitude.
+    %                 slope_lower_PPG_flag = true; % slope is lower than PPG signal.
+    %                 prev_slope = slope_k(kk,1); % store the slope value now.
+    %                 slope_k(kk,1) = filtered_PPG(kk,1);
+    %             elseif slope_k(kk,1) > filtered_PPG(kk,1) % slope is higher.
+    %                 slope_lower_PPG_flag = false;
+    %                 prev_slope = NaN; % reset the prev value.
+
+    %             end
+
+    %             if slope_lower_PPG_flag ~= 1 % if slope was not lower than PPG.
+    %                 % -------------- Check if two lines will meet -----------------
+    %                 PPG_x1 = kk - 1;
+    %                 PPG_x2 = kk;
+    %                 PPG_y1 = filtered_PPG(kk-1,1);
+    %                 PPG_y2 = filtered_PPG(kk,1);
+    %                 slope = s_r;
+    %                 slope_y2 = slope_k(kk,1);
+    %                 slope_y1 = slope_k(kk-1,1);
+    %                 [meet_x] = my_slope_meet_PPG(PPG_x1,PPG_x2,PPG_y1,PPG_y2,slope,slope_y2,slope_y1);
+    % 
+    %                 slope_meet_PPG_flag = (ceil(meet_x) == kk);%(slope_k(kk,1) - filtered_PPG(kk,1)) < 0.1; % 0.3 is a testing value. %slope_k(kk,1) == filtered_PPG(kk,1) % slope meets the PPG signal.
+    %             end
+                if V_max_flag
+                    slope_meet_PPG_flag = ((slope_k(kk,1) < filtered_PPG(kk,1)) & slope_k(kk - 1,1) > filtered_PPG(kk - 1,1));
+                else
+                    slope_meet_PPG_flag = ((slope_k(kk,1) > filtered_PPG(kk,1)) & slope_k(kk - 1,1) < filtered_PPG(kk - 1,1)); % lower peak use inverse amplitude.
+                end
+                % -------------------------------------------------------------
+                % I found I cannot use equal, because the PPG sampling
+                % frequency is not so high.
+                if slope_meet_PPG_flag
+                    slope_k(kk,1) = filtered_PPG(kk,1); % starts from the next index, slope == PPG amplitude.
+                else
+                    % don't need to do anything.
+                    if slope_lower_PPG_flag ~= 1 % there was no slope lower than PPG before.
+                        if V_max_flag
+                            slope_lower_PPG_flag = ((slope_k(kk,1) < filtered_PPG(kk,1)) & slope_k(kk - 1,1) == filtered_PPG(kk - 1,1)); % beginning part has same amplitude, but the ending part slope is lower.
+                        else
+                            slope_lower_PPG_flag = ((slope_k(kk,1) > filtered_PPG(kk,1)) & slope_k(kk - 1,1) == filtered_PPG(kk - 1,1)); % lower peak use inverse amplitude.
+                        end
+                        if slope_lower_PPG_flag
+                            prev_slope = slope_k(kk,1); % store the slope value now.
+                            slope_k(kk,1) = filtered_PPG(kk,1); % starts from the next index, slope == PPG amplitude.
+                        end
+                    else % there was slope lower than PPG before.
+
+                        if V_max_flag
+                            temp_PPG_below_slope_flag = filtered_PPG(kk,1) < prev_slope; % upper peak detection, so PPG below slope.
+                        else
+                            temp_PPG_below_slope_flag = filtered_PPG(kk,1) > prev_slope; % lower peak detection, so PPG above slope.
+                        end
+
+                        if temp_PPG_below_slope_flag % PPG is lower than prev slope.
+                            slope_k(kk,1) = prev_slope; % stop tracking PPG amp.
+                            slope_lower_PPG_flag = false; % reset the lower PPG flag.
+                            prev_slope = NaN;
+                        else
+                            slope_k(kk,1) = filtered_PPG(kk,1); % keep tracking PPG amp.
+                        end
+                    end
+                end
+                if debugging_plot_flag % debugging plot
+                    plot(kk,slope_k(kk,1),'r.');
+                end
+            end
+        end
+
+    end
+    % ================== IMPORTANT: clean up NaN value ========================
+    peak_loc(isnan(peak_loc)) = []; % remove empty peak loc.
+    if V_max_flag % doing upper peak detection.
+
+    else
+        % moving signal back.
+    %     filtered_PPG = filtered_PPG - move_filter_amp - std(raw_PPG); % move the lowest value more than zero.
+    %     slope_k = slope_k - move_filter_amp - std(raw_PPG); % move the slope as well.
+    end
+
+    if debugging_plot_flag % debugging plot
+        plot(peak_loc,filtered_PPG(peak_loc),'ko');
+    end
+
+    if isempty(peak_loc)
+        HR_Shin_2009 = 0; % there is no peak location.
+        peak_loc = 1;
+    else
+        HR_Shin_2009 = 60 * Fs ./ diff(peak_loc); % calculate the HR.
+    end
+
+    output_Shin_2009 = struct('PPG_peak_loc_Shin_2009',peak_loc,...
+        'slope_Shin_2009',slope_k,...
+        'filtered_PPG_Shin_2009',filtered_PPG,...
+        'HR_Shin_2009',HR_Shin_2009); 
+end","MATLAB"
+"Biosensors","Cassey2016/PPG_Peak_Detection","method_05/my_func_ppg_peakdet_method_05_Elgendi_2013_method_II.m",".m","11993","412","function [output_Elgendi_2_2013] = my_func_ppg_peakdet_method_05_Elgendi_2013_method_II(raw_PPG,fs_PPG) 
+% -------------------------------------------------------------------------
+% This peak detection function was mentioned in this paper:
+% Elgendi, Mohamed, et al. 
+% ""Systolic peak detection in acceleration photoplethysmograms measured from 
+% emergency responders in tropical conditions."" PLoS One 8.10 (2013): e76585.
+% 
+    [onsetp,peakp,dicron,abpsig] = delineator(raw_PPG,fs_PPG);
+% -------------------------------------------------------------------------
+    
+    if isempty(peakp) % there is no peak detected:
+        HR_Elgendi_2_2013 = 0; % there is no peak location.
+        peakp = 1;
+    else
+        HR_Elgendi_2_2013 = 60 * fs_PPG ./ diff(peakp); % calculate the HR.
+    end
+
+    
+    output_Elgendi_2_2013 = struct('PPG_peak_loc_Elgendi_2_2013',peakp,...
+        'HR_Elgendi_2_2013',HR_Elgendi_2_2013,...
+        'filtered_PPG_Elgendi_2_2013',abpsig);
+end
+
+function [onsetp,peakp,dicron,abpsig] = delineator(abpsig,abpfreq)
+% Below was copied from Mathwords File Exchange ""Pulse Waveform Delineator"": 
+% https://www.mathworks.com/matlabcentral/fileexchange/29484-pulse-waveform-delineator
+
+% This program is intended to delineate the fiducial points of pulse waveforms
+% Inputs:
+%   abpsig: input as original pulse wave signals;
+%   abpfreq: input as the sampling frequency;
+% Outputs:
+%   onsetp: output fiducial points as the beginning of each beat;
+%   peakp: output fiducial points as systolic peaks;
+%   dicron: output fiducial points as dicrotic notches;
+
+% Its delineation is based on the self-adaptation in pulse waveforms, but
+% not in the differentials.
+
+% Reference:
+%   BN Li, MC Dong & MI Vai (2010) 
+%   On an automatic delineator for arterial blood pressure waveforms
+%   Biomedical Signal Processing and Control 5(1) 76-81.
+
+% LI Bing Nan @ University of Macau, Feb 2007
+%   Revision 2.0.5, Apr 2009
+
+%Initialization
+peakIndex=0;
+onsetIndex=0;
+dicroIndex=0;
+stepWin=2*abpfreq;
+closeWin=floor(0.1*abpfreq);    %invalide for pulse beat > 200BPM
+
+sigLen=length(abpsig);
+
+peakp=[];
+onsetp=[];
+dicron=[];
+
+%lowpass filter at first
+coh=25;                     %cutoff frequency is 25Hz
+coh=coh*2/abpfreq;
+od=3;                       %3rd order bessel filter
+[B,A]=besself(od,coh);
+abpsig=filter(B,A,abpsig);
+abpsig=10*abpsig;
+
+abpsig=smooth(abpsig);
+
+%Compute differentials
+ttp=diff(abpsig);
+diff1(2:sigLen)=ttp;
+diff1(1)=diff1(2);
+diff1=100*diff1;
+clear ttp;
+diff1=smooth(diff1);
+
+if sigLen>12*abpfreq
+    tk=10;
+elseif sigLen>7*abpfreq
+    tk=5;
+elseif sigLen>4*abpfreq
+    tk=2;
+else
+    tk=1;
+end
+
+%Seek avaerage threshold in original signal
+if tk>1             %self-learning threshold with interval sampling
+    tatom=floor(sigLen/(tk+2));
+    for ji=1:tk       %search the slopes of abp waveforms
+        sigIndex=ji*tatom;
+        tempIndex=sigIndex+abpfreq;
+        [tempMin,jk,tempMax,jl]=seeklocales(abpsig,sigIndex,tempIndex);
+        tempTH(ji)=tempMax-tempMin;
+    end
+    abpMaxTH=mean(tempTH);
+else
+    [tempMin,jk,tempMax,jl]=seeklocales(abpsig,closeWin,sigLen);
+    abpMaxTH=tempMax-tempMin;
+end
+clear j*;
+clear t*;
+
+abpMaxLT=0.4*abpMaxTH;
+
+%Seek pulse beats by MinMax method
+% diffIndex=1;
+diffIndex=closeWin;             %Avoid filter distortion
+
+while diffIndex<sigLen
+    tempMin=abpsig(diffIndex);   %Initialization
+    tempMax=abpsig(diffIndex);
+    tempIndex=diffIndex;
+    tpeakp=diffIndex;        %Avoid initial error
+    tonsetp=diffIndex;      %Avoid initial error
+
+    while tempIndex<sigLen
+        %If no pulses within 2s, then adjust threshold and retry
+        if (tempIndex-diffIndex)>stepWin
+%             tempIndex=diffIndex-closeWin;
+            tempIndex=diffIndex;
+            abpMaxTH=0.6*abpMaxTH;
+            if abpMaxTH<=abpMaxLT
+                abpMaxTH=2.5*abpMaxLT;
+            end
+            break;
+        end
+
+        if (diff1(tempIndex-1)*diff1(tempIndex+1))<=0  %Candidate fiducial points
+            if (tempIndex+5)<=sigLen
+                jk=tempIndex+5;
+            else
+                jk=sigLen;
+            end
+            if (tempIndex-5)>=1
+                jj=tempIndex-5;
+            else
+                jj=1;
+            end
+
+            %Artifacts of oversaturated or signal loss?
+            if (jk-tempIndex)>=5
+                for ttk=tempIndex:jk
+                    if diff1(ttk)~=0
+                        break;
+                    end
+                end
+                if ttk==jk
+                    break;          %Confirm artifacts
+                end
+            end
+
+            if diff1(jj)<0          %Candidate onset
+                if diff1(jk)>0
+                    [tempMini,tmin,ta,tb]=seeklocales(abpsig,jj,jk);
+                    if abs(tmin-tempIndex)<=2
+                        tempMin=tempMini;
+                        tonsetp=tmin;
+                    end
+                end
+            elseif diff1(jj)>0      %Candidate peak
+                if diff1(jk)<0
+                    [tc,td,tempMaxi,tmax]=seeklocales(abpsig,jj,jk);
+                    if abs(tmax-tempIndex)<=2
+                        tempMax=tempMaxi;
+                        tpeakp=tmax;
+                    end
+                end
+            end
+
+            if ((tempMax-tempMin)>0.4*abpMaxTH)   %evaluation
+                if ((tempMax-tempMin)<2*abpMaxTH)
+                    if tpeakp>tonsetp
+                        %If more zero-crossing points, further refine!
+                        ttempMin=abpsig(tonsetp);
+                        ttonsetp=tonsetp;
+                        for ttk=tpeakp:-1:(tonsetp+1)
+                            if abpsig(ttk)<ttempMin
+                                ttempMin=abpsig(ttk);
+                                ttonsetp=ttk;
+                            end
+                        end
+                        tempMin=ttempMin;
+                        tonsetp=ttonsetp;
+                            
+                        if peakIndex>0
+                            %If pulse period less than eyeclose, then artifact
+                            if (tonsetp-peakp(peakIndex))<(3*closeWin)
+                                %too many fiducial points, then reset
+                                tempIndex=diffIndex;                                
+                                abpMaxTH=2.5*abpMaxLT;
+                                break;
+                            end
+                            
+                            %If pulse period bigger than 2s, then artifact
+                            if (tpeakp-peakp(peakIndex))>stepWin
+                                peakIndex=peakIndex-1;
+                                onsetIndex=onsetIndex-1;
+                                if dicroIndex>0
+                                    dicroIndex=dicroIndex-1;
+                                end
+                            end
+
+                            if peakIndex>0
+                                %new pulse beat
+                                peakIndex=peakIndex+1;
+                                peakp(peakIndex)=tpeakp;
+                                onsetIndex=onsetIndex+1;
+                                onsetp(onsetIndex)=tonsetp;
+
+                                tf=onsetp(peakIndex)-onsetp(peakIndex-1);
+
+                                to=floor(abpfreq./20);   %50ms
+                                tff=floor(0.1*tf);
+                                if tff<to
+                                    to=tff;
+                                end
+                                to=peakp(peakIndex-1)+to;
+
+                                te=floor(abpfreq./2);   %500ms
+                                tff=floor(0.5*tf);
+                                if tff<te
+                                    te=tff;
+                                end
+                                te=peakp(peakIndex-1)+te;
+                                % Dong added on 05/07/2020:
+                                % For MIMIC III PACPVC 3_2, ii = 25.
+                                if te > length(diff1)
+                                    te = length(diff1);
+                                end
+                                tff=seekdicrotic(diff1(to:te));
+                                if tff==0
+                                    tff=te-peakp(peakIndex-1);
+                                    tff=floor(tff/3);
+                                end
+                                dicroIndex=dicroIndex+1;
+                                dicron(dicroIndex)=to+tff;
+
+                                tempIndex=tempIndex+closeWin;
+                                break;
+                            end
+                        end
+                        
+                        if  peakIndex==0   %new pulse beat
+                            peakIndex=peakIndex+1;
+                            peakp(peakIndex)=tpeakp;
+                            onsetIndex=onsetIndex+1;
+                            onsetp(onsetIndex)=tonsetp;
+
+                            tempIndex=tempIndex+closeWin;
+                            break;
+                        end
+                    end
+                end
+            end
+        end
+
+        tempIndex=tempIndex+1;      %step forward
+    end
+
+%     diffIndex=tempIndex+closeWin;    %for a new beat
+    diffIndex=tempIndex+1;
+end
+
+if isempty(peakp),return;end
+%Compensate the offsets of lowpass filter
+sigLen=length(peakp);
+for diffIndex=1:sigLen          %avoid edge effect
+    tempp(diffIndex)=peakp(diffIndex)-od;
+end
+ttk=tempp(1);
+if ttk<=0
+    tempp(1)=1;
+end 
+clear peakp;
+peakp=tempp;
+clear tempp;
+
+sigLen=length(onsetp);
+for diffIndex=1:sigLen
+    tempp(diffIndex)=onsetp(diffIndex)-od;
+end
+ttk=tempp(1);
+if ttk<=0
+    tempp(1)=1;
+end 
+clear onsetp;
+onsetp=tempp;
+clear tempp;
+
+if isempty(dicron),return;end
+sigLen=length(dicron);
+for diffIndex=1:sigLen
+    if dicron(diffIndex)~=0
+        tempp(diffIndex)=dicron(diffIndex)-od;
+    else
+        tempp(diffIndex)=0;
+    end
+end
+clear dicron;
+dicron=tempp;
+clear tempp;
+end
+
+function [mini,minip,maxi,maxip]=seeklocales(tempsig,tempbegin,tempend)
+tempMin=tempsig(tempbegin);
+tempMax=tempsig(tempbegin);
+minip=tempbegin;
+maxip=tempbegin;
+for j=tempbegin:tempend
+    if tempsig(j)>tempMax
+        tempMax=tempsig(j);
+        maxip=j;
+    elseif tempsig(j)<tempMin
+        tempMin=tempsig(j);
+        minip=j;
+    end
+end
+
+mini=tempMin;
+maxi=tempMax;
+end
+
+function [dicron]=seekdicrotic(tempdiff)
+izcMin=0;
+izcMax=0;
+itemp=3;
+tempLen=length(tempdiff)-3;
+
+dicron=0;
+
+tempdiff=smooth(tempdiff);
+
+while itemp<=tempLen
+    if (tempdiff(itemp)*tempdiff(itemp+1))<=0
+        if tempdiff(itemp-2)<0
+            if tempdiff(itemp+2)>=0
+                izcMin=izcMin+1;
+                tzcMin(izcMin)=itemp;
+            end
+        end
+
+%         if tempdiff(itemp-2)>0
+%             if tempdiff(itemp+2)<=0
+%                 izcMax=izcMax+1;
+%                 tzcMax(izcMax)=itemp;
+%             end
+%         end
+    end
+
+    itemp=itemp+1;
+end
+
+if izcMin==0     %big inflection
+    itemp=3;
+    tempMin=tempdiff(itemp);
+    itempMin=itemp;
+    
+    while itemp<tempLen
+        if tempdiff(itemp)<tempMin
+            tempMin=tempdiff(itemp);
+            itempMin=itemp;
+        end
+        itemp=itemp+1;
+    end
+
+    itemp=itempMin+1;
+    while itemp<tempLen
+        if tempdiff(itemp+1)<=tempdiff(itemp-1)
+            dicron=itemp;
+            return;
+        end
+        itemp=itemp+1;
+    end
+elseif izcMin==1
+    dicron=tzcMin(izcMin);
+    return;
+else
+    itemp=tzcMin(1);
+    tempMax=tempdiff(itemp);
+    itempMax=itemp;
+    
+    while itemp<tempLen
+        if tempdiff(itemp)>tempMax
+            tempMax=tempdiff(itemp);
+            itempMax=itemp;
+        end
+        itemp=itemp+1;
+    end
+
+    for itemp=izcMin:-1:1
+        if tzcMin(itemp)<itempMax
+            dicron=tzcMin(itemp);
+            return;
+        end
+    end
+end
+end
+
+function [diap]=seekdiap(tempabp)
+diap=0;
+
+[tt,ti]=max(tempabp);
+if ti==0
+    diap=floor(length(tempabp)./2);
+else
+    diap=ti;
+end
+end
+","MATLAB"
+"Biosensors","Cassey2016/PPG_Peak_Detection","func/my_func_standardizing_PPG.m",".m","422","11","function PPG_buffer = my_func_standardizing_PPG(PPG_buffer)
+% Standardizing PPG into zero-mean and uni-variance.
+    var_sig_PPG = var(PPG_buffer);
+    if var_sig_PPG == 0
+        univar_sig_PPG = PPG_buffer;
+    else
+        univar_sig_PPG = sqrt(1/var_sig_PPG) * PPG_buffer;
+    end
+    zeromean_sig_PPG = univar_sig_PPG - mean(univar_sig_PPG);
+    PPG_buffer = zeromean_sig_PPG; % univariance for PPG 30 sec segment
+end","MATLAB"
+"Biosensors","Cassey2016/PPG_Peak_Detection","func/my_func_prep_PPG_buffer.m",".m","554","17","function [PPG_buffer,fs_PPG] = my_func_prep_PPG_buffer(PPG_raw_buffer,fs_PPG)
+    % Resample PPG to 50 Hz.
+    if fs_PPG ~= 50 % Hz
+        PPG_down = resample(PPG_raw_buffer,50,fs_PPG);
+        fs_PPG = 50;
+    else
+        PPG_down = PPG_raw_buffer;
+    end
+
+    PPG_buffer = PPG_down(:); % Make sure PPG is column vector
+    % Standardizing PPG in sub-function.
+    PPG_buffer = my_func_standardizing_PPG(PPG_buffer);
+
+    % Filter signal.
+    [b, a] = butter(6,[0.5 20]/(fs_PPG/2)); % Bandpass filter.
+    PPG_buffer = filtfilt(b, a, PPG_buffer);
+end","MATLAB"
+"Biosensors","Cassey2016/PPG_Peak_Detection","method_06/my_revise_run_wabp.m",".m","4330","109","function [r,ssf,my_avg0,A] = my_revise_run_wabp(abp,fs_abp)
+% Below was copied from Erick Andres Perez Alday's Github repository 
+% "" physionetchallenges / matlab-classifier-2020 "": 
+% https://github.com/physionetchallenges/matlab-classifier-2020/blob/master/Tools/PhysioNet-Cardiovascular-Signal-Toolbox-master/Tools/BP_Tools/run_wabp.m
+% WABP  ABP waveform onset detector.
+%   r = run_wabp(abp) obtains the onset time (in samples) 
+%       of each beat in the ABP waveform.
+%
+%   In:   ABP (125Hz sampled)
+%   Out:  Onset sample time
+% 
+%   Usage:
+%   - ABP waveform must have units of mmHg
+%
+%   Written by James Sun (xinsun@mit.edu) on Nov 19, 2005.  This ABP onset
+%   detector is adapted from Dr. Wei Zong's wabp.c.
+%
+%   LICENSE:    
+%       This software is offered freely and without warranty under 
+%       the GNU (v3 or later) public license. See license file for
+%       more information
+
+% Dong changed: input should be 250 Hz for filtering.
+%% Input checks
+    % if nargin ~=1
+    %     error('exactly 1 argment needed');
+    % end
+
+    if size(abp,2)~=1
+        error('Input must be a <nx1> vector');
+    end
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+    % scale physiologic ABP
+    offset   = 1600;
+    scale    = 20;
+    Araw     = abp*scale-offset;
+
+    % LPF
+    A = filter([1 0 0 0 0 -2 0 0 0 0 1],[1 -2 1],Araw)/24+30;
+    A = (A(4:end)+offset)/scale; % Takes care of 4 sample group delay
+
+    % ------- Dong changed this: -------
+    A = A ./ std(A); % normalizing data is very important for my peak detection.
+    A = A - mean(A);
+
+    % Slope-sum function
+    dypos          = diff(A);
+    dypos(dypos<0) = 0;
+    % ssf            = [0; 0; conv(ones(16,1),dypos)];
+    w = 16/125*fs_abp; % 125 Hz to 250 Hz.
+    ssf            = [0; 0; conv(ones(w,1),dypos)];
+
+    % Decision rule
+    first_8sec = 8*fs_abp;
+    % avg0       = sum(ssf(1:1000))/1000;   % average of 1st 8 seconds (1000 samples) of SSF
+    avg0       = sum(ssf(1:first_8sec))/first_8sec;
+    Threshold0 = 3*avg0;                  % initial decision threshold
+
+    % ignoring ""learning period"" for now
+    lockout    = 0;    % lockout >0 means we are in refractory
+    timer      = 0;
+    % z          = zeros(100000,1);
+    z          = zeros(fs_abp*800,1);
+    counter    = 0;
+
+    % Dong: copied from wabp.c, 02/27/2020. % Dong change here. 02/27/2020.
+    TmDEF = 0.25; %5;% Dong change here. 02/27/2020.
+    max_min_thres = 0.1; %10;% Dong change here. 02/27/2020.
+    my_avg0 = zeros(size(abp));% Dong change here. 02/27/2020.
+    step_adjust_thres = 0.025; % it was 0.1 % Dong change here. 02/27/2020.
+    % for t = 50:length(ssf)-17
+    for t = round(0.4*fs_abp):length(ssf)-w-1
+        lockout = lockout - 1;
+        timer   = timer   + 1;      % Timer used for counting time after previous ABP pulse
+
+        if (lockout<1) & (ssf(t)>avg0+TmDEF) %(ssf(t)>avg0+5)  % Not in refractory and SSF has exceeded threshold here % Dong change here. 02/27/2020.
+            timer = 0;
+            maxSSF = max(ssf(t:t+w));  % Find local max of SSF
+            minSSF = min(ssf(t-w:t));  % Find local min of SSF
+            if maxSSF > (minSSF + max_min_thres) %(minSSF + 10)% Dong change here. 02/27/2020.
+                onset = 0.01*maxSSF ;  % Onset is at the time in which local SSF just exceeds 0.01*maxSSF
+
+                tt       = t-w:t;
+                dssf     = ssf(tt) - ssf(tt-1);
+                BeatTime = find(dssf<onset,1,'last')+t-w-1;
+                counter  = counter+1;
+
+                if isempty(BeatTime)
+                    counter = counter-1;
+                else
+                    z(counter) = BeatTime;
+                end
+                Threshold0 = Threshold0 + step_adjust_thres*(maxSSF - Threshold0);  % adjust threshold
+                avg0 = Threshold0 / 3;        % adjust avg
+
+                lockout = round(32/125*fs_abp);   % lock so prevent sensing right after detection (refractory period)
+            end
+        end
+
+        if timer > round(312/125*fs_abp)  % Lower threshold if no pulse detection for a while
+            Threshold0 = Threshold0 - 0.1; %Threshold0 - 1; % Dong change here. 02/27/2020.
+            avg0       = Threshold0/3;
+        end
+        my_avg0(t,1) = avg0+TmDEF; % % Dong change here. 02/27/2020.
+    end
+    r = z(find(z))-2;
+end","MATLAB"
+"Biosensors","Cassey2016/PPG_Peak_Detection","method_06/my_Elgendi_2013_method_III_peakdet.m",".m","1028","22","function [output_Elgendi_3_2013] = my_Elgendi_2013_method_III_peakdet(raw_PPG,fs_PPG)
+% -------------------------------------------------------------------------
+% This peak detection function was mentioned in this paper:
+% Elgendi, Mohamed, et al. 
+% ""Systolic peak detection in acceleration photoplethysmograms measured from 
+% emergency responders in tropical conditions."" PLoS One 8.10 (2013): e76585.
+% 
+    [r,ssf,my_avg0,A] = my_revise_run_wabp(raw_PPG,fs_PPG);
+% -------------------------------------------------------------------------
+    if isempty(r)
+        HR_Elgendi_3_2013 = 0; % there is no peak location.
+        r = 1;
+    else
+        HR_Elgendi_3_2013 = 60 * fs_PPG ./ diff(r); % calculate the HR.
+    end
+    A = [A;0;0;0;]; % add zero
+    A(1:6) = A(7); % first six plots are all high amplitude.
+    output_Elgendi_3_2013 = struct('PPG_peak_loc_Elgendi_3_2013',r,...
+        'HR_Elgendi_3_2013',HR_Elgendi_3_2013,...
+        'filtered_PPG_Elgendi_3_2013',A,...
+        'thres_Elgendi_3_2013',my_avg0);
+end","MATLAB"
+"Biosensors","Cassey2016/PPG_Peak_Detection","method_03_and_04/my_Elgendi_2013_method_I_peakdet.m",".m","3762","111","function [output_Elgendi_1_2013] = my_Elgendi_2013_method_I_peakdet(raw_PPG, delta, fs_PPG)
+% -------------------------------------------------------------------------
+% Dong add this on 02/25/2020, based on this paper:
+% Elgendi, Mohamed, et al. 
+% ""Systolic peak detection in acceleration photoplethysmograms measured from 
+% emergency responders in tropical conditions."" PLoS One 8.10 (2013): e76585.
+% 
+% (1): bandpass filter (0.5-8Hz)
+    [b, a] = butter(6,[0.5 8]/(fs_PPG/2)); % bandpass filter 0.5-10Hz, changed from 0.5-20 to 0.5-9 Hz at 11/21/2018
+    raw_PPG = filtfilt(b, a, raw_PPG); % -> AC component
+    raw_PPG = raw_PPG ./ std(raw_PPG); % normalizing data is very important for my peak detection.
+    raw_PPG = raw_PPG - mean(raw_PPG);
+    
+    debugging_plot_flag = false; % only for plotting debugging figures. 
+% -------------------------------------------------------------------------
+% Below code is copied from: http://billauer.co.il/peakdet.html
+% PEAKDET Detect peaks in a vector
+%        [MAXTAB, MINTAB] = PEAKDET(V, DELTA) finds the local
+%        maxima and minima (""peaks"") in the vector V.
+%        MAXTAB and MINTAB consists of two columns. Column 1
+%        contains indices in V, and column 2 the found values.
+%      
+%        With [MAXTAB, MINTAB] = PEAKDET(V, DELTA, X) the indices
+%        in MAXTAB and MINTAB are replaced with the corresponding
+%        X-values.
+%
+%        A point is considered a maximum peak if it has the maximal
+%        value, and was preceded (to the left) by a value lower by
+%        DELTA.
+
+% Eli Billauer, 3.4.05 (Explicitly not copyrighted).
+% This function is released to the public domain; Any use is allowed.
+    maxtab = [];
+    mintab = [];
+
+    raw_PPG = raw_PPG(:); % Just in case this wasn't a proper vector
+
+    % if nargin < 3
+      x = (1:length(raw_PPG))';
+    % else 
+    %   x = x(:);
+    %   if length(raw_PPG)~= length(x)
+    %     error('Input vectors v and x must have same length');
+    %   end
+    % end
+
+    if (length(delta(:)))>1
+      error('Input argument DELTA must be a scalar');
+    end
+
+    if delta <= 0
+      error('Input argument DELTA must be positive');
+    end
+
+    mn = Inf; mx = -Inf;
+    mnpos = NaN; mxpos = NaN;
+
+    lookformax = 1;
+
+    for i=1:length(raw_PPG)
+      this = raw_PPG(i);
+      if this > mx, mx = this; mxpos = x(i); end
+      if this < mn, mn = this; mnpos = x(i); end
+
+      if lookformax
+        if this < mx-delta
+          maxtab = [maxtab ; mxpos mx];
+          mn = this; mnpos = x(i);
+          lookformax = 0;
+        end  
+      else
+        if this > mn+delta
+          mintab = [mintab ; mnpos mn];
+          mx = this; mxpos = x(i);
+          lookformax = 1;
+        end
+      end
+    end
+
+
+
+    if isempty(maxtab)
+        HR_Elgendi_1_max_2009 = 0; % there is no peak location.
+        peak_loc_max = 1;
+    else
+        peak_loc_max = maxtab(:,1);
+        HR_Elgendi_1_max_2009 = 60 * fs_PPG ./ diff(peak_loc_max); % calculate the HR.
+    end
+
+    if isempty(mintab)
+        HR_Elgendi_1_min_2009 = 0; % there is no peak location.
+        peak_loc_min = 1;
+    else
+        peak_loc_min = mintab(:,1);
+        HR_Elgendi_1_min_2009 = 60 * fs_PPG ./ diff(peak_loc_min); % calculate the HR.
+    end
+
+    output_Elgendi_1_2013 = struct('filtered_PPG_Elgendi_1_2013',raw_PPG,...
+        'PPG_peak_loc_Elgendi_1_max_2013',peak_loc_max,...
+        'PPG_peak_loc_Elgendi_1_min_2013',peak_loc_min,...
+        'HR_Elgendi_1_max_2013',HR_Elgendi_1_max_2009,...
+        'HR_Elgendi_1_min_2013',HR_Elgendi_1_min_2009);
+
+
+    if debugging_plot_flag % debugging plot
+        figure;
+        plot(x,raw_PPG);hold on;
+        plot(peak_loc_max,raw_PPG(peak_loc_max),'ro');
+        plot(peak_loc_min,raw_PPG(peak_loc_min),'go');
+    end
+end","MATLAB"
+"Biosensors","Cassey2016/PPG_Peak_Detection","method_08_and_09/my_Vadrevu_2019_peakdet.m",".m","10598","329","function [output_Vadrevu_1_2019,output_Vadrevu_2_2019] = my_Vadrevu_2019_peakdet(PPG_buffer,fs_PPG)
+% =========================================================================
+% This is my implementation of this paper:
+%
+% Vadrevu, Simhadri, and M. Sabarimalai Manikandan. 
+% ""A robust pulse onset and peak detection method for automated PPG signal 
+% analysis system."" IEEE Transactions on Instrumentation and Measurement 
+% 68.3 (2018): 807-817.
+%
+% Implemented by Dong Han on 05/03/2020.
+%
+% Please cite our paper if you used this code:
+% Han, Dong, Syed K. Bashar, Jesús Lázaro, Fahimeh Mohagheghian, 
+% Andrew Peitzsch, Nishat Nishita, Eric Ding, Emily L. Dickson, 
+% Danielle DiMezza, Jessica Scott, Cody Whitcomb, Timothy P. Fitzgibbons, 
+% David D. McManus, and Ki H. Chon. 2022. 
+% ""A Real-Time PPG Peak Detection Method for Accurate Determination of 
+% Heart Rate during Sinus Rhythm and Cardiac Arrhythmia"" 
+% Biosensors 12, no. 2: 82. https://doi.org/10.3390/bios12020082 
+%
+% Please cite our paper if you used our code. Thank you.
+% =========================================================================
+    debug_flag = false; % decide to plot the paper figure or not.
+    %% A. Stationary Wavelet Transform of PPG signal.
+
+    % first, for the input length, you can know the maximum wavelet
+    % decomposition level you can get:
+    TYPE = '1D'; % extension method.
+    MODE = 'zpd'; % zero extension.
+    X = PPG_buffer;
+
+    % based on your input signal length, you have to extend your input signal
+    % to MATLAB suggested length.
+    LEN = 45;%18; % 18 for fs_PPG 50, 45 for fs_PPG 125; for 30 sec input.
+    YEXT = wextend(TYPE,MODE,X,LEN); % required by swt.
+    sig = YEXT;
+    % s = PPG_buffer;
+    sLen = length(sig);
+    wname = 'bior1.5';
+    L = wmaxlev(sLen,wname);
+
+    % [swa,swd] = swt(s,3,'bior1.5'); % the author mentioned wavelet biorthogonal 1.5 (bior1.5)
+    [swa,swd] = swt(sig,L,wname); % the author mentioned wavelet biorthogonal 1.5 (bior1.5)
+    s1 = swd(3,:) + swd(4,:); 
+    s1 = s1(:); % make sure it is column vector.
+    s2 = swd(5,:) + swd(6,:) + swd(7,:);
+    s2 = s2(:); % make sure it is column vector.
+
+    if debug_flag
+        % if you want to debug the result.
+        figure;
+        t_plot = [1:length(sig)]'./fs_PPG; %
+        subplot(5,1,1);
+        plot(t_plot,sig);
+        xlim([0 t_plot(end)])
+        ylabel('Orig');
+        title('Fig.3 in TIM 2019 paper');
+
+        subplot(5,1,2)
+        plot(t_plot,(swd(1,:) + swd(2,:)))
+        xlim([0 t_plot(end)])
+        ylabel('s_0');
+
+        subplot(5,1,3);
+        plot(t_plot,s1);
+        xlim([0 t_plot(end)])
+        ylabel('s_1');
+
+        subplot(5,1,4);
+        plot(t_plot,s2);
+        xlim([0 t_plot(end)])
+        ylabel('s_2');
+
+        subplot(5,1,5);
+        plot(t_plot,swa(7,:));
+        xlim([0 t_plot(end)])
+        ylabel('a_7');
+    end
+    %% B. Multiscale Sum and Products:
+    p = s1 .* s2;
+    p = p(:);
+
+    if debug_flag
+        % if you want to debug the result.
+        figure;
+        ax(1) = subplot(4,1,1);
+        plot(t_plot,sig);
+        xlim([0 t_plot(end)])
+        ylabel('Orig');
+        title('Fig.4 in TIM 2019 paper');
+
+        ax(2) = subplot(4,1,2);
+        p1 = swd(1,:) .* swd(2,:) .* swd(3,:) .* swd(4,:) .* swd(5,:) .* swd(6,:) .* swd(7,:); 
+        plot(t_plot,p1);
+        xlim([0 t_plot(end)])
+        ylabel('p_1');
+
+        ax(3) = subplot(4,1,3);
+        p1 = swd(3,:) .* swd(4,:) .* swd(5,:) .* swd(6,:) .* swd(7,:); 
+        plot(t_plot,p1);
+        xlim([0 t_plot(end)])
+        ylabel('p_2');
+
+        ax(4) = subplot(4,1,4);
+        plot(t_plot,p);
+        xlim([0 t_plot(end)])
+        ylabel('p');
+
+        linkaxes(ax,'x');
+    end
+    %% C. Shannon Entropy Envelope Extraction
+    eta = 0.01 + std(p);
+    p_tilda = abs(p);
+    p_tilda(p_tilda < eta) = 0;
+    p_tilda = p_tilda(:);
+
+    % normalize p_tilda:
+    norm_p_tilda = (p_tilda - min(p_tilda)) ./ (max(p_tilda) - min(p_tilda));
+    norm_p_tilda = norm_p_tilda(:);
+
+    se = NaN(size(norm_p_tilda));
+
+    for tttt = 1:size(norm_p_tilda,1)
+        if norm_p_tilda(tttt) == 0
+            % from MATLAB page: https://www.mathworks.com/help/wavelet/ref/wentropy.html
+            %  log(0) = 0
+            % 0log(0) = 0.
+            se(tttt) = 0;
+        else
+            se(tttt) = -1 * norm_p_tilda(tttt) .* log(norm_p_tilda(tttt));
+        end
+    end
+
+    % % method 1: CONV twice:
+    filt_Len = floor(0.2 * fs_PPG); % 0.4 is better. 05/04/2020.
+    % h = ones(filt_Len,1)/filt_Len;   % A third-order filter has length 4
+    % s = conv(se,h,'same'); % return the same size as se
+    % s = conv(s,h,'same'); % conv twice
+
+    % method 2: FILTFILT.
+    % for 4020, ii = 2, PPG is zero.
+    if any(isnan(se))
+        % any sample is NaN.
+        new_se = se;
+        new_se(isnan(new_se)) = [];
+        if isempty(new_se)
+            % nothing left after removing NaN.
+
+                HR_Vadrevu_1_2019 = 0; % there is no peak location.
+                onset_zx = 1;
+
+                HR_Vadrevu_2_2019 = 0; % there is no peak location.
+                peak_zx = 1;
+
+                filter_PPG = PPG_buffer;
+            output_Vadrevu_1_2019 = struct('filtered_PPG_Vadrevu_2019',filter_PPG,...
+                'PPG_peak_loc_Vadrevu_1_2019',onset_zx,...
+                'HR_Vadrevu_1_2019',HR_Vadrevu_1_2019);
+
+                output_Vadrevu_2_2019 = struct('filtered_PPG_Vadrevu_2019',filter_PPG,...
+                'PPG_peak_loc_Vadrevu_2_2019',peak_zx,...
+                'HR_Vadrevu_2_2019',HR_Vadrevu_2_2019);
+            return
+        else
+            % part of data is NaN, maybe I should fill zeros in it?
+            keyboard;
+        end
+    end
+    b = ones(filt_Len,1);
+    a = -1;
+    s = filtfilt(b, a, se); % -> AC component
+
+
+    %% D. Pulse Peak and Onset Determination.
+    % 1. Gaussian derivative kernel:
+    sigma_1 = floor(0.05 * fs_PPG); % 0.05 mentioned in the paper.
+    M = floor(2 * fs_PPG); % 2 mentioned in the paper.
+    g = gausswin(M,sigma_1); % size should be 250 if Fs = 125.
+    h_d = diff(g); % g(m+1) - g(m).
+    z = conv(s,h_d,'same');
+
+    % % My conv function did not work.
+    % temp_z = zeros(size(s,1),1);
+    % for nnnn = 1:size(s,1)
+    %     for mmmm = 1:size(g,1)-1
+    %         if (nnnn-mmmm+1 > 0)
+    % %             h_d(mmmm) = g(mmmm+1) - g(mmmm);
+    %         temp_z(nnnn) = temp_z(nnnn) + s(mmmm) * h_d(nnnn-mmmm+1);
+    %         end
+    %     end
+    % end
+
+    DownZCi = @(v) find(v(1:end-1) >= 0 & v(2:end) < 0); % Returns Down Zero-Crossing Indices. https://www.mathworks.com/matlabcentral/answers/267222-easy-way-of-finding-zero-crossing-of-a-function
+    zx = DownZCi(z); % negative zero crossing point.
+
+    % peak correction algorithm for onset:
+    search_intv = floor(0.1 * fs_PPG / 2); % w/2
+    onset_zx = NaN(size(zx));
+    for zz = 1:size(zx,1)
+        temp_zx = zx(zz);
+        if temp_zx - search_intv > 0 % not exceed signal limit.
+            if temp_zx + search_intv <= size(sig,1)
+                temp_PPG = sig(temp_zx - search_intv : temp_zx + search_intv);
+                [~,I] = min(temp_PPG);
+                if isempty(I) ~= 1
+                    adj_loc = temp_zx - search_intv + I - 1;
+                else
+                    % no local minimum.
+                    adj_loc = temp_zx; 
+                end
+                onset_zx(zz) = adj_loc;
+            else
+                % right interval exceed signal length.
+                onset_zx(zz) = zx(zz);
+            end
+        else
+            % left interval exceed index 1.
+            onset_zx(zz) = zx(zz);
+        end
+    end
+
+    % find peak:
+    peak_zx = NaN(size(onset_zx,1)-1,1); % one sample smaller.
+    for zz = 2:size(onset_zx,1)
+        temp_onset_1 = onset_zx(zz-1);
+        temp_onset_2 = onset_zx(zz);
+        temp_PPG = sig(temp_onset_1:temp_onset_2);
+        [~,I] = max(temp_PPG);
+        if isempty(I) ~= 1
+           peak_zx(zz-1) = temp_onset_1 + I - 1; % peak is one sample size smaller.
+        else
+            peak_zx(zz-1) = onset_zx(zz);
+        end
+    end
+
+    % prepare to output signal:
+    filter_PPG = z(LEN+1:end-LEN);
+    remove_left = find(onset_zx < LEN+1);
+    if isempty(remove_left) ~= 1
+        onset_zx(remove_left) = [];
+    end
+    remove_right = find(onset_zx > size(z,1) - LEN);
+    if isempty(remove_right) ~= 1
+        onset_zx(remove_right) = [];
+    end
+    onset_zx = onset_zx - LEN; % shifted.
+
+    remove_left = find(peak_zx < LEN+1);
+    if isempty(remove_left) ~= 1
+        peak_zx(remove_left) = [];
+    end
+    remove_right = find(peak_zx > size(z,1) - LEN);
+    if isempty(remove_right) ~= 1
+        peak_zx(remove_right) = [];
+    end
+    peak_zx = peak_zx - LEN;
+
+    if debug_flag
+        % if you want to debug the result.
+        figure;
+        ax(1) = subplot(7,1,1);
+        plot(t_plot,sig);
+        xlim([0 t_plot(end)])
+        ylabel('Orig');
+        title('Fig.5 in TIM 2019 paper');
+
+        ax(2) = subplot(7,1,2);
+        plot(t_plot,p);
+        xlim([0 t_plot(end)])
+        ylabel('p');
+
+        ax(3) = subplot(7,1,3);
+        plot(t_plot,norm_p_tilda);
+        xlim([0 t_plot(end)])
+        ylabel('p_th');
+
+        ax(4) = subplot(7,1,4);
+        plot(t_plot,se);
+        xlim([0 t_plot(end)])
+        ylabel('se');
+
+        ax(5) = subplot(7,1,5);
+        plot(t_plot,s);
+        xlim([0 t_plot(end)])
+        ylabel('s');
+
+        ax(6) = subplot(7,1,6);
+        plot(t_plot,z);
+        hold on;
+        plot(t_plot(zx),z(zx),'ro');
+        xlim([0 t_plot(end)]);
+        ylabel('z');
+
+
+        ax(7) = subplot(7,1,7);
+        plot(t_plot,sig);
+        hold on;
+        plot(t_plot(onset_zx),sig(onset_zx),'go');
+        plot(t_plot(peak_zx),sig(peak_zx),'ro');
+        xlim([0 t_plot(end)])
+        ylabel('orig with peak');
+
+        linkaxes(ax,'x');
+    end
+
+    if isempty(onset_zx)
+        HR_Vadrevu_1_2019 = 0; % there is no peak location.
+        onset_zx = 1;
+    else
+        HR_Vadrevu_1_2019 = 60 * fs_PPG ./ diff(onset_zx); % calculate the HR.
+    end
+    
+    if isempty(peak_zx)
+        HR_Vadrevu_2_2019 = 0; % there is no peak location.
+        peak_zx = 1;
+    else
+        HR_Vadrevu_2_2019 = 60 * fs_PPG ./ diff(peak_zx); % calculate the HR.
+    end
+    
+    output_Vadrevu_1_2019 = struct('filtered_PPG_Vadrevu_2019',filter_PPG,...
+        'PPG_peak_loc_Vadrevu_1_2019',onset_zx,...
+        'HR_Vadrevu_1_2019',HR_Vadrevu_1_2019);
+
+        output_Vadrevu_2_2019 = struct('filtered_PPG_Vadrevu_2019',filter_PPG,...
+        'PPG_peak_loc_Vadrevu_2_2019',peak_zx,...
+        'HR_Vadrevu_2_2019',HR_Vadrevu_2_2019);
+    
+end
+","MATLAB"

data/dataset_Biotechnology.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae5f6ff49b57e523d83cffa0adfba6beba919e74e8a9773a4c00f3285db0a67a
+size 246280813

data/dataset_Cell_atlas.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e46bc111a26a198e9990aeec58c4326df3fdaa844367bd99de4799e3b55f940
+size 72197401

data/dataset_Chemical_space.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8e88459d479bed92bb767b49e33308e1ba7b7f647833fe1bd148c1b2d696261
+size 235865458

data/dataset_Cheminformatics.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1af279c2ad8a474f8b20ba802133582721a9632ae9a44b94ccee9eb13bcbf47d
+size 141839346

data/dataset_Chemistry.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ecb76934a5e29f73eacfccf98c9c30d757aee7dcee171c87801213ff40c98e4
+size 360112090

data/dataset_Compartmental_model.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38a3208e3bd4e15690469264821eb34aee6fb9dfdb5d8341f90a72feea70296f
+size 196516716

data/dataset_Computational_Chemistry.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b247737bff18ee9764de11fb60af1ec36463fdc675e3d8fb96cab61c9f16203a
+size 514818775

data/dataset_Computational_Materials.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:692f98166f96bb3c6fdcb960ac112919ad5cc68cfa47b731e274706e9cdc4e05
+size 1470023569

data/dataset_Coupled_cluster.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fef50d2653d98af56b95e40ad57999f3677a31f4af0bf09e736b0ad65a00fab
+size 418368710

data/dataset_Crystal.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7489bbaa15fb8c604382a0ec85c53dd59d8917ea4d78cd6c3cc2de97f3336bb7
+size 64264594

data/dataset_Cycle.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bbe1d5327b4c320764174215507daacdc0ea79a202c8d184a32fc78c0041d81
+size 1497335713

data/dataset_DFT.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ecae0254d24c6869b154f623f907c398190152aba00fccf71a7ce9cec112617
+size 610647978

data/dataset_DNA.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ffe1dafda9ee5f9f22a5dbe85a4d71803740adf98b4bcbcea220b6e2db16df9
+size 90689920

data/dataset_De_novo.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba29166e48d838ec4fabda954a33d8d7e5979ac95f07c8c7ce9c6525c08ced98
+size 63275132

data/dataset_Design.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe2185aac337a9af160e74bf77ab2dc88342aff8bd672dd00c011c70bc935f1b
+size 325191237