diff --git a/Desktop/open-source/R/.github/CODEOWNERS b/Desktop/open-source/R/.github/CODEOWNERS
new file mode 100644
index 00000000..076e386d
--- /dev/null
+++ b/Desktop/open-source/R/.github/CODEOWNERS
@@ -0,0 +1,4 @@
+* @siriak @acylam @eshom
+*.md              @Panquesito7
+/.github          @Panquesito7
+LICENSE           @Panquesito7
diff --git a/Desktop/open-source/R/.github/copilot-instructions.md b/Desktop/open-source/R/.github/copilot-instructions.md
new file mode 100644
index 00000000..d39c1cd9
--- /dev/null
+++ b/Desktop/open-source/R/.github/copilot-instructions.md
@@ -0,0 +1,59 @@
+# Copilot Instructions for TheAlgorithms/R
+
+## General Guidelines
+
+This repository contains implementations of various algorithms in R. All contributions should follow these guidelines to maintain code quality and consistency.
+
+## Code Quality & Functionality
+
+- Ensure that your code is functional and well-structured before submitting
+- The code should run without errors in an R environment and produce the expected output
+- Follow best practices for efficiency, readability, and maintainability
+- Use consistent and meaningful variable names (use `.` or `_` to separate words, e.g., `results.df` for a data frame)
+
+## Adding New Algorithms
+
+When adding a new algorithm:
+- **Verify that the algorithm is not already implemented** in the repository (including under a different name)
+- **Confirm that the proposed algorithm is a recognized computer-science algorithm**, not a problem-specific adaptation of a general technique (e.g., tuned for LeetCode or other competitive-programming problems)
+- Include a brief explanation of the algorithm in the file as comments
+- Add an example showcasing its usage (can be commented within the script)
+- **Update DIRECTORY.md** to include the new algorithm in the appropriate section
+
+## Modifying Existing Algorithms
+
+When modifying existing algorithms:
+- Clearly document the changes in your pull request description
+- Ensure that your modifications do not break existing functionality
+- If applicable, update or add test cases to validate your changes
+
+## File Naming & Structure Conventions
+
+- **All code file names must use lowercase `.r` extension** (not `.R`)
+- Ensure that filenames follow the existing directory structure and naming patterns
+- Files should be placed in the appropriate category directory (e.g., `sorting_algorithms/`, `graph_algorithms/`, `mathematics/`)
+
+## Documentation & Comments
+
+- Provide clear and concise documentation in the form of comments within the code
+- Add a brief docstring at the beginning of the script explaining:
+  - What the algorithm does
+  - The expected input and output
+  - Any dependencies required
+
+## Testing & Verification
+
+Before submitting a pull request, verify that your code:
+- Runs correctly with different test cases
+- Does not produce unnecessary warnings or errors
+- If applicable, add a test file demonstrating the algorithm's correctness
+
+## Pull Request Review Checklist
+
+When reviewing a pull request:
+- Verify that any added algorithms or data structures aren't already implemented elsewhere in the repository (including under a different name)
+- Confirm that the proposed algorithm is a recognized computer-science algorithm, not a problem-specific adaptation of a general technique (e.g., tuned for LeetCode or other competitive-programming problems)
+- Check that the extension of all code file names is a lowercase `.r`
+- Check that DIRECTORY.md was updated correctly
+- Verify that the code includes appropriate documentation and examples
+- Ensure that variable naming follows repository conventions
diff --git a/Desktop/open-source/R/.github/scripts/doc_builder.r b/Desktop/open-source/R/.github/scripts/doc_builder.r
new file mode 100644
index 00000000..0b0d2b3e
--- /dev/null
+++ b/Desktop/open-source/R/.github/scripts/doc_builder.r
@@ -0,0 +1,32 @@
+# Taken from https://stackoverflow.com/a/4749909 and slightly edited. Thanks!
+list_dirs <- function(path=".", pattern=NULL, all.dirs=FALSE,
+  full.names=FALSE, ignore.case=FALSE) {
+
+  all <- list.files(path, pattern, all.dirs,
+           full.names=TRUE, recursive=FALSE, ignore.case)
+  dirs <- all[file.info(all)$isdir]
+
+  if(isTRUE(full.names))
+    return(dirs)
+  else
+    return(basename(dirs))
+}
+
+cat("R process started.\n")
+cat("Change working directory to documentation directory\n")
+setwd("documentation")
+
+cat("Creating the directory list\n")
+dirlist <- list_dirs(path="..", pattern=".R", ignore.case = TRUE, full.names = TRUE)
+
+cat("Getting a list of R scripts from the algorithm directories.\n")
+scriptlist <- lapply(dirlist, list.files, ".R", ignore.case = TRUE, full.names = TRUE)
+cat("Removing from the list empty directories.\n")
+scriptlist <- scriptlist[!sapply(scriptlist, identical, character(0))]
+print(unlist(scriptlist))
+
+cat("Compiling documentation from scripts.\n")
+invisible(lapply(unlist(scriptlist), function(x) tryCatch(knitr::spin(x),
+    error = function(e) message("Error compiling: ", e))))
+
+cat("R process done.\n")
diff --git a/Desktop/open-source/R/.github/workflows/directory_workflow.yml b/Desktop/open-source/R/.github/workflows/directory_workflow.yml
new file mode 100644
index 00000000..b9a157d7
--- /dev/null
+++ b/Desktop/open-source/R/.github/workflows/directory_workflow.yml
@@ -0,0 +1,40 @@
+name: Directory/Filename Formatter workflow
+on: [push, pull_request]
+
+jobs:
+  main:
+    name: (Directory) Formatter
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Git configuration
+        run: |
+          git config --global user.name 'autoprettier'
+          git config --global user.email 'actions@github.com'
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
+      - name: Filename Formatter
+        run: |
+          IFS=$'\n'
+          for fname in `find . -type f -name '*.R' -o -name '*.R'`
+          do
+            echo "${fname}"
+            new_fname=`echo ${fname} | tr ' ' '_'`
+            echo "      ${new_fname}"
+            new_fname=`echo ${new_fname} | tr 'A-Z' 'a-z'`
+            echo "      ${new_fname}"
+            new_fname=`echo ${new_fname} | tr '-' '_'`
+            echo "      ${new_fname}"
+            if [ ${fname} != ${new_fname} ]
+            then
+              echo "      ${fname} --> ${new_fname}"
+              git "mv" "${fname}" ${new_fname}
+            fi
+          done
+          git commit -am "Formatting filenames ${GITHUB_SHA::8}" || true
+      - name: Update DIRECTORY.md
+        run: |
+          wget https://raw.githubusercontent.com/TheAlgorithms/scripts/main/build_directory_md.py
+          python3 build_directory_md.py R . .R,.r > DIRECTORY.md
+          git diff
+          git commit -m "Update DIRECTORY.md" DIRECTORY.md || true
+          git push --force origin HEAD:$GITHUB_REF || true
diff --git a/Desktop/open-source/R/.github/workflows/documentation_workflow.yml b/Desktop/open-source/R/.github/workflows/documentation_workflow.yml
new file mode 100644
index 00000000..3762b445
--- /dev/null
+++ b/Desktop/open-source/R/.github/workflows/documentation_workflow.yml
@@ -0,0 +1,36 @@
+name: Documentation
+on: [push, pull_request]
+
+jobs:
+  MakeDocs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup R
+        uses: r-lib/actions/setup-r@v2-branch
+        with:
+          r-version: '4.1.0'
+      - name: Create Documentation directory
+        run: |
+          echo "Creating 'Documentation'"
+          mkdir -p documentation
+      - name: Install dependencies
+        run: |
+          echo "Installing R package dependencies. Scripts might have additional dependencies installed."
+          Rscript -e 'if (!require(knitr)) install.packages("knitr")'
+          Rscript -e 'if (!require(markdown)) install.packages("markdown")'
+      - name: Remove old documentation
+        run: 'rm -rf documentation/*'
+      - name: Generate new documentation
+        run: 'Rscript .github/scripts/doc_builder.r'
+      - name: Commit Documentation
+        run: |
+          git diff-index --quiet HEAD && exit
+          echo "Setting up Git to push changes."
+          git config --global user.name 'autoprettier'
+          git config --global user.email 'actions@github.com'
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
+          echo "Staging documentation"
+          git add documentation/ # This is the only directory that has changes and should be staged
+          git commit -m "Update documentation" || true
+          git push || true
diff --git a/Desktop/open-source/R/.github/workflows/stale.yml b/Desktop/open-source/R/.github/workflows/stale.yml
new file mode 100644
index 00000000..95bd0935
--- /dev/null
+++ b/Desktop/open-source/R/.github/workflows/stale.yml
@@ -0,0 +1,18 @@
+name: 'Close stale issues and PRs'
+on:
+  schedule:
+    - cron: '0 0 * * *'
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v4
+        with:
+          stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
+          close-issue-message: 'This issue was closed because it has been stalled for 7 days with no activity.'
+          stale-pr-message: 'This PR is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
+          close-pr-message: 'This PR was closed because it has been stalled for 7 days with no activity.'
+          exempt-issue-labels: 'dont-close'
+          exempt-pr-labels: 'dont-close'
+          days-before-stale: 30
+          days-before-close: 7
diff --git a/Desktop/open-source/R/.gitpod.Dockerfile b/Desktop/open-source/R/.gitpod.Dockerfile
new file mode 100644
index 00000000..a4e549e2
--- /dev/null
+++ b/Desktop/open-source/R/.gitpod.Dockerfile
@@ -0,0 +1,3 @@
+FROM gitpod/workspace-full
+
+RUN brew install R
\ No newline at end of file
diff --git a/Desktop/open-source/R/.gitpod.yml b/Desktop/open-source/R/.gitpod.yml
new file mode 100644
index 00000000..4e222489
--- /dev/null
+++ b/Desktop/open-source/R/.gitpod.yml
@@ -0,0 +1,2 @@
+image:
+    file: .gitpod.Dockerfile
\ No newline at end of file
diff --git a/Desktop/open-source/R/DIRECTORY.md b/Desktop/open-source/R/DIRECTORY.md
new file mode 100644
index 00000000..0a0560e5
--- /dev/null
+++ b/Desktop/open-source/R/DIRECTORY.md
@@ -0,0 +1,151 @@
+
+## Association Algorithms
+  * [Apriori](https://github.com/TheAlgorithms/R/blob/HEAD/association_algorithms/apriori.r)
+
+## Classification Algorithms
+  * [Decision Tree](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/decision_tree.r)
+  * [Gradient Boosting Algorithms](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/gradient_boosting_algorithms.r)
+  * [Knn](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/knn.r)
+  * [Light Gbm](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/light_gbm.r)
+  * [Logistic Regression](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/logistic_regression.r)
+  * [Logistic Regression 2](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/logistic_regression_2.r)
+  * [Naive Bayes](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/naive_bayes.r)
+  * [Random Forest](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/random_forest.r)
+  * [Svm](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/svm.r)
+  * [Xgboost](https://github.com/TheAlgorithms/R/blob/HEAD/classification_algorithms/xgboost.r)
+
+## Clustering Algorithms
+  * [Dbscan Clustering](https://github.com/TheAlgorithms/R/blob/HEAD/clustering_algorithms/dbscan_clustering.r)
+  * [Gmm](https://github.com/TheAlgorithms/R/blob/HEAD/clustering_algorithms/gmm.r)
+  * [Heirarchical Clustering](https://github.com/TheAlgorithms/R/blob/HEAD/clustering_algorithms/heirarchical_clustering.r)
+  * [K Means](https://github.com/TheAlgorithms/R/blob/HEAD/clustering_algorithms/k_means.r)
+  * [Kmeans Clustering](https://github.com/TheAlgorithms/R/blob/HEAD/clustering_algorithms/kmeans_clustering.r)
+  * [Kmeans Raw R](https://github.com/TheAlgorithms/R/blob/HEAD/clustering_algorithms/kmeans_raw_r.r)
+  * [Pam](https://github.com/TheAlgorithms/R/blob/HEAD/clustering_algorithms/pam.r)
+
+## Data Manipulation
+  * [Label Encode](https://github.com/TheAlgorithms/R/blob/HEAD/data_manipulation/label_encode.r)
+  * [One Hot Encode](https://github.com/TheAlgorithms/R/blob/HEAD/data_manipulation/one_hot_encode.r)
+  * [Shorten.Vector](https://github.com/TheAlgorithms/R/blob/HEAD/data_manipulation/shorten.vector.r)
+
+## Data Preprocessing
+  * [Data Normalization Standardization](https://github.com/TheAlgorithms/R/blob/HEAD/data_preprocessing/data_normalization_standardization.r)
+  * [Data Processing](https://github.com/TheAlgorithms/R/blob/HEAD/data_preprocessing/data_processing.r)
+  * [Dimensionality Reduction Algorithms](https://github.com/TheAlgorithms/R/blob/HEAD/data_preprocessing/dimensionality_reduction_algorithms.r)
+  * [K Folds](https://github.com/TheAlgorithms/R/blob/HEAD/data_preprocessing/k_folds.r)
+  * [Lasso](https://github.com/TheAlgorithms/R/blob/HEAD/data_preprocessing/lasso.r)
+
+## Data Structures
+  * [Binary Search Tree](https://github.com/TheAlgorithms/R/blob/HEAD/data_structures/binary_search_tree.r)
+
+## Dynamic Programming
+  * 0
+    * 0
+      * [1 Knapsack Problem](https://github.com/TheAlgorithms/R/blob/HEAD/dynamic_programming/0/0/1_knapsack_problem.r)
+    * [1 Knapsack Problem](https://github.com/TheAlgorithms/R/blob/HEAD/dynamic_programming/0/1_knapsack_problem.r)
+  * [Coin Change](https://github.com/TheAlgorithms/R/blob/HEAD/dynamic_programming/coin_change.r)
+  * [Longest Common Subsequence](https://github.com/TheAlgorithms/R/blob/HEAD/dynamic_programming/longest_common_subsequence.r)
+  * [Longest Increasing Subsequence](https://github.com/TheAlgorithms/R/blob/HEAD/dynamic_programming/longest_increasing_subsequence.r)
+  * [Matrix Chain Multiplication](https://github.com/TheAlgorithms/R/blob/HEAD/dynamic_programming/matrix_chain_multiplication.r)
+  * [Minimum Path Sum](https://github.com/TheAlgorithms/R/blob/HEAD/dynamic_programming/minimum_path_sum.r)
+  * [Subset Sum](https://github.com/TheAlgorithms/R/blob/HEAD/dynamic_programming/subset_sum.r)
+
+## Graph Algorithms
+  * [Bellman Ford Shortest Path](https://github.com/TheAlgorithms/R/blob/HEAD/graph_algorithms/bellman_ford_shortest_path.r)
+  * [Breadth First Search](https://github.com/TheAlgorithms/R/blob/HEAD/graph_algorithms/breadth_first_search.r)
+  * [Bridge Detector](https://github.com/TheAlgorithms/R/blob/HEAD/graph_algorithms/bridge_detector.r)
+  * [Depth First Search](https://github.com/TheAlgorithms/R/blob/HEAD/graph_algorithms/depth_first_search.r)
+  * [Dijkstra Shortest Path](https://github.com/TheAlgorithms/R/blob/HEAD/graph_algorithms/dijkstra_shortest_path.r)
+  * [Floyd Warshall](https://github.com/TheAlgorithms/R/blob/HEAD/graph_algorithms/floyd_warshall.r)
+
+## Machine Learning
+  * [Gradient Boosting](https://github.com/TheAlgorithms/R/blob/HEAD/machine_learning/gradient_boosting.r)
+
+## Mathematics
+  * [Amicable Numbers](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/amicable_numbers.r)
+  * [Armstrong Number](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/armstrong_number.r)
+  * [Bisection Method](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/bisection_method.r)
+  * [Catalan Numbers](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/catalan_numbers.r)
+  * [Euclidean Distance](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/euclidean_distance.r)
+  * [Extended Euclidean Algorithm](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/extended_euclidean_algorithm.r)
+  * [Factorial](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/factorial.r)
+  * [Fibonacci](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/fibonacci.r)
+  * [First N Fibonacci](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/first_n_fibonacci.r)
+  * [Greatest Common Divisor](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/greatest_common_divisor.r)
+  * [Josephus Problem](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/josephus_problem.r)
+  * [Least Common Multiple](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/least_common_multiple.r)
+  * [Modular Exponentiation](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/modular_exponentiation.r)
+  * [Newton Raphson Method](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/newton_raphson_method.r)
+  * [Perfect Number](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/perfect_number.r)
+  * [Perfect Square](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/perfect_square.r)
+  * [Permutation Calculation](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/permutation_calculation.r)
+  * [Pi Monte Carlo](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/pi_monte_carlo.r)
+  * [Prime](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/prime.r)
+  * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/R/blob/HEAD/mathematics/sieve_of_eratosthenes.r)
+
+## Quantitative Finance
+  * [Black Scholes Option Pricing](https://github.com/TheAlgorithms/R/blob/HEAD/quantitative_finance/black_scholes_option_pricing.r)
+  * [Kalman Filter](https://github.com/TheAlgorithms/R/blob/HEAD/quantitative_finance/kalman_filter.r)
+  * [Markowitz Portfolio Optimization](https://github.com/TheAlgorithms/R/blob/HEAD/quantitative_finance/markowitz_portfolio_optimization.r)
+  * [Monte Carlo Simulation](https://github.com/TheAlgorithms/R/blob/HEAD/quantitative_finance/monte_carlo_simulation.r)
+  * [Risk Metrics](https://github.com/TheAlgorithms/R/blob/HEAD/quantitative_finance/risk_metrics.r)
+  * [Time Series Analyzer](https://github.com/TheAlgorithms/R/blob/HEAD/quantitative_finance/time_series_analyzer.r)
+
+## Regression Algorithms
+  * [Ann](https://github.com/TheAlgorithms/R/blob/HEAD/regression_algorithms/ann.r)
+  * [Anova Oneway](https://github.com/TheAlgorithms/R/blob/HEAD/regression_algorithms/anova_oneway.r)
+  * [Linear Regression](https://github.com/TheAlgorithms/R/blob/HEAD/regression_algorithms/linear_regression.r)
+  * [Linearregressionrawr](https://github.com/TheAlgorithms/R/blob/HEAD/regression_algorithms/linearregressionrawr.r)
+  * [Multiple Linear Regression](https://github.com/TheAlgorithms/R/blob/HEAD/regression_algorithms/multiple_linear_regression.r)
+
+## Searches
+  * [Binary Search](https://github.com/TheAlgorithms/R/blob/HEAD/searches/binary_search.r)
+  * [Jump Search](https://github.com/TheAlgorithms/R/blob/HEAD/searches/jump_search.r)
+  * [Linear Search](https://github.com/TheAlgorithms/R/blob/HEAD/searches/linear_search.r)
+  * [Rabin.Karp.String.Search](https://github.com/TheAlgorithms/R/blob/HEAD/searches/rabin.karp.string.search.r)
+  * [Ternary.Search](https://github.com/TheAlgorithms/R/blob/HEAD/searches/ternary.search.r)
+  * [Z.Algorithm.Search](https://github.com/TheAlgorithms/R/blob/HEAD/searches/z.algorithm.search.r)
+
+## Sorting Algorithms
+  * [Binary Insertion Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/binary_insertion_sort.r)
+  * [Bubble Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/bubble_sort.r)
+  * [Bucket Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/bucket_sort.r)
+  * [Cocktail Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/cocktail_sort.r)
+  * [Comb Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/comb_sort.r)
+  * [Counting Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/counting_sort.r)
+  * [Cycle Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/cycle_sort.r)
+  * [Gnome Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/gnome_sort.r)
+  * [Heap Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/heap_sort.r)
+  * [Insertion Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/insertion_sort.r)
+  * [Merge Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/merge_sort.r)
+  * [Odd Even Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/odd_even_sort.r)
+  * [Pancake Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/pancake_sort.r)
+  * [Patience Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/patience_sort.r)
+  * [Quick Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/quick_sort.r)
+  * [Radix Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/radix_sort.r)
+  * [Selection Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/selection_sort.r)
+  * [Shell Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/shell_sort.r)
+  * [Stooge Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/stooge_sort.r)
+  * [Strand Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/strand_sort.r)
+  * [Tim Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/tim_sort.r)
+  * [Topological Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/topological_sort.r)
+  * [Wiggle Sort](https://github.com/TheAlgorithms/R/blob/HEAD/sorting_algorithms/wiggle_sort.r)
+
+## String Manipulation
+  * [Burrows](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/burrows.r)
+  * [Findpalindrome](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/findpalindrome.r)
+  * [Hamming Distance](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/hamming_distance.r)
+  * [Is.Anagram](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/is.anagram.r)
+  * [Is.Lower](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/is.lower.r)
+  * [Is.Uppercase](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/is.uppercase.r)
+  * [Kmp String Matching](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/kmp_string_matching.r)
+  * [Levenshtein](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/levenshtein.r)
+  * [Longest.Palindromic.Subsequence](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/longest.palindromic.subsequence.r)
+  * [Longest.Substring.No.Repeat](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/longest.substring.no.repeat.r)
+  * [Manacher.Longest.Palindrome](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/manacher.longest.palindrome.r)
+  * [Maskwords](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/maskwords.r)
+  * [Min.Palindromic.Insert](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/min.palindromic.insert.r)
+  * [Minimum.Window.Substring](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/minimum.window.substring.r)
+  * [Rearrangeways](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/rearrangeways.r)
+  * [Shortest.Common.Supersequence](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/shortest.common.supersequence.r)
+  * [Unique.Letters.Count](https://github.com/TheAlgorithms/R/blob/HEAD/string_manipulation/unique.letters.count.r)
diff --git a/Desktop/open-source/R/LICENSE b/Desktop/open-source/R/LICENSE
new file mode 100644
index 00000000..6d7f310d
--- /dev/null
+++ b/Desktop/open-source/R/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 The Algorithms
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Desktop/open-source/R/README.md b/Desktop/open-source/R/README.md
new file mode 100644
index 00000000..efe4947b
--- /dev/null
+++ b/Desktop/open-source/R/README.md
@@ -0,0 +1,70 @@
+# The Algorithms - R
+
+<a href="https://gitpod.io/#https://github.com/TheAlgorithms/R">
+    <img src="https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod&style=flat-square" height="20" alt="Gitpod Ready-to-Code">
+</a>
+
+![build](https://img.shields.io/badge/build-passing-brightgreen.svg)
+![license](https://img.shields.io/badge/License-MIT-brightgreen.svg)
+![prs](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)
+
+*R is a programming language and free software environment for statistical computing and graphics supported by the R Foundation for Statistical Computing. The R language is widely used among statisticians and data miners for developing statistical software and data analysis. Polls, data mining surveys and studies of scholarly literature databases show substantial increases in popularity in recent years. As of November 2019, R ranks 16th in the TIOBE index, a measure of popularity of programming languages. ([Wikipedia](https://en.wikipedia.org/wiki/R_(programming_language)))*
+
+All algorithms can be found in the [`DIRECTORY.md`](https://github.com/TheAlgorithms/R/blob/master/DIRECTORY.md) file ordered by folder.
+  
+## Contribution Guidelines
+
+Please ensure to follow the points stated below if you would like to contribute:
+### 1. Code Quality & Functionality
+
+-Ensure that your code is functional and well-structured before submitting a pull request.
+
+-The code should run without errors in an R environment and produce the expected output.
+
+-Follow best practices for efficiency, readability, and maintainability.
+
+### 2. Adding a New Algorithm
+
+-Verify that the algorithm is not already implemented in the repository.
+
+-Include a brief explanation of the algorithm in the file as comments.
+
+-Add an example showcasing its usage (it can be commented within the script).
+
+### 3. Modifying an Existing Algorithm
+
+-If making improvements, clearly document the changes in your pull request description.
+
+-Ensure that your modifications do not break existing functionality.
+
+-If applicable, update or add test cases to validate your changes.
+
+### 4. Code Style & Naming Conventions
+
+-Use consistent and meaningful variable names. Follow one of these naming conventions:
+
+-Use . or _ to separate words (e.g., results.df for a data frame).
+
+-Ensure that filenames follow the existing directory structure and naming patterns.
+
+### 5. Documentation & Comments
+
+-Provide clear and concise documentation in the form of comments within the code.
+
+-Add a brief docstring at the beginning of the script explaining:
+
+-What the algorithm does
+
+-The expected input and output
+
+-Any dependencies required
+
+### 6. Testing & Verification
+
+-Before submitting a pull request, verify that your code:
+
+-Runs correctly with different test cases
+
+-Does not produce unnecessary warnings or errors
+
+-If applicable, add a test file demonstrating the algorithm’s correctness.
diff --git a/Desktop/open-source/R/association_algorithms/apriori.r b/Desktop/open-source/R/association_algorithms/apriori.r
new file mode 100644
index 00000000..b770864e
--- /dev/null
+++ b/Desktop/open-source/R/association_algorithms/apriori.r
@@ -0,0 +1,10 @@
+library(arules)
+groceries <- read.transactions("groceries.csv", sep=",")
+summary(groceries)
+itemFrequencyPlot(groceries, topN=20)
+
+#sample for randomly extracting samples, image function for visualing sparse matrix
+image(sample(groceries,100))
+groceries_rule <- apriori(data=groceries, parameter=list(support=0.006, confidence=0.25, minlen=2))
+plotly_arules(groceries_rule)
+summary(groceries_rule)
diff --git a/Desktop/open-source/R/classification_algorithms/decision_tree.r b/Desktop/open-source/R/classification_algorithms/decision_tree.r
new file mode 100644
index 00000000..c7042ad0
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/decision_tree.r
@@ -0,0 +1,7 @@
+library(rpart)
+x <- cbind(x_train,y_train)
+# grow tree 
+fit <- rpart(y_train ~ ., data = x,method="class")
+summary(fit)
+# Predict Output 
+predicted= predict(fit,x_test)
diff --git a/Desktop/open-source/R/classification_algorithms/gradient_boosting_algorithms.r b/Desktop/open-source/R/classification_algorithms/gradient_boosting_algorithms.r
new file mode 100644
index 00000000..c0966175
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/gradient_boosting_algorithms.r
@@ -0,0 +1,71 @@
+# GBM
+library(caret)
+x <- cbind(x_train,y_train)
+# Fitting model
+fitControl <- trainControl( method = "repeatedcv", number = 4, repeats = 4)
+fit <- train(y ~ ., data = x, method = "gbm", trControl = fitControl,verbose = FALSE)
+predicted= predict(fit,x_test,type= "prob")[,2] 
+
+
+
+# XGBoost
+require(caret)
+x <- cbind(x_train,y_train)
+# Fitting model
+TrainControl <- trainControl( method = "repeatedcv", number = 10, repeats = 4)
+model<- train(y ~ ., data = x, method = "xgbLinear", trControl = TrainControl,verbose = FALSE)
+# OR 
+model<- train(y ~ ., data = x, method = "xgbTree", trControl = TrainControl,verbose = FALSE)
+predicted <- predict(model, x_test)
+
+
+
+# LightGBM
+library(RLightGBM)
+data(example.binary)
+# Parameters
+num_iterations <- 100
+config <- list(objective = "binary",  metric="binary_logloss,auc", learning_rate = 0.1, num_leaves = 63, tree_learner = "serial", feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)
+# Create data handle and booster
+handle.data <- lgbm.data.create(x)
+lgbm.data.setField(handle.data, "label", y)
+handle.booster <- lgbm.booster.create(handle.data, lapply(config, as.character))
+# Train for num_iterations iterations and eval every 5 steps
+lgbm.booster.train(handle.booster, num_iterations, 5)
+# Predict
+pred <- lgbm.booster.predict(handle.booster, x.test)
+# Test accuracy
+sum(y.test == (y.pred > 0.5)) / length(y.test)
+# Save model (can be loaded again via lgbm.booster.load(filename))
+lgbm.booster.save(handle.booster, filename = "/tmp/model.txt")
+
+
+
+# Catboost
+set.seed(1)
+
+require(titanic)
+
+require(caret)
+
+require(catboost)
+
+tt <- titanic::titanic_train[complete.cases(titanic::titanic_train),]
+
+data <- as.data.frame(as.matrix(tt), stringsAsFactors = TRUE)
+
+drop_columns = c("PassengerId", "Survived", "Name", "Ticket", "Cabin")
+
+x <- data[,!(names(data) %in% drop_columns)]y <- data[,c("Survived")]
+
+fit_control <- trainControl(method = "cv", number = 4,classProbs = TRUE)
+
+grid <- expand.grid(depth = c(4, 6, 8),learning_rate = 0.1,iterations = 100, l2_leaf_reg = 1e-3,            rsm = 0.95, border_count = 64)
+
+report <- train(x, as.factor(make.names(y)),method = catboost.caret,verbose = TRUE, preProc = NULL,tuneGrid = grid, trControl = fit_control)
+
+print(report)
+
+importance <- varImp(report, scale = FALSE)
+
+print(importance)
diff --git a/Desktop/open-source/R/classification_algorithms/knn.r b/Desktop/open-source/R/classification_algorithms/knn.r
new file mode 100644
index 00000000..afd79f6c
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/knn.r
@@ -0,0 +1,7 @@
+library(knn)
+x <- cbind(x_train,y_train)
+# Fitting model
+fit <-knn(y_train ~ ., data = x,k=5)
+summary(fit)
+# Predict Output 
+predicted= predict(fit,x_test)
diff --git a/Desktop/open-source/R/classification_algorithms/light_gbm.r b/Desktop/open-source/R/classification_algorithms/light_gbm.r
new file mode 100644
index 00000000..993ba931
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/light_gbm.r
@@ -0,0 +1,26 @@
+library(RLightGBM)
+data(example.binary)
+#Parameters
+
+num_iterations <- 100
+config <- list(objective = "binary",  metric="binary_logloss,auc", learning_rate = 0.1, num_leaves = 63, tree_learner = "serial", feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)
+
+#Create data handle and booster
+handle.data <- lgbm.data.create(x)
+
+lgbm.data.setField(handle.data, "label", y)
+
+handle.booster <- lgbm.booster.create(handle.data, lapply(config, as.character))
+
+#Train for num_iterations iterations and eval every 5 steps
+
+lgbm.booster.train(handle.booster, num_iterations, 5)
+
+#Predict
+pred <- lgbm.booster.predict(handle.booster, x.test)
+
+#Test accuracy
+sum(y.test == (y.pred > 0.5)) / length(y.test)
+
+#Save model (can be loaded again via lgbm.booster.load(filename))
+lgbm.booster.save(handle.booster, filename = "/tmp/model.txt")
diff --git a/Desktop/open-source/R/classification_algorithms/logistic_regression.r b/Desktop/open-source/R/classification_algorithms/logistic_regression.r
new file mode 100644
index 00000000..1e946846
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/logistic_regression.r
@@ -0,0 +1,6 @@
+x <- cbind(x_train,y_train)
+# Train the model using the training sets and check score
+logistic <- glm(y_train ~ ., data = x,family='binomial')
+summary(logistic)
+# Predict Output
+predicted= predict(logistic,x_test)
diff --git a/Desktop/open-source/R/classification_algorithms/logistic_regression_2.r b/Desktop/open-source/R/classification_algorithms/logistic_regression_2.r
new file mode 100644
index 00000000..5060e7d4
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/logistic_regression_2.r
@@ -0,0 +1,10 @@
+# Introduction to logistic regression
+
+# glm stands for Generalized Linear Model
+mod1 <- glm(y_data~x_data, data=name_of_the_dataframe, family="binomial")
+
+# displays the output of the model computed by the previous line
+summary(mod1)
+
+# modeled data : it predicts the output for x_test_data as input information for the model
+predicted <- predict(mod1, x_test_data)
diff --git a/Desktop/open-source/R/classification_algorithms/naive_bayes.r b/Desktop/open-source/R/classification_algorithms/naive_bayes.r
new file mode 100644
index 00000000..c160722b
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/naive_bayes.r
@@ -0,0 +1,7 @@
+library(e1071)
+x <- cbind(x_train,y_train)
+# Fitting model
+fit <-naiveBayes(y_train ~ ., data = x)
+summary(fit)
+# Predict Output 
+predicted= predict(fit,x_test)
diff --git a/Desktop/open-source/R/classification_algorithms/random_forest.r b/Desktop/open-source/R/classification_algorithms/random_forest.r
new file mode 100644
index 00000000..e45d43ae
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/random_forest.r
@@ -0,0 +1,7 @@
+library(randomForest)
+x <- cbind(x_train,y_train)
+# Fitting model
+fit <- randomForest(Species ~ ., x,ntree=500)
+summary(fit)
+# Predict Output 
+predicted= predict(fit,x_test)
diff --git a/Desktop/open-source/R/classification_algorithms/svm.r b/Desktop/open-source/R/classification_algorithms/svm.r
new file mode 100644
index 00000000..9cc4b5b2
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/svm.r
@@ -0,0 +1,7 @@
+library(e1071)
+x <- cbind(x_train,y_train)
+# Fitting model
+fit <-svm(y_train ~ ., data = x)
+summary(fit)
+# Predict Output 
+predicted= predict(fit,x_test)
diff --git a/Desktop/open-source/R/classification_algorithms/xgboost.r b/Desktop/open-source/R/classification_algorithms/xgboost.r
new file mode 100644
index 00000000..5e54ba57
--- /dev/null
+++ b/Desktop/open-source/R/classification_algorithms/xgboost.r
@@ -0,0 +1,19 @@
+library(tidyverse)
+library(xgboost)
+
+ind<-sample(2,nrow(diamonds),replace = T,prob = c(0.7,0.3))
+train.set<-diamonds[ind==1,]
+test.set<-diamonds[ind==2,]
+
+xgb.train<-bind_cols(select_if(train.set,is.numeric),model.matrix(~cut-1,train.set) %>% as.tibble(),model.matrix(~color-1,train.set) %>% as.tibble(),model.matrix(~clarity-1,train.set) %>% as.tibble())
+xgboost.train<-xgb.DMatrix(data = as.matrix(select(xgb.train,-price)),label=xgb.train$price)
+xgb.test<-bind_cols(select_if(test.set,is.numeric),model.matrix(~cut-1,test.set) %>% as.tibble(),model.matrix(~color-1,test.set) %>% as.tibble(),model.matrix(~clarity-1,test.set) %>% as.tibble())
+xgboost.test<-xgb.DMatrix(data = select(xgb.test,-price) %>% as.matrix(),label=xgb.test$price)
+
+param<-list(eval_metric='rmse',gamma=1,max_depth=6,nthread = 3)
+xg.model<-xgb.train(data = xgboost.train,params = param,watchlist = list(test=xgboost.test),nrounds = 500,early_stopping_rounds = 60,
+                      print_every_n = 30)
+                      
+xg.predict<-predict(xg.model,xgboost.test)
+mse.xgb<-sqrt(mean((test.set$price-xg.predict)^2))
+plot((test.set$price-xg.predict))
diff --git a/Desktop/open-source/R/clustering_algorithms/dbscan_clustering.r b/Desktop/open-source/R/clustering_algorithms/dbscan_clustering.r
new file mode 100644
index 00000000..b5e0ba2e
--- /dev/null
+++ b/Desktop/open-source/R/clustering_algorithms/dbscan_clustering.r
@@ -0,0 +1,3 @@
+library(dbscan)
+cl <- dbscan(iris[,-5], eps = .5, minPts = 5)
+plot(iris[,-5], col = cl$cluster)
diff --git a/Desktop/open-source/R/clustering_algorithms/gmm.r b/Desktop/open-source/R/clustering_algorithms/gmm.r
new file mode 100644
index 00000000..696009ac
--- /dev/null
+++ b/Desktop/open-source/R/clustering_algorithms/gmm.r
@@ -0,0 +1,4 @@
+library(mclust) # Gaussian mixture model (GMM)
+gmm_fit <- Mclust(iris[, 1:4]) # Fit a GMM model
+summary(gmm_fit) # Summary table 
+plot(gmm_fit, 'BIC') # Select model based on BIC
diff --git a/Desktop/open-source/R/clustering_algorithms/heirarchical_clustering.r b/Desktop/open-source/R/clustering_algorithms/heirarchical_clustering.r
new file mode 100644
index 00000000..d6ea84cc
--- /dev/null
+++ b/Desktop/open-source/R/clustering_algorithms/heirarchical_clustering.r
@@ -0,0 +1,3 @@
+set.seed(42)
+clusters <- hclust(dist(iris[, -5]))
+plot(clusters)
diff --git a/Desktop/open-source/R/clustering_algorithms/k_means.r b/Desktop/open-source/R/clustering_algorithms/k_means.r
new file mode 100644
index 00000000..735948e8
--- /dev/null
+++ b/Desktop/open-source/R/clustering_algorithms/k_means.r
@@ -0,0 +1,3 @@
+library(cluster)
+set.seed(42)
+fit <- kmeans(X, 3) # 3 cluster solution
diff --git a/Desktop/open-source/R/clustering_algorithms/kmeans_clustering.r b/Desktop/open-source/R/clustering_algorithms/kmeans_clustering.r
new file mode 100644
index 00000000..2a19d2d4
--- /dev/null
+++ b/Desktop/open-source/R/clustering_algorithms/kmeans_clustering.r
@@ -0,0 +1,4 @@
+set.seed(42)
+cl <- kmeans(iris[,-5], 3)
+plot(iris[,-5], col = cl$cluster)
+points(cl$centers, col = 1:3, pch = 8)
diff --git a/Desktop/open-source/R/clustering_algorithms/kmeans_raw_r.r b/Desktop/open-source/R/clustering_algorithms/kmeans_raw_r.r
new file mode 100644
index 00000000..1cb7d69e
--- /dev/null
+++ b/Desktop/open-source/R/clustering_algorithms/kmeans_raw_r.r
@@ -0,0 +1,53 @@
+custonKmeans<-function(dataset=NA,k=NA){
+  if(is.na(dataset) || is.na(k)){
+    stop("You must input valid parameters!")
+  }
+  Eudist<-function(x,y){
+    distance<-sqrt(sum((x-y)^2))
+    return (distance)
+  }
+  
+  rows.dataset<-nrow(dataset)
+  continue.change=TRUE
+  initPoint<-dataset[sample.int(rows.dataset,size = k),]
+  formerPoint<-initPoint
+  iterPoint<-matrix(0,nrow = k,ncol = ncol(dataset))
+  
+  #记录每一个点到每一个类的距离
+  error.matrix<-matrix(0,nrow=rows.dataset,ncol=k)
+  while(continue.change){
+    #记录每个点所属的类是哪一个
+    cluster.matrix<-matrix(0,nrow=rows.dataset,ncol=k)
+    for(i in 1:rows.dataset){#计算每个点到三个初始中心点的距离
+      for(j in 1:k){
+        error.matrix[i,j]<-Eudist(dataset[i,],formerPoint[j,])
+      }
+    }
+    #将每一个点所属的类计算出来
+    for(i in 1:rows.dataset){
+      cluster.matrix[i,which.min(error.matrix[i,])]<-1
+    }
+    
+    #更新新的质心位置
+    for(i in 1:k){
+      iterPoint[i,]<-apply(dataset[which(cluster.matrix[,i] == 1),],2,"mean")
+    }
+    all.true<-c()
+    for(i in 1:k){
+      if(all(formerPoint[i,] == iterPoint[i,]) == T){
+        all.true[i]<-TRUE
+      }
+    }
+    formerPoint = iterPoint
+    continue.change=ifelse(all(all.true) == T,F,T)
+  }
+  colnames(iterPoint)<-colnames(dataset)
+  out=list()
+  out[["centers"]]<-iterPoint
+  out[["distance"]]<-error.matrix
+  out[["cluster"]]<-rep(1,rows.dataset)
+  for(i in 1:rows.dataset){
+    out[["cluster"]][i]<-which(cluster.matrix[i,] == 1)
+  }
+  return(out)
+}
diff --git a/Desktop/open-source/R/clustering_algorithms/pam.r b/Desktop/open-source/R/clustering_algorithms/pam.r
new file mode 100644
index 00000000..b2148e75
--- /dev/null
+++ b/Desktop/open-source/R/clustering_algorithms/pam.r
@@ -0,0 +1,3 @@
+library(cluster) 
+pam_fit <- pam(iris[, 1:4], 5) # Partition Around Medoids
+summary(pam_fit) # Get summary
diff --git a/Desktop/open-source/R/data_manipulation/label_encode.r b/Desktop/open-source/R/data_manipulation/label_encode.r
new file mode 100644
index 00000000..1a2cdb48
--- /dev/null
+++ b/Desktop/open-source/R/data_manipulation/label_encode.r
@@ -0,0 +1,31 @@
+library(tidyverse)
+#Divide data into train and test in 70% and 30%
+ind<-sample(2,nrow(diamonds),replace = T,prob = c(0.7,0.3))
+train.set <- diamonds[ind==1,]
+test.set <- diamonds[ind==2,]
+
+#Combine the dataset using rbind function(inbuilt function)
+combi <- rbind(train.set, test.set)
+
+##Label Encoding
+combi[, cut_num := ifelse(cut == "Fair",0,
+                                   ifelse(cut == "Good",1,
+                                   ifelse(cut == "Very Good",2,
+                                   ifelse(cut == "Premium",3,4))))]
+combi[, color_num := ifelse(color == "D",0,
+                                   ifelse(color == "E",2,
+                                   ifelse(color == "F",3,
+                                   ifelse(color == "G",4,
+                                   ifelse(color == "H",5,
+                                   ifelse(color == "I",6,7))))))]
+
+# Column "clarity" won't be taken in label encoding as it contains more variables.
+#The more variables in column in label encoding, the model will perform less.
+
+#Removing categorical variables after label encoding
+combi[,c("color", "cut") := NULL)
+                                                     
+#Divide data back into train and test in 70% and 30%
+ind<-sample(2,nrow(combi),replace = T,prob = c(0.7,0.3))
+train.set <- combi[ind==1,]
+test.set <- combi[ind==2,]
diff --git a/Desktop/open-source/R/data_manipulation/one_hot_encode.r b/Desktop/open-source/R/data_manipulation/one_hot_encode.r
new file mode 100644
index 00000000..f5a59b49
--- /dev/null
+++ b/Desktop/open-source/R/data_manipulation/one_hot_encode.r
@@ -0,0 +1,27 @@
+oneHotEncode <- function(x, fullRank = T){
+    if(fullRank){
+        return(model.matrix(~ 0 + ., data = x))
+    } else {
+        charCols <- colnames(x)[sapply(x, is.character)]
+        if(length(charCols) > 0){
+            for(col in charCols){
+                x[[eval(col)]] <- factor(x[[eval(col)]])
+            }
+        }
+        factorCols <- colnames(x)[sapply(x, is.factor)]
+        contrastsList <- vector(mode = "list", length = length(factorCols))
+        names(contrastsList) <- factorCols
+        if(length(factorCols) > 0){
+            for(col in factorCols){
+                contrastsList[[eval(col)]] <- contrasts(x[[eval(col)]], contrasts = F)
+            }
+            return(model.matrix(~ 0 + ., data = x, contrasts = contrastsList))
+        } else {
+            return(model.matrix(~ 0 + ., data = x))
+        }
+    }
+}
+
+diamonds <- ggplot2::diamonds
+head(oneHotEncode(diamonds))
+head(oneHotEncode(diamonds, fullRank = F))
diff --git a/Desktop/open-source/R/data_manipulation/shorten.vector.r b/Desktop/open-source/R/data_manipulation/shorten.vector.r
new file mode 100644
index 00000000..00460f2c
--- /dev/null
+++ b/Desktop/open-source/R/data_manipulation/shorten.vector.r
@@ -0,0 +1,23 @@
+shorten.vector <- function(vector,by){
+  # get last elements
+  vec_new <- vector |> tail(by) 
+  
+  # get index of last elements
+  index <- c()
+  for(i in vec_new){
+    values <- which(vector == i) 
+    index <- c(index,values)
+  }
+  
+  # delete index from vector
+  final_vec <- vector[-c(index)]
+  
+  # return final output
+  return(final_vec)
+  
+  
+}
+
+fruits <- c("Pear","Banana","Peach","Grape","Apple","Orange")
+
+shorten.vector(fruits,by = 1)
diff --git a/Desktop/open-source/R/data_mining/.gitignore b/Desktop/open-source/R/data_mining/.gitignore
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/Desktop/open-source/R/data_mining/.gitignore
@@ -0,0 +1 @@
+
diff --git a/Desktop/open-source/R/data_mining/README.md b/Desktop/open-source/R/data_mining/README.md
new file mode 100644
index 00000000..c3e99506
--- /dev/null
+++ b/Desktop/open-source/R/data_mining/README.md
@@ -0,0 +1,5 @@
+# Data Mining in R
+
+## Tutorials
+
+  - [Top 10 data mining algorithms in plain R](https://hackerbits.com/data/top-10-data-mining-algorithms-in-plain-r/)
diff --git a/Desktop/open-source/R/data_preprocessing/data_normalization_standardization.r b/Desktop/open-source/R/data_preprocessing/data_normalization_standardization.r
new file mode 100644
index 00000000..5ae62bcf
--- /dev/null
+++ b/Desktop/open-source/R/data_preprocessing/data_normalization_standardization.r
@@ -0,0 +1,49 @@
+# normalization & standardization
+normalization<-function(x){
+  return((x-min(x))/(max(x)-min(x)))
+}
+
+standardization<-function(x){
+  return((x-mean(x))/sd(x))
+}
+
+head(iris)
+# Sepal.Length Sepal.Width Petal.Length Petal.Width Species
+# 1          5.1         3.5          1.4         0.2  setosa
+# 2          4.9         3.0          1.4         0.2  setosa
+# 3          4.7         3.2          1.3         0.2  setosa
+# 4          4.6         3.1          1.5         0.2  setosa
+# 5          5.0         3.6          1.4         0.2  setosa
+# 6          5.4         3.9          1.7         0.4  setosa
+
+iris<-iris[,-5]
+head(iris)
+# Sepal.Length Sepal.Width Petal.Length Petal.Width
+# 1          5.1         3.5          1.4         0.2
+# 2          4.9         3.0          1.4         0.2
+# 3          4.7         3.2          1.3         0.2
+# 4          4.6         3.1          1.5         0.2
+# 5          5.0         3.6          1.4         0.2
+# 6          5.4         3.9          1.7         0.4
+
+#normalize
+apply(as.matrix(iris),2,normalization)
+# Sepal.Length Sepal.Width Petal.Length Petal.Width
+# [1,]   0.22222222  0.62500000   0.06779661  0.04166667
+# [2,]   0.16666667  0.41666667   0.06779661  0.04166667
+# [3,]   0.11111111  0.50000000   0.05084746  0.04166667
+# [4,]   0.08333333  0.45833333   0.08474576  0.04166667
+# [5,]   0.19444444  0.66666667   0.06779661  0.04166667
+# [6,]   0.30555556  0.79166667   0.11864407  0.12500000
+# [7,]   0.08333333  0.58333333   0.06779661  0.08333333
+
+#standardize
+apply(as.matrix(iris),2,standardization)
+# Sepal.Length Sepal.Width Petal.Length   Petal.Width
+# [1,]  -0.89767388  1.01560199  -1.33575163 -1.3110521482
+# [2,]  -1.13920048 -0.13153881  -1.33575163 -1.3110521482
+# [3,]  -1.38072709  0.32731751  -1.39239929 -1.3110521482
+# [4,]  -1.50149039  0.09788935  -1.27910398 -1.3110521482
+# [5,]  -1.01843718  1.24503015  -1.33575163 -1.3110521482
+# [6,]  -0.53538397  1.93331463  -1.16580868 -1.0486667950
+# [7,]  -1.50149039  0.78617383  -1.33575163 -1.1798594716
\ No newline at end of file
diff --git a/Desktop/open-source/R/data_preprocessing/data_processing.r b/Desktop/open-source/R/data_preprocessing/data_processing.r
new file mode 100644
index 00000000..23e71b0d
--- /dev/null
+++ b/Desktop/open-source/R/data_preprocessing/data_processing.r
@@ -0,0 +1,134 @@
+library(xlsx)
+## Loading required package: rJava
+## Loading required package: xlsxjars
+
+setwd("/Users/chenfeiyang")
+cameraData <- read.xlsx("./data/cameras.xlsx", sheetIndex = 1, header = TRUE)
+cameraData <- read.xlsx("./data/cameras.xlsx", "Baltimore Fixed Speed Cameras", 
+    header = TRUE)
+head(cameraData)
+##                          address direction      street  crossStreet
+## 1       S CATON AVE & BENSON AVE       N/B   Caton Ave   Benson Ave
+## 2       S CATON AVE & BENSON AVE       S/B   Caton Ave   Benson Ave
+## 3 WILKENS AVE & PINE HEIGHTS AVE       E/B Wilkens Ave Pine Heights
+## 4        THE ALAMEDA & E 33RD ST       S/B The Alameda      33rd St
+## 5        E 33RD ST & THE ALAMEDA       E/B      E 33rd  The Alameda
+## 6        ERDMAN AVE & N MACON ST       E/B      Erdman     Macon St
+##                 intersection                      Location.1
+## 1     Caton Ave & Benson Ave (39.2693779962, -76.6688185297)
+## 2     Caton Ave & Benson Ave (39.2693157898, -76.6689698176)
+## 3 Wilkens Ave & Pine Heights  (39.2720252302, -76.676960806)
+## 4     The Alameda  & 33rd St (39.3285013141, -76.5953545714)
+## 5      E 33rd  & The Alameda (39.3283410623, -76.5953594625)
+## 6         Erdman  & Macon St (39.3068045671, -76.5593167803)
+
+# Read specific rows and columns in Excel
+colIndex <- 2:3
+rowIndex <- 1:4
+cameraDataSubset <- read.xlsx("./data/cameras.xlsx", sheetIndex = 1, colIndex = colIndex, 
+    rowIndex = rowIndex)
+cameraDataSubset
+##   direction      street
+## 1       N/B   Caton Ave
+## 2       S/B   Caton Ave
+## 3       E/B Wilkens Ave
+
+# Subsetting - quick review
+set.seed(13435)
+X <- data.frame(var1 = sample(1:5), var2 = sample(6:10), var3 = sample(11:15))
+X <- X[sample(1:5), ]
+X$var2[c(1, 3)] = NA
+X
+##   var1 var2 var3
+## 1    2   NA   15
+## 4    1   10   11
+## 2    3   NA   12
+## 3    5    6   14
+## 5    4    9   13
+
+X[, 1]
+## [1] 2 1 3 5 4
+X[, "var1"]
+## [1] 2 1 3 5 4
+X[1:2, "var2"]
+## [1] NA 10
+
+# Logicals and: & , or: |
+X[(X$var1 <= 3 & X$var3 > 11), ]
+##   var1 var2 var3
+## 1    2   NA   15
+## 2    3   NA   12
+X[(X$var1 <= 3 | X$var3 > 15), ]
+##   var1 var2 var3
+## 1    2   NA   15
+## 4    1   10   11
+## 2    3   NA   12
+
+## Dealing with missing values
+X[which(X$var2 > 8), ]
+##   var1 var2 var3
+## 4    1   10   11
+## 5    4    9   13
+
+# Sorting
+sort(X$var1)
+## [1] 1 2 3 4 5
+sort(X$var1, decreasing = TRUE)
+## [1] 5 4 3 2 1
+sort(X$var2, na.last = TRUE)
+## [1]  6  9 10 NA NA
+
+# Ordering
+X[order(X$var1), ]
+##   var1 var2 var3
+## 4    1   10   11
+## 1    2   NA   15
+## 2    3   NA   12
+## 5    4    9   13
+## 3    5    6   14
+
+X[order(X$var1, X$var3), ]
+##   var1 var2 var3
+## 4    1   10   11
+## 1    2   NA   15
+## 2    3   NA   12
+## 5    4    9   13
+## 3    5    6   14
+
+## Sort using the arrange function of the plyr package
+
+library(plyr)
+arrange(X, var1)
+##   var1 var2 var3
+## 1    1   10   11
+## 2    2   NA   15
+## 3    3   NA   12
+## 4    4    9   13
+## 5    5    6   14
+
+arrange(X, desc(var1))
+##   var1 var2 var3
+## 1    5    6   14
+## 2    4    9   13
+## 3    3   NA   12
+## 4    2   NA   15
+## 5    1   10   11
+
+# Add row and column
+X$var4 <- rnorm(5)
+X
+##   var1 var2 var3     var4
+## 1    2   NA   15  0.18760
+## 4    1   10   11  1.78698
+## 2    3   NA   12  0.49669
+## 3    5    6   14  0.06318
+## 5    4    9   13 -0.53613
+
+Y <- cbind(X, rnorm(5))
+Y
+##   var1 var2 var3     var4 rnorm(5)
+## 1    2   NA   15  0.18760  0.62578
+## 4    1   10   11  1.78698 -2.45084
+## 2    3   NA   12  0.49669  0.08909
+## 3    5    6   14  0.06318  0.47839
+## 5    4    9   13 -0.53613  1.00053
diff --git a/Desktop/open-source/R/data_preprocessing/dimensionality_reduction_algorithms.r b/Desktop/open-source/R/data_preprocessing/dimensionality_reduction_algorithms.r
new file mode 100644
index 00000000..a4b6dbc1
--- /dev/null
+++ b/Desktop/open-source/R/data_preprocessing/dimensionality_reduction_algorithms.r
@@ -0,0 +1,4 @@
+library(stats)
+pca <- princomp(train, cor = TRUE)
+train_reduced  <- predict(pca,train)
+test_reduced  <- predict(pca,test)
diff --git a/Desktop/open-source/R/data_preprocessing/k_folds.r b/Desktop/open-source/R/data_preprocessing/k_folds.r
new file mode 100644
index 00000000..37ea54a8
--- /dev/null
+++ b/Desktop/open-source/R/data_preprocessing/k_folds.r
@@ -0,0 +1,29 @@
+# K folds cross validation is essential for machine learning
+# createFolds function in package caret is easy to use
+# here we write our own function
+
+get_k_folds<-function(y = c(),k = 10, isList = TRUE, seed = 123){
+  set.seed(seed)
+  folds<-sample(1:length(y), length(y))
+  every_n<-ceiling(length(y)/k)
+  matFolds<-suppressWarnings(matrix(folds, ncol=every_n, byrow = T))
+  
+  if(isList){
+    value<-NULL
+    rownames(matFolds)<-paste("Folds",1:k,sep="")
+    value<-lapply(1:k, function(x){
+      if(x == k){
+        return(matFolds[x,][1:(length(y)-every_n*(k-1))])
+      }else{
+        return(matFolds[x,])
+      }
+    })
+  }else{
+    value<-c()
+    for(i in 1:length(y)){
+      value[i]<-ceiling(i/every_n)
+    }
+  }
+  
+  return(value)
+}
diff --git a/Desktop/open-source/R/data_preprocessing/lasso.r b/Desktop/open-source/R/data_preprocessing/lasso.r
new file mode 100644
index 00000000..01bbc89c
--- /dev/null
+++ b/Desktop/open-source/R/data_preprocessing/lasso.r
@@ -0,0 +1,20 @@
+data(ggplot2::diamonds)
+library(caret)
+library(dplyr)
+dia.trans<-bind_cols(diamonds %>% select_if(is.numeric),
+                     model.matrix(~cut-1,diamonds) %>% as_tibble(),
+                     model.matrix(~color-1,diamonds) %>% as_tibble(),
+                     model.matrix(~clarity-1,diamonds) %>% as_tibble())
+
+#setting parameters alpha and lambda
+lasso_expand<-expand.grid(alpha = 1, lambda = seq(0.001,0.1,by = 0.0005))
+lasso_mod <- train(x=dia.trans %>% select(-price), y=dia.trans$price, method='glmnet', 
+                   tuneGrid=lasso_expand)
+
+#best tune
+lasso_mod$bestTune
+lasso_mod$results$RMSE
+
+lasso_imp<-varImp(lasso_mod)
+#get the importance of each feature and eliminate some of them
+lasso_imp$importance
diff --git a/Desktop/open-source/R/data_structures/binary_search_tree.r b/Desktop/open-source/R/data_structures/binary_search_tree.r
new file mode 100644
index 00000000..d2743515
--- /dev/null
+++ b/Desktop/open-source/R/data_structures/binary_search_tree.r
@@ -0,0 +1,489 @@
+# Binary Search Tree (BST) Implementation
+#
+# A Binary Search Tree is a hierarchical data structure where each node has at most
+# two children (left and right), and for every node:
+# - All values in the left subtree are less than the node's value
+# - All values in the right subtree are greater than the node's value
+# - Both subtrees are also binary search trees
+#
+# Time Complexities (average case):
+# - Search: O(log n)  
+# - Insert: O(log n)
+# - Delete: O(log n)
+# - Traversal: O(n)
+#
+# Worst case: O(n) when tree becomes skewed (like a linked list)
+#
+# Applications:
+# - Database indexing
+# - Expression parsing
+# - Priority queues
+# - File system organization
+
+# Define BST Node structure using R6 class system
+if (!require(R6, quietly = TRUE)) {
+  cat("Installing R6 package for object-oriented programming...\n")
+  install.packages("R6", quiet = TRUE)
+  library(R6)
+}
+
+# BST Node class
+BSTNode <- R6Class("BSTNode",
+  public = list(
+    value = NULL,
+    left = NULL,
+    right = NULL,
+    
+    initialize = function(value) {
+      self$value <- value
+      self$left <- NULL
+      self$right <- NULL
+    }
+  )
+)
+
+# Binary Search Tree class
+BST <- R6Class("BST",
+  public = list(
+    root = NULL,
+    size = 0,
+    
+    initialize = function() {
+      self$root <- NULL
+      self$size <- 0
+    },
+    
+    # Insert a value into the BST
+    insert = function(value) {
+      if (is.null(self$root)) {
+        self$root <- BSTNode$new(value)
+        self$size <- self$size + 1
+      } else {
+        private$insert_recursive(self$root, value)
+      }
+    },
+    
+    # Search for a value in the BST
+    search = function(value) {
+      return(private$search_recursive(self$root, value))
+    },
+    
+    # Delete a value from the BST
+    delete = function(value) {
+      if (self$search(value)) {
+        self$root <- private$delete_recursive(self$root, value)
+        self$size <- self$size - 1
+        return(TRUE)
+      }
+      return(FALSE)
+    },
+    
+    # Find minimum value in the BST
+    find_min = function() {
+      if (is.null(self$root)) return(NULL)
+      return(private$find_min_recursive(self$root)$value)
+    },
+    
+    # Find maximum value in the BST  
+    find_max = function() {
+      if (is.null(self$root)) return(NULL)
+      return(private$find_max_recursive(self$root)$value)
+    },
+    
+    # In-order traversal (left, root, right) - gives sorted output
+    inorder_traversal = function() {
+      result <- c()
+      private$inorder_recursive(self$root, result)
+      return(result)
+    },
+    
+    # Pre-order traversal (root, left, right)
+    preorder_traversal = function() {
+      result <- c()
+      private$preorder_recursive(self$root, result)
+      return(result)
+    },
+    
+    # Post-order traversal (left, right, root)
+    postorder_traversal = function() {
+      result <- c()
+      private$postorder_recursive(self$root, result)
+      return(result)
+    },
+    
+    # Level-order traversal (breadth-first)
+    level_order_traversal = function() {
+      if (is.null(self$root)) return(c())
+      
+      result <- c()
+      queue <- list(self$root)
+      
+      while (length(queue) > 0) {
+        node <- queue[[1]]
+        queue <- queue[-1]
+        
+        result <- c(result, node$value)
+        
+        if (!is.null(node$left)) {
+          queue <- append(queue, list(node$left))
+        }
+        if (!is.null(node$right)) {
+          queue <- append(queue, list(node$right))
+        }
+      }
+      
+      return(result)
+    },
+    
+    # Get height of the tree
+    height = function() {
+      return(private$height_recursive(self$root))
+    },
+    
+    # Check if tree is valid BST
+    is_valid_bst = function() {
+      return(private$is_valid_bst_recursive(self$root, -Inf, Inf))
+    },
+    
+    # Get size of the tree
+    get_size = function() {
+      return(self$size)
+    },
+    
+    # Check if tree is empty
+    is_empty = function() {
+      return(is.null(self$root))
+    },
+    
+    # Print tree structure
+    print_tree = function() {
+      if (is.null(self$root)) {
+        cat("Empty tree\n")
+        return()
+      }
+      private$print_tree_recursive(self$root, "", TRUE)
+    }
+  ),
+  
+  private = list(
+    # Recursive helper for insertion
+    insert_recursive = function(node, value) {
+      if (value < node$value) {
+        if (is.null(node$left)) {
+          node$left <- BSTNode$new(value)
+          self$size <- self$size + 1
+        } else {
+          private$insert_recursive(node$left, value)
+        }
+      } else if (value > node$value) {
+        if (is.null(node$right)) {
+          node$right <- BSTNode$new(value)
+          self$size <- self$size + 1
+        } else {
+          private$insert_recursive(node$right, value)
+        }
+      }
+      # If value == node$value, don't insert (no duplicates)
+    },
+    
+    # Recursive helper for search
+    search_recursive = function(node, value) {
+      if (is.null(node) || node$value == value) {
+        return(!is.null(node))
+      }
+      
+      if (value < node$value) {
+        return(private$search_recursive(node$left, value))
+      } else {
+        return(private$search_recursive(node$right, value))
+      }
+    },
+    
+    # Recursive helper for deletion
+    delete_recursive = function(node, value) {
+      if (is.null(node)) {
+        return(NULL)
+      }
+      
+      if (value < node$value) {
+        node$left <- private$delete_recursive(node$left, value)
+      } else if (value > node$value) {
+        node$right <- private$delete_recursive(node$right, value)
+      } else {
+        # Node to delete found
+        if (is.null(node$left)) {
+          return(node$right)
+        } else if (is.null(node$right)) {
+          return(node$left)
+        }
+        
+        # Node has two children - find inorder successor
+        successor <- private$find_min_recursive(node$right)
+        node$value <- successor$value
+        node$right <- private$delete_recursive(node$right, successor$value)
+      }
+      
+      return(node)
+    },
+    
+    # Find minimum node
+    find_min_recursive = function(node) {
+      while (!is.null(node$left)) {
+        node <- node$left
+      }
+      return(node)
+    },
+    
+    # Find maximum node
+    find_max_recursive = function(node) {
+      while (!is.null(node$right)) {
+        node <- node$right
+      }
+      return(node)
+    },
+    
+    # In-order traversal helper
+    inorder_recursive = function(node, result) {
+      if (!is.null(node)) {
+        result <<- private$inorder_recursive(node$left, result)
+        result <<- c(result, node$value)
+        result <<- private$inorder_recursive(node$right, result)
+      }
+      return(result)
+    },
+    
+    # Pre-order traversal helper
+    preorder_recursive = function(node, result) {
+      if (!is.null(node)) {
+        result <<- c(result, node$value)
+        result <<- private$preorder_recursive(node$left, result)
+        result <<- private$preorder_recursive(node$right, result)
+      }
+      return(result)
+    },
+    
+    # Post-order traversal helper
+    postorder_recursive = function(node, result) {
+      if (!is.null(node)) {
+        result <<- private$postorder_recursive(node$left, result)
+        result <<- private$postorder_recursive(node$right, result)
+        result <<- c(result, node$value)
+      }
+      return(result)
+    },
+    
+    # Height calculation helper
+    height_recursive = function(node) {
+      if (is.null(node)) {
+        return(-1)  # Height of empty tree is -1
+      }
+      
+      left_height <- private$height_recursive(node$left)
+      right_height <- private$height_recursive(node$right)
+      
+      return(1 + max(left_height, right_height))
+    },
+    
+    # BST validation helper
+    is_valid_bst_recursive = function(node, min_val, max_val) {
+      if (is.null(node)) {
+        return(TRUE)
+      }
+      
+      if (node$value <= min_val || node$value >= max_val) {
+        return(FALSE)
+      }
+      
+      return(private$is_valid_bst_recursive(node$left, min_val, node$value) &&
+             private$is_valid_bst_recursive(node$right, node$value, max_val))
+    },
+    
+    # Tree printing helper
+    print_tree_recursive = function(node, prefix, is_last) {
+      if (!is.null(node)) {
+        cat(prefix)
+        cat(if (is_last) "└── " else "├── ")
+        cat(node$value, "\n")
+        
+        new_prefix <- paste0(prefix, if (is_last) "    " else "│   ")
+        
+        if (!is.null(node$left) || !is.null(node$right)) {
+          if (!is.null(node$left)) {
+            private$print_tree_recursive(node$left, new_prefix, is.null(node$right))
+          }
+          if (!is.null(node$right)) {
+            private$print_tree_recursive(node$right, new_prefix, TRUE)
+          }
+        }
+      }
+    }
+  )
+)
+
+# Utility functions for BST operations
+
+# Create BST from array
+create_bst_from_array <- function(arr) {
+  #' Create a BST from an array of values
+  #' @param arr: Array of values to insert
+  #' @return: BST object
+  
+  bst <- BST$new()
+  for (value in arr) {
+    bst$insert(value)
+  }
+  return(bst)
+}
+
+# Check if two BSTs are identical
+are_identical_bsts <- function(bst1, bst2) {
+  #' Check if two BSTs have identical structure and values
+  #' @param bst1: First BST
+  #' @param bst2: Second BST
+  #' @return: TRUE if identical, FALSE otherwise
+  
+  traversal1 <- bst1$preorder_traversal()
+  traversal2 <- bst2$preorder_traversal()
+  
+  return(identical(traversal1, traversal2))
+}
+
+# Find kth smallest element in BST
+kth_smallest <- function(bst, k) {
+  #' Find the kth smallest element in BST
+  #' @param bst: BST object
+  #' @param k: Position (1-indexed)
+  #' @return: kth smallest value or NULL if k is out of bounds
+  
+  inorder <- bst$inorder_traversal()
+  if (k > 0 && k <= length(inorder)) {
+    return(inorder[k])
+  }
+  return(NULL)
+}
+
+# Example usage and testing
+cat("=== Binary Search Tree (BST) Implementation ===\n\n")
+
+# Test 1: Basic BST operations
+cat("1. Basic BST Operations\n")
+bst <- BST$new()
+
+# Insert values
+values <- c(50, 30, 70, 20, 40, 60, 80)
+cat("Inserting values:", paste(values, collapse = ", "), "\n")
+
+for (value in values) {
+  bst$insert(value)
+}
+
+cat("Tree size:", bst$get_size(), "\n")
+cat("Tree height:", bst$height(), "\n")
+cat("Is valid BST:", bst$is_valid_bst(), "\n\n")
+
+# Test 2: Tree visualization
+cat("2. Tree Structure\n")
+bst$print_tree()
+cat("\n")
+
+# Test 3: Search operations
+cat("3. Search Operations\n")
+search_values <- c(40, 25, 80, 100)
+for (value in search_values) {
+  found <- bst$search(value)
+  cat("Search for", value, ":", if (found) "Found" else "Not found", "\n")
+}
+cat("\n")
+
+# Test 4: Min/Max operations
+cat("4. Min/Max Operations\n")
+cat("Minimum value:", bst$find_min(), "\n")
+cat("Maximum value:", bst$find_max(), "\n\n")
+
+# Test 5: Tree traversals
+cat("5. Tree Traversals\n")
+cat("In-order (sorted):   ", paste(bst$inorder_traversal(), collapse = ", "), "\n")
+cat("Pre-order:           ", paste(bst$preorder_traversal(), collapse = ", "), "\n")
+cat("Post-order:          ", paste(bst$postorder_traversal(), collapse = ", "), "\n")
+cat("Level-order (BFS):   ", paste(bst$level_order_traversal(), collapse = ", "), "\n\n")
+
+# Test 6: Deletion operations
+cat("6. Deletion Operations\n")
+delete_values <- c(20, 30, 50)  # Delete leaf, node with one child, root
+
+for (value in delete_values) {
+  cat("Deleting", value, ":", if (bst$delete(value)) "Success" else "Failed", "\n")
+  cat("Tree after deletion:\n")
+  bst$print_tree()
+  cat("In-order traversal:", paste(bst$inorder_traversal(), collapse = ", "), "\n")
+  cat("Tree size:", bst$get_size(), "\n\n")
+}
+
+# Test 7: Create BST from sorted vs unsorted array
+cat("7. BST Creation Comparison\n")
+
+# Sorted array (creates skewed tree)
+sorted_array <- c(1, 2, 3, 4, 5, 6, 7)
+bst_sorted <- create_bst_from_array(sorted_array)
+cat("BST from sorted array [1,2,3,4,5,6,7]:\n")
+cat("Height:", bst_sorted$height(), "(should be close to log₂(7) ≈ 2.8 for balanced)\n")
+bst_sorted$print_tree()
+
+# Shuffled array (more balanced)
+shuffled_array <- c(4, 2, 6, 1, 3, 5, 7)
+bst_shuffled <- create_bst_from_array(shuffled_array)
+cat("BST from shuffled array [4,2,6,1,3,5,7]:\n")
+cat("Height:", bst_shuffled$height(), "\n")
+bst_shuffled$print_tree()
+
+# Test 8: kth smallest element
+cat("8. Finding kth Smallest Elements\n")
+for (k in 1:min(5, bst_shuffled$get_size())) {
+  kth_val <- kth_smallest(bst_shuffled, k)
+  cat(k, "smallest element:", kth_val, "\n")
+}
+cat("\n")
+
+# Test 9: Edge cases
+cat("9. Edge Cases\n")
+empty_bst <- BST$new()
+cat("Empty BST:\n")
+cat("Is empty:", empty_bst$is_empty(), "\n")
+cat("Size:", empty_bst$get_size(), "\n")
+cat("Height:", empty_bst$height(), "\n")
+cat("Min value:", empty_bst$find_min(), "\n")
+cat("Search for 5:", empty_bst$search(5), "\n")
+cat("Delete 5:", empty_bst$delete(5), "\n")
+
+# Single node BST
+single_bst <- BST$new()
+single_bst$insert(42)
+cat("\nSingle node BST:\n")
+cat("Size:", single_bst$get_size(), "\n")
+cat("Height:", single_bst$height(), "\n")
+cat("Min/Max:", single_bst$find_min(), "/", single_bst$find_max(), "\n")
+single_bst$print_tree()
+
+# Test 10: Real-world example - Student grades
+cat("\n10. Real-world Example - Student Grade Management\n")
+grade_bst <- BST$new()
+grades <- c(85, 92, 78, 96, 83, 88, 91, 79, 87, 94)
+
+cat("Student grades:", paste(grades, collapse = ", "), "\n")
+for (grade in grades) {
+  grade_bst$insert(grade)
+}
+
+cat("Grades in ascending order:", paste(grade_bst$inorder_traversal(), collapse = ", "), "\n")
+cat("Highest grade:", grade_bst$find_max(), "\n")
+cat("Lowest grade:", grade_bst$find_min(), "\n")
+cat("Median grade (middle element):", kth_smallest(grade_bst, ceiling(grade_bst$get_size()/2)), "\n")
+
+# Find students above certain grade
+threshold <- 90
+above_threshold <- grade_bst$inorder_traversal()
+above_threshold <- above_threshold[above_threshold >= threshold]
+cat("Grades >=", threshold, ":", paste(above_threshold, collapse = ", "), "\n")
+
+cat("\nGrade distribution tree:\n")
+grade_bst$print_tree()
\ No newline at end of file
diff --git a/Desktop/open-source/R/documentation/ann.html b/Desktop/open-source/R/documentation/ann.html
new file mode 100644
index 00000000..93d6e584
--- /dev/null
+++ b/Desktop/open-source/R/documentation/ann.html
@@ -0,0 +1,170 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(neuralnet)
+</code></pre>
+<pre><code>## Error in library(neuralnet): there is no package called 'neuralnet'
+</code></pre>
+<pre><code class="language-r">concrete&lt;-read.csv(file = &quot;concrete.txt&quot;,stringsAsFactors = F)#get the data
+</code></pre>
+<pre><code>## Warning in file(file, &quot;rt&quot;): cannot open file 'concrete.txt': No such file or
+## directory
+</code></pre>
+<pre><code>## Error in file(file, &quot;rt&quot;): cannot open the connection
+</code></pre>
+<pre><code class="language-r">normalize&lt;-function(x){
+  return((x-min(x))/(max(x)-min(x)))
+}
+concrete&lt;-as.data.frame(lapply(concrete, normalize))
+</code></pre>
+<pre><code>## Error in lapply(concrete, normalize): object 'concrete' not found
+</code></pre>
+<pre><code class="language-r">concrete_train&lt;-concrete[1:773,]
+</code></pre>
+<pre><code>## Error: object 'concrete' not found
+</code></pre>
+<pre><code class="language-r">concrete_test&lt;-concrete[774:1030,]
+</code></pre>
+<pre><code>## Error: object 'concrete' not found
+</code></pre>
+<pre><code class="language-r">concrete_model&lt;-neuralnet(strength~cement+slag+ash+water+superplastic+coarseagg+fineagg+age,data = concrete_train,hidden = 5)
+</code></pre>
+<pre><code>## Error in neuralnet(strength ~ cement + slag + ash + water + superplastic + : could not find function &quot;neuralnet&quot;
+</code></pre>
+<pre><code class="language-r">model_res&lt;-compute(concrete_model,concrete_test[,1:8])
+</code></pre>
+<pre><code>## Error in compute(concrete_model, concrete_test[, 1:8]): could not find function &quot;compute&quot;
+</code></pre>
+<pre><code class="language-r">x=model_res$net.result
+</code></pre>
+<pre><code>## Error: object 'model_res' not found
+</code></pre>
+<pre><code class="language-r">y=concrete_test$strength
+</code></pre>
+<pre><code>## Error: object 'concrete_test' not found
+</code></pre>
+<pre><code class="language-r">cor(x,y)
+</code></pre>
+<pre><code>## Error in is.data.frame(y): object 'y' not found
+</code></pre>
+<pre><code class="language-r">plot(concrete_model)
+</code></pre>
+<pre><code>## Error in plot(concrete_model): object 'concrete_model' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/ann.md b/Desktop/open-source/R/documentation/ann.md
new file mode 100644
index 00000000..4b578d47
--- /dev/null
+++ b/Desktop/open-source/R/documentation/ann.md
@@ -0,0 +1,98 @@
+
+
+``` r
+library(neuralnet)
+```
+
+```
+## Error in library(neuralnet): there is no package called 'neuralnet'
+```
+
+``` r
+concrete<-read.csv(file = "concrete.txt",stringsAsFactors = F)#get the data
+```
+
+```
+## Warning in file(file, "rt"): cannot open file 'concrete.txt': No such file or
+## directory
+```
+
+```
+## Error in file(file, "rt"): cannot open the connection
+```
+
+``` r
+normalize<-function(x){
+  return((x-min(x))/(max(x)-min(x)))
+}
+concrete<-as.data.frame(lapply(concrete, normalize))
+```
+
+```
+## Error in lapply(concrete, normalize): object 'concrete' not found
+```
+
+``` r
+concrete_train<-concrete[1:773,]
+```
+
+```
+## Error: object 'concrete' not found
+```
+
+``` r
+concrete_test<-concrete[774:1030,]
+```
+
+```
+## Error: object 'concrete' not found
+```
+
+``` r
+concrete_model<-neuralnet(strength~cement+slag+ash+water+superplastic+coarseagg+fineagg+age,data = concrete_train,hidden = 5)
+```
+
+```
+## Error in neuralnet(strength ~ cement + slag + ash + water + superplastic + : could not find function "neuralnet"
+```
+
+``` r
+model_res<-compute(concrete_model,concrete_test[,1:8])
+```
+
+```
+## Error in compute(concrete_model, concrete_test[, 1:8]): could not find function "compute"
+```
+
+``` r
+x=model_res$net.result
+```
+
+```
+## Error: object 'model_res' not found
+```
+
+``` r
+y=concrete_test$strength
+```
+
+```
+## Error: object 'concrete_test' not found
+```
+
+``` r
+cor(x,y)
+```
+
+```
+## Error in is.data.frame(y): object 'y' not found
+```
+
+``` r
+plot(concrete_model)
+```
+
+```
+## Error in plot(concrete_model): object 'concrete_model' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/apriori.html b/Desktop/open-source/R/documentation/apriori.html
new file mode 100644
index 00000000..e2489b12
--- /dev/null
+++ b/Desktop/open-source/R/documentation/apriori.html
@@ -0,0 +1,153 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(arules)
+</code></pre>
+<pre><code>## Error in library(arules): there is no package called 'arules'
+</code></pre>
+<pre><code class="language-r">groceries &lt;- read.transactions(&quot;groceries.csv&quot;, sep=&quot;,&quot;)
+</code></pre>
+<pre><code>## Error in read.transactions(&quot;groceries.csv&quot;, sep = &quot;,&quot;): could not find function &quot;read.transactions&quot;
+</code></pre>
+<pre><code class="language-r">summary(groceries)
+</code></pre>
+<pre><code>## Error in summary(groceries): object 'groceries' not found
+</code></pre>
+<pre><code class="language-r">itemFrequencyPlot(groceries, topN=20)
+</code></pre>
+<pre><code>## Error in itemFrequencyPlot(groceries, topN = 20): could not find function &quot;itemFrequencyPlot&quot;
+</code></pre>
+<pre><code class="language-r">#sample for randomly extracting samples, image function for visualing sparse matrix
+image(sample(groceries,100))
+</code></pre>
+<pre><code>## Error in sample(groceries, 100): object 'groceries' not found
+</code></pre>
+<pre><code class="language-r">groceries_rule &lt;- apriori(data=groceries, parameter=list(support=0.006, confidence=0.25, minlen=2))
+</code></pre>
+<pre><code>## Error in apriori(data = groceries, parameter = list(support = 0.006, confidence = 0.25, : could not find function &quot;apriori&quot;
+</code></pre>
+<pre><code class="language-r">plotly_arules(groceries_rule)
+</code></pre>
+<pre><code>## Error in plotly_arules(groceries_rule): could not find function &quot;plotly_arules&quot;
+</code></pre>
+<pre><code class="language-r">summary(groceries_rule)
+</code></pre>
+<pre><code>## Error in summary(groceries_rule): object 'groceries_rule' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/apriori.md b/Desktop/open-source/R/documentation/apriori.md
new file mode 100644
index 00000000..e595594f
--- /dev/null
+++ b/Desktop/open-source/R/documentation/apriori.md
@@ -0,0 +1,67 @@
+
+
+``` r
+library(arules)
+```
+
+```
+## Error in library(arules): there is no package called 'arules'
+```
+
+``` r
+groceries <- read.transactions("groceries.csv", sep=",")
+```
+
+```
+## Error in read.transactions("groceries.csv", sep = ","): could not find function "read.transactions"
+```
+
+``` r
+summary(groceries)
+```
+
+```
+## Error in summary(groceries): object 'groceries' not found
+```
+
+``` r
+itemFrequencyPlot(groceries, topN=20)
+```
+
+```
+## Error in itemFrequencyPlot(groceries, topN = 20): could not find function "itemFrequencyPlot"
+```
+
+``` r
+#sample for randomly extracting samples, image function for visualing sparse matrix
+image(sample(groceries,100))
+```
+
+```
+## Error in sample(groceries, 100): object 'groceries' not found
+```
+
+``` r
+groceries_rule <- apriori(data=groceries, parameter=list(support=0.006, confidence=0.25, minlen=2))
+```
+
+```
+## Error in apriori(data = groceries, parameter = list(support = 0.006, confidence = 0.25, : could not find function "apriori"
+```
+
+``` r
+plotly_arules(groceries_rule)
+```
+
+```
+## Error in plotly_arules(groceries_rule): could not find function "plotly_arules"
+```
+
+``` r
+summary(groceries_rule)
+```
+
+```
+## Error in summary(groceries_rule): object 'groceries_rule' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/binary_search.html b/Desktop/open-source/R/documentation/binary_search.html
new file mode 100644
index 00000000..62834b3a
--- /dev/null
+++ b/Desktop/open-source/R/documentation/binary_search.html
@@ -0,0 +1,151 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">binary_search &lt;- function(arr, target) { #function for finding position of value 
+  low &lt;- 1
+  high &lt;- length(arr) 
+  
+  while (low &lt;= high) {
+    mid &lt;- low + (high - low) %/% 2 #finding mid of array
+    
+    if (arr[mid] == target) { #comapring the mis value with the value to search
+      return(mid)  # Target found, return its index
+    } else if (arr[mid] &lt; target) {
+      low &lt;- mid + 1  # Search in the right half
+    } else {
+      high &lt;- mid - 1  # Search in the left half
+    }
+  }
+  return(-1)  # Target not found in the array
+}
+
+arr &lt;- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) #input array (hard code)
+target &lt;- 7 #input value to be searched (hard code)
+
+result &lt;- binary_search(arr, target) #binary_seach function calling
+
+if (result == -1) {
+  cat(&quot;Element&quot;, target, &quot;not found in the array.\n&quot;)
+} else {
+  cat(&quot;Element&quot;, target, &quot;found at position&quot;, result, &quot;.\n&quot;)
+}
+</code></pre>
+<pre><code>## Element 7 found at position 7 .
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/binary_search.md b/Desktop/open-source/R/documentation/binary_search.md
new file mode 100644
index 00000000..3b34a8e5
--- /dev/null
+++ b/Desktop/open-source/R/documentation/binary_search.md
@@ -0,0 +1,37 @@
+
+
+``` r
+binary_search <- function(arr, target) { #function for finding position of value 
+  low <- 1
+  high <- length(arr) 
+  
+  while (low <= high) {
+    mid <- low + (high - low) %/% 2 #finding mid of array
+    
+    if (arr[mid] == target) { #comapring the mis value with the value to search
+      return(mid)  # Target found, return its index
+    } else if (arr[mid] < target) {
+      low <- mid + 1  # Search in the right half
+    } else {
+      high <- mid - 1  # Search in the left half
+    }
+  }
+  return(-1)  # Target not found in the array
+}
+
+arr <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) #input array (hard code)
+target <- 7 #input value to be searched (hard code)
+
+result <- binary_search(arr, target) #binary_seach function calling
+
+if (result == -1) {
+  cat("Element", target, "not found in the array.\n")
+} else {
+  cat("Element", target, "found at position", result, ".\n")
+}
+```
+
+```
+## Element 7 found at position 7 .
+```
+
diff --git a/Desktop/open-source/R/documentation/binary_search_tree.html b/Desktop/open-source/R/documentation/binary_search_tree.html
new file mode 100644
index 00000000..25464924
--- /dev/null
+++ b/Desktop/open-source/R/documentation/binary_search_tree.html
@@ -0,0 +1,819 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Binary Search Tree (BST) Implementation
+#
+# A Binary Search Tree is a hierarchical data structure where each node has at most
+# two children (left and right), and for every node:
+# - All values in the left subtree are less than the node's value
+# - All values in the right subtree are greater than the node's value
+# - Both subtrees are also binary search trees
+#
+# Time Complexities (average case):
+# - Search: O(log n)  
+# - Insert: O(log n)
+# - Delete: O(log n)
+# - Traversal: O(n)
+#
+# Worst case: O(n) when tree becomes skewed (like a linked list)
+#
+# Applications:
+# - Database indexing
+# - Expression parsing
+# - Priority queues
+# - File system organization
+
+# Define BST Node structure using R6 class system
+if (!require(R6, quietly = TRUE)) {
+  cat(&quot;Installing R6 package for object-oriented programming...\n&quot;)
+  install.packages(&quot;R6&quot;, quiet = TRUE)
+  library(R6)
+}
+</code></pre>
+<pre><code>## Warning in library(package, lib.loc = lib.loc, character.only = TRUE,
+## logical.return = TRUE, : there is no package called 'R6'
+</code></pre>
+<pre><code>## Installing R6 package for object-oriented programming...
+</code></pre>
+<pre><code class="language-r"># BST Node class
+BSTNode &lt;- R6Class(&quot;BSTNode&quot;,
+  public = list(
+    value = NULL,
+    left = NULL,
+    right = NULL,
+    
+    initialize = function(value) {
+      self$value &lt;- value
+      self$left &lt;- NULL
+      self$right &lt;- NULL
+    }
+  )
+)
+
+# Binary Search Tree class
+BST &lt;- R6Class(&quot;BST&quot;,
+  public = list(
+    root = NULL,
+    size = 0,
+    
+    initialize = function() {
+      self$root &lt;- NULL
+      self$size &lt;- 0
+    },
+    
+    # Insert a value into the BST
+    insert = function(value) {
+      if (is.null(self$root)) {
+        self$root &lt;- BSTNode$new(value)
+        self$size &lt;- self$size + 1
+      } else {
+        private$insert_recursive(self$root, value)
+      }
+    },
+    
+    # Search for a value in the BST
+    search = function(value) {
+      return(private$search_recursive(self$root, value))
+    },
+    
+    # Delete a value from the BST
+    delete = function(value) {
+      if (self$search(value)) {
+        self$root &lt;- private$delete_recursive(self$root, value)
+        self$size &lt;- self$size - 1
+        return(TRUE)
+      }
+      return(FALSE)
+    },
+    
+    # Find minimum value in the BST
+    find_min = function() {
+      if (is.null(self$root)) return(NULL)
+      return(private$find_min_recursive(self$root)$value)
+    },
+    
+    # Find maximum value in the BST  
+    find_max = function() {
+      if (is.null(self$root)) return(NULL)
+      return(private$find_max_recursive(self$root)$value)
+    },
+    
+    # In-order traversal (left, root, right) - gives sorted output
+    inorder_traversal = function() {
+      result &lt;- c()
+      private$inorder_recursive(self$root, result)
+      return(result)
+    },
+    
+    # Pre-order traversal (root, left, right)
+    preorder_traversal = function() {
+      result &lt;- c()
+      private$preorder_recursive(self$root, result)
+      return(result)
+    },
+    
+    # Post-order traversal (left, right, root)
+    postorder_traversal = function() {
+      result &lt;- c()
+      private$postorder_recursive(self$root, result)
+      return(result)
+    },
+    
+    # Level-order traversal (breadth-first)
+    level_order_traversal = function() {
+      if (is.null(self$root)) return(c())
+      
+      result &lt;- c()
+      queue &lt;- list(self$root)
+      
+      while (length(queue) &gt; 0) {
+        node &lt;- queue[[1]]
+        queue &lt;- queue[-1]
+        
+        result &lt;- c(result, node$value)
+        
+        if (!is.null(node$left)) {
+          queue &lt;- append(queue, list(node$left))
+        }
+        if (!is.null(node$right)) {
+          queue &lt;- append(queue, list(node$right))
+        }
+      }
+      
+      return(result)
+    },
+    
+    # Get height of the tree
+    height = function() {
+      return(private$height_recursive(self$root))
+    },
+    
+    # Check if tree is valid BST
+    is_valid_bst = function() {
+      return(private$is_valid_bst_recursive(self$root, -Inf, Inf))
+    },
+    
+    # Get size of the tree
+    get_size = function() {
+      return(self$size)
+    },
+    
+    # Check if tree is empty
+    is_empty = function() {
+      return(is.null(self$root))
+    },
+    
+    # Print tree structure
+    print_tree = function() {
+      if (is.null(self$root)) {
+        cat(&quot;Empty tree\n&quot;)
+        return()
+      }
+      private$print_tree_recursive(self$root, &quot;&quot;, TRUE)
+    }
+  ),
+  
+  private = list(
+    # Recursive helper for insertion
+    insert_recursive = function(node, value) {
+      if (value &lt; node$value) {
+        if (is.null(node$left)) {
+          node$left &lt;- BSTNode$new(value)
+          self$size &lt;- self$size + 1
+        } else {
+          private$insert_recursive(node$left, value)
+        }
+      } else if (value &gt; node$value) {
+        if (is.null(node$right)) {
+          node$right &lt;- BSTNode$new(value)
+          self$size &lt;- self$size + 1
+        } else {
+          private$insert_recursive(node$right, value)
+        }
+      }
+      # If value == node$value, don't insert (no duplicates)
+    },
+    
+    # Recursive helper for search
+    search_recursive = function(node, value) {
+      if (is.null(node) || node$value == value) {
+        return(!is.null(node))
+      }
+      
+      if (value &lt; node$value) {
+        return(private$search_recursive(node$left, value))
+      } else {
+        return(private$search_recursive(node$right, value))
+      }
+    },
+    
+    # Recursive helper for deletion
+    delete_recursive = function(node, value) {
+      if (is.null(node)) {
+        return(NULL)
+      }
+      
+      if (value &lt; node$value) {
+        node$left &lt;- private$delete_recursive(node$left, value)
+      } else if (value &gt; node$value) {
+        node$right &lt;- private$delete_recursive(node$right, value)
+      } else {
+        # Node to delete found
+        if (is.null(node$left)) {
+          return(node$right)
+        } else if (is.null(node$right)) {
+          return(node$left)
+        }
+        
+        # Node has two children - find inorder successor
+        successor &lt;- private$find_min_recursive(node$right)
+        node$value &lt;- successor$value
+        node$right &lt;- private$delete_recursive(node$right, successor$value)
+      }
+      
+      return(node)
+    },
+    
+    # Find minimum node
+    find_min_recursive = function(node) {
+      while (!is.null(node$left)) {
+        node &lt;- node$left
+      }
+      return(node)
+    },
+    
+    # Find maximum node
+    find_max_recursive = function(node) {
+      while (!is.null(node$right)) {
+        node &lt;- node$right
+      }
+      return(node)
+    },
+    
+    # In-order traversal helper
+    inorder_recursive = function(node, result) {
+      if (!is.null(node)) {
+        result &lt;&lt;- private$inorder_recursive(node$left, result)
+        result &lt;&lt;- c(result, node$value)
+        result &lt;&lt;- private$inorder_recursive(node$right, result)
+      }
+      return(result)
+    },
+    
+    # Pre-order traversal helper
+    preorder_recursive = function(node, result) {
+      if (!is.null(node)) {
+        result &lt;&lt;- c(result, node$value)
+        result &lt;&lt;- private$preorder_recursive(node$left, result)
+        result &lt;&lt;- private$preorder_recursive(node$right, result)
+      }
+      return(result)
+    },
+    
+    # Post-order traversal helper
+    postorder_recursive = function(node, result) {
+      if (!is.null(node)) {
+        result &lt;&lt;- private$postorder_recursive(node$left, result)
+        result &lt;&lt;- private$postorder_recursive(node$right, result)
+        result &lt;&lt;- c(result, node$value)
+      }
+      return(result)
+    },
+    
+    # Height calculation helper
+    height_recursive = function(node) {
+      if (is.null(node)) {
+        return(-1)  # Height of empty tree is -1
+      }
+      
+      left_height &lt;- private$height_recursive(node$left)
+      right_height &lt;- private$height_recursive(node$right)
+      
+      return(1 + max(left_height, right_height))
+    },
+    
+    # BST validation helper
+    is_valid_bst_recursive = function(node, min_val, max_val) {
+      if (is.null(node)) {
+        return(TRUE)
+      }
+      
+      if (node$value &lt;= min_val || node$value &gt;= max_val) {
+        return(FALSE)
+      }
+      
+      return(private$is_valid_bst_recursive(node$left, min_val, node$value) &amp;&amp;
+             private$is_valid_bst_recursive(node$right, node$value, max_val))
+    },
+    
+    # Tree printing helper
+    print_tree_recursive = function(node, prefix, is_last) {
+      if (!is.null(node)) {
+        cat(prefix)
+        cat(if (is_last) &quot;└── &quot; else &quot;├── &quot;)
+        cat(node$value, &quot;\n&quot;)
+        
+        new_prefix &lt;- paste0(prefix, if (is_last) &quot;    &quot; else &quot;│   &quot;)
+        
+        if (!is.null(node$left) || !is.null(node$right)) {
+          if (!is.null(node$left)) {
+            private$print_tree_recursive(node$left, new_prefix, is.null(node$right))
+          }
+          if (!is.null(node$right)) {
+            private$print_tree_recursive(node$right, new_prefix, TRUE)
+          }
+        }
+      }
+    }
+  )
+)
+
+# Utility functions for BST operations
+
+# Create BST from array
+create_bst_from_array &lt;- function(arr) {
+  #' Create a BST from an array of values
+  #' @param arr: Array of values to insert
+  #' @return: BST object
+  
+  bst &lt;- BST$new()
+  for (value in arr) {
+    bst$insert(value)
+  }
+  return(bst)
+}
+
+# Check if two BSTs are identical
+are_identical_bsts &lt;- function(bst1, bst2) {
+  #' Check if two BSTs have identical structure and values
+  #' @param bst1: First BST
+  #' @param bst2: Second BST
+  #' @return: TRUE if identical, FALSE otherwise
+  
+  traversal1 &lt;- bst1$preorder_traversal()
+  traversal2 &lt;- bst2$preorder_traversal()
+  
+  return(identical(traversal1, traversal2))
+}
+
+# Find kth smallest element in BST
+kth_smallest &lt;- function(bst, k) {
+  #' Find the kth smallest element in BST
+  #' @param bst: BST object
+  #' @param k: Position (1-indexed)
+  #' @return: kth smallest value or NULL if k is out of bounds
+  
+  inorder &lt;- bst$inorder_traversal()
+  if (k &gt; 0 &amp;&amp; k &lt;= length(inorder)) {
+    return(inorder[k])
+  }
+  return(NULL)
+}
+
+# Example usage and testing
+cat(&quot;=== Binary Search Tree (BST) Implementation ===\n\n&quot;)
+</code></pre>
+<pre><code>## === Binary Search Tree (BST) Implementation ===
+</code></pre>
+<pre><code class="language-r"># Test 1: Basic BST operations
+cat(&quot;1. Basic BST Operations\n&quot;)
+</code></pre>
+<pre><code>## 1. Basic BST Operations
+</code></pre>
+<pre><code class="language-r">bst &lt;- BST$new()
+
+# Insert values
+values &lt;- c(50, 30, 70, 20, 40, 60, 80)
+cat(&quot;Inserting values:&quot;, paste(values, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Inserting values: 50, 30, 70, 20, 40, 60, 80
+</code></pre>
+<pre><code class="language-r">for (value in values) {
+  bst$insert(value)
+}
+
+cat(&quot;Tree size:&quot;, bst$get_size(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Tree size: 7
+</code></pre>
+<pre><code class="language-r">cat(&quot;Tree height:&quot;, bst$height(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Tree height: 2
+</code></pre>
+<pre><code class="language-r">cat(&quot;Is valid BST:&quot;, bst$is_valid_bst(), &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Is valid BST: TRUE
+</code></pre>
+<pre><code class="language-r"># Test 2: Tree visualization
+cat(&quot;2. Tree Structure\n&quot;)
+</code></pre>
+<pre><code>## 2. Tree Structure
+</code></pre>
+<pre><code class="language-r">bst$print_tree()
+</code></pre>
+<pre><code>## └── 50 
+##     ├── 30 
+##     │   ├── 20 
+##     │   └── 40 
+##     └── 70 
+##         ├── 60 
+##         └── 80
+</code></pre>
+<pre><code class="language-r">cat(&quot;\n&quot;)
+</code></pre>
+<pre><code class="language-r"># Test 3: Search operations
+cat(&quot;3. Search Operations\n&quot;)
+</code></pre>
+<pre><code>## 3. Search Operations
+</code></pre>
+<pre><code class="language-r">search_values &lt;- c(40, 25, 80, 100)
+for (value in search_values) {
+  found &lt;- bst$search(value)
+  cat(&quot;Search for&quot;, value, &quot;:&quot;, if (found) &quot;Found&quot; else &quot;Not found&quot;, &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>## Search for 40 : Found 
+## Search for 25 : Not found 
+## Search for 80 : Found 
+## Search for 100 : Not found
+</code></pre>
+<pre><code class="language-r">cat(&quot;\n&quot;)
+</code></pre>
+<pre><code class="language-r"># Test 4: Min/Max operations
+cat(&quot;4. Min/Max Operations\n&quot;)
+</code></pre>
+<pre><code>## 4. Min/Max Operations
+</code></pre>
+<pre><code class="language-r">cat(&quot;Minimum value:&quot;, bst$find_min(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Minimum value: 20
+</code></pre>
+<pre><code class="language-r">cat(&quot;Maximum value:&quot;, bst$find_max(), &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Maximum value: 80
+</code></pre>
+<pre><code class="language-r"># Test 5: Tree traversals
+cat(&quot;5. Tree Traversals\n&quot;)
+</code></pre>
+<pre><code>## 5. Tree Traversals
+</code></pre>
+<pre><code class="language-r">cat(&quot;In-order (sorted):   &quot;, paste(bst$inorder_traversal(), collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## In-order (sorted):
+</code></pre>
+<pre><code class="language-r">cat(&quot;Pre-order:           &quot;, paste(bst$preorder_traversal(), collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Pre-order:
+</code></pre>
+<pre><code class="language-r">cat(&quot;Post-order:          &quot;, paste(bst$postorder_traversal(), collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Post-order:
+</code></pre>
+<pre><code class="language-r">cat(&quot;Level-order (BFS):   &quot;, paste(bst$level_order_traversal(), collapse = &quot;, &quot;), &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Level-order (BFS):    50, 30, 70, 20, 40, 60, 80
+</code></pre>
+<pre><code class="language-r"># Test 6: Deletion operations
+cat(&quot;6. Deletion Operations\n&quot;)
+</code></pre>
+<pre><code>## 6. Deletion Operations
+</code></pre>
+<pre><code class="language-r">delete_values &lt;- c(20, 30, 50)  # Delete leaf, node with one child, root
+
+for (value in delete_values) {
+  cat(&quot;Deleting&quot;, value, &quot;:&quot;, if (bst$delete(value)) &quot;Success&quot; else &quot;Failed&quot;, &quot;\n&quot;)
+  cat(&quot;Tree after deletion:\n&quot;)
+  bst$print_tree()
+  cat(&quot;In-order traversal:&quot;, paste(bst$inorder_traversal(), collapse = &quot;, &quot;), &quot;\n&quot;)
+  cat(&quot;Tree size:&quot;, bst$get_size(), &quot;\n\n&quot;)
+}
+</code></pre>
+<pre><code>## Deleting 20 : Success 
+## Tree after deletion:
+## └── 50 
+##     ├── 30 
+##     │   └── 40 
+##     └── 70 
+##         ├── 60 
+##         └── 80 
+## In-order traversal:  
+## Tree size: 6 
+## 
+## Deleting 30 : Success 
+## Tree after deletion:
+## └── 50 
+##     ├── 40 
+##     └── 70 
+##         ├── 60 
+##         └── 80 
+## In-order traversal:  
+## Tree size: 5 
+## 
+## Deleting 50 : Success 
+## Tree after deletion:
+## └── 60 
+##     ├── 40 
+##     └── 70 
+##         └── 80 
+## In-order traversal:  
+## Tree size: 4
+</code></pre>
+<pre><code class="language-r"># Test 7: Create BST from sorted vs unsorted array
+cat(&quot;7. BST Creation Comparison\n&quot;)
+</code></pre>
+<pre><code>## 7. BST Creation Comparison
+</code></pre>
+<pre><code class="language-r"># Sorted array (creates skewed tree)
+sorted_array &lt;- c(1, 2, 3, 4, 5, 6, 7)
+bst_sorted &lt;- create_bst_from_array(sorted_array)
+cat(&quot;BST from sorted array [1,2,3,4,5,6,7]:\n&quot;)
+</code></pre>
+<pre><code>## BST from sorted array [1,2,3,4,5,6,7]:
+</code></pre>
+<pre><code class="language-r">cat(&quot;Height:&quot;, bst_sorted$height(), &quot;(should be close to log₂(7) ≈ 2.8 for balanced)\n&quot;)
+</code></pre>
+<pre><code>## Height: 6 (should be close to log₂(7) ≈ 2.8 for balanced)
+</code></pre>
+<pre><code class="language-r">bst_sorted$print_tree()
+</code></pre>
+<pre><code>## └── 1 
+##     └── 2 
+##         └── 3 
+##             └── 4 
+##                 └── 5 
+##                     └── 6 
+##                         └── 7
+</code></pre>
+<pre><code class="language-r"># Shuffled array (more balanced)
+shuffled_array &lt;- c(4, 2, 6, 1, 3, 5, 7)
+bst_shuffled &lt;- create_bst_from_array(shuffled_array)
+cat(&quot;BST from shuffled array [4,2,6,1,3,5,7]:\n&quot;)
+</code></pre>
+<pre><code>## BST from shuffled array [4,2,6,1,3,5,7]:
+</code></pre>
+<pre><code class="language-r">cat(&quot;Height:&quot;, bst_shuffled$height(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Height: 2
+</code></pre>
+<pre><code class="language-r">bst_shuffled$print_tree()
+</code></pre>
+<pre><code>## └── 4 
+##     ├── 2 
+##     │   ├── 1 
+##     │   └── 3 
+##     └── 6 
+##         ├── 5 
+##         └── 7
+</code></pre>
+<pre><code class="language-r"># Test 8: kth smallest element
+cat(&quot;8. Finding kth Smallest Elements\n&quot;)
+</code></pre>
+<pre><code>## 8. Finding kth Smallest Elements
+</code></pre>
+<pre><code class="language-r">for (k in 1:min(5, bst_shuffled$get_size())) {
+  kth_val &lt;- kth_smallest(bst_shuffled, k)
+  cat(k, &quot;smallest element:&quot;, kth_val, &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>## 1 smallest element: 
+## 2 smallest element: 
+## 3 smallest element: 
+## 4 smallest element: 
+## 5 smallest element:
+</code></pre>
+<pre><code class="language-r">cat(&quot;\n&quot;)
+</code></pre>
+<pre><code class="language-r"># Test 9: Edge cases
+cat(&quot;9. Edge Cases\n&quot;)
+</code></pre>
+<pre><code>## 9. Edge Cases
+</code></pre>
+<pre><code class="language-r">empty_bst &lt;- BST$new()
+cat(&quot;Empty BST:\n&quot;)
+</code></pre>
+<pre><code>## Empty BST:
+</code></pre>
+<pre><code class="language-r">cat(&quot;Is empty:&quot;, empty_bst$is_empty(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Is empty: TRUE
+</code></pre>
+<pre><code class="language-r">cat(&quot;Size:&quot;, empty_bst$get_size(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Size: 0
+</code></pre>
+<pre><code class="language-r">cat(&quot;Height:&quot;, empty_bst$height(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Height: -1
+</code></pre>
+<pre><code class="language-r">cat(&quot;Min value:&quot;, empty_bst$find_min(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Min value:
+</code></pre>
+<pre><code class="language-r">cat(&quot;Search for 5:&quot;, empty_bst$search(5), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Search for 5: FALSE
+</code></pre>
+<pre><code class="language-r">cat(&quot;Delete 5:&quot;, empty_bst$delete(5), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Delete 5: FALSE
+</code></pre>
+<pre><code class="language-r"># Single node BST
+single_bst &lt;- BST$new()
+single_bst$insert(42)
+cat(&quot;\nSingle node BST:\n&quot;)
+</code></pre>
+<pre><code>## 
+## Single node BST:
+</code></pre>
+<pre><code class="language-r">cat(&quot;Size:&quot;, single_bst$get_size(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Size: 1
+</code></pre>
+<pre><code class="language-r">cat(&quot;Height:&quot;, single_bst$height(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Height: 0
+</code></pre>
+<pre><code class="language-r">cat(&quot;Min/Max:&quot;, single_bst$find_min(), &quot;/&quot;, single_bst$find_max(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Min/Max: 42 / 42
+</code></pre>
+<pre><code class="language-r">single_bst$print_tree()
+</code></pre>
+<pre><code>## └── 42
+</code></pre>
+<pre><code class="language-r"># Test 10: Real-world example - Student grades
+cat(&quot;\n10. Real-world Example - Student Grade Management\n&quot;)
+</code></pre>
+<pre><code>## 
+## 10. Real-world Example - Student Grade Management
+</code></pre>
+<pre><code class="language-r">grade_bst &lt;- BST$new()
+grades &lt;- c(85, 92, 78, 96, 83, 88, 91, 79, 87, 94)
+
+cat(&quot;Student grades:&quot;, paste(grades, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Student grades: 85, 92, 78, 96, 83, 88, 91, 79, 87, 94
+</code></pre>
+<pre><code class="language-r">for (grade in grades) {
+  grade_bst$insert(grade)
+}
+
+cat(&quot;Grades in ascending order:&quot;, paste(grade_bst$inorder_traversal(), collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Grades in ascending order:
+</code></pre>
+<pre><code class="language-r">cat(&quot;Highest grade:&quot;, grade_bst$find_max(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Highest grade: 96
+</code></pre>
+<pre><code class="language-r">cat(&quot;Lowest grade:&quot;, grade_bst$find_min(), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Lowest grade: 78
+</code></pre>
+<pre><code class="language-r">cat(&quot;Median grade (middle element):&quot;, kth_smallest(grade_bst, ceiling(grade_bst$get_size()/2)), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Median grade (middle element):
+</code></pre>
+<pre><code class="language-r"># Find students above certain grade
+threshold &lt;- 90
+above_threshold &lt;- grade_bst$inorder_traversal()
+above_threshold &lt;- above_threshold[above_threshold &gt;= threshold]
+cat(&quot;Grades &gt;=&quot;, threshold, &quot;:&quot;, paste(above_threshold, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Grades &gt;= 90 :
+</code></pre>
+<pre><code class="language-r">cat(&quot;\nGrade distribution tree:\n&quot;)
+</code></pre>
+<pre><code>## 
+## Grade distribution tree:
+</code></pre>
+<pre><code class="language-r">grade_bst$print_tree()
+</code></pre>
+<pre><code>## └── 85 
+##     ├── 78 
+##     │   └── 83 
+##     │       └── 79 
+##     └── 92 
+##         ├── 88 
+##         │   ├── 87 
+##         │   └── 91 
+##         └── 96 
+##             └── 94
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/binary_search_tree.md b/Desktop/open-source/R/documentation/binary_search_tree.md
new file mode 100644
index 00000000..38413f75
--- /dev/null
+++ b/Desktop/open-source/R/documentation/binary_search_tree.md
@@ -0,0 +1,917 @@
+
+
+``` r
+# Binary Search Tree (BST) Implementation
+#
+# A Binary Search Tree is a hierarchical data structure where each node has at most
+# two children (left and right), and for every node:
+# - All values in the left subtree are less than the node's value
+# - All values in the right subtree are greater than the node's value
+# - Both subtrees are also binary search trees
+#
+# Time Complexities (average case):
+# - Search: O(log n)  
+# - Insert: O(log n)
+# - Delete: O(log n)
+# - Traversal: O(n)
+#
+# Worst case: O(n) when tree becomes skewed (like a linked list)
+#
+# Applications:
+# - Database indexing
+# - Expression parsing
+# - Priority queues
+# - File system organization
+
+# Define BST Node structure using R6 class system
+if (!require(R6, quietly = TRUE)) {
+  cat("Installing R6 package for object-oriented programming...\n")
+  install.packages("R6", quiet = TRUE)
+  library(R6)
+}
+```
+
+```
+## Warning in library(package, lib.loc = lib.loc, character.only = TRUE,
+## logical.return = TRUE, : there is no package called 'R6'
+```
+
+```
+## Installing R6 package for object-oriented programming...
+```
+
+``` r
+# BST Node class
+BSTNode <- R6Class("BSTNode",
+  public = list(
+    value = NULL,
+    left = NULL,
+    right = NULL,
+    
+    initialize = function(value) {
+      self$value <- value
+      self$left <- NULL
+      self$right <- NULL
+    }
+  )
+)
+
+# Binary Search Tree class
+BST <- R6Class("BST",
+  public = list(
+    root = NULL,
+    size = 0,
+    
+    initialize = function() {
+      self$root <- NULL
+      self$size <- 0
+    },
+    
+    # Insert a value into the BST
+    insert = function(value) {
+      if (is.null(self$root)) {
+        self$root <- BSTNode$new(value)
+        self$size <- self$size + 1
+      } else {
+        private$insert_recursive(self$root, value)
+      }
+    },
+    
+    # Search for a value in the BST
+    search = function(value) {
+      return(private$search_recursive(self$root, value))
+    },
+    
+    # Delete a value from the BST
+    delete = function(value) {
+      if (self$search(value)) {
+        self$root <- private$delete_recursive(self$root, value)
+        self$size <- self$size - 1
+        return(TRUE)
+      }
+      return(FALSE)
+    },
+    
+    # Find minimum value in the BST
+    find_min = function() {
+      if (is.null(self$root)) return(NULL)
+      return(private$find_min_recursive(self$root)$value)
+    },
+    
+    # Find maximum value in the BST  
+    find_max = function() {
+      if (is.null(self$root)) return(NULL)
+      return(private$find_max_recursive(self$root)$value)
+    },
+    
+    # In-order traversal (left, root, right) - gives sorted output
+    inorder_traversal = function() {
+      result <- c()
+      private$inorder_recursive(self$root, result)
+      return(result)
+    },
+    
+    # Pre-order traversal (root, left, right)
+    preorder_traversal = function() {
+      result <- c()
+      private$preorder_recursive(self$root, result)
+      return(result)
+    },
+    
+    # Post-order traversal (left, right, root)
+    postorder_traversal = function() {
+      result <- c()
+      private$postorder_recursive(self$root, result)
+      return(result)
+    },
+    
+    # Level-order traversal (breadth-first)
+    level_order_traversal = function() {
+      if (is.null(self$root)) return(c())
+      
+      result <- c()
+      queue <- list(self$root)
+      
+      while (length(queue) > 0) {
+        node <- queue[[1]]
+        queue <- queue[-1]
+        
+        result <- c(result, node$value)
+        
+        if (!is.null(node$left)) {
+          queue <- append(queue, list(node$left))
+        }
+        if (!is.null(node$right)) {
+          queue <- append(queue, list(node$right))
+        }
+      }
+      
+      return(result)
+    },
+    
+    # Get height of the tree
+    height = function() {
+      return(private$height_recursive(self$root))
+    },
+    
+    # Check if tree is valid BST
+    is_valid_bst = function() {
+      return(private$is_valid_bst_recursive(self$root, -Inf, Inf))
+    },
+    
+    # Get size of the tree
+    get_size = function() {
+      return(self$size)
+    },
+    
+    # Check if tree is empty
+    is_empty = function() {
+      return(is.null(self$root))
+    },
+    
+    # Print tree structure
+    print_tree = function() {
+      if (is.null(self$root)) {
+        cat("Empty tree\n")
+        return()
+      }
+      private$print_tree_recursive(self$root, "", TRUE)
+    }
+  ),
+  
+  private = list(
+    # Recursive helper for insertion
+    insert_recursive = function(node, value) {
+      if (value < node$value) {
+        if (is.null(node$left)) {
+          node$left <- BSTNode$new(value)
+          self$size <- self$size + 1
+        } else {
+          private$insert_recursive(node$left, value)
+        }
+      } else if (value > node$value) {
+        if (is.null(node$right)) {
+          node$right <- BSTNode$new(value)
+          self$size <- self$size + 1
+        } else {
+          private$insert_recursive(node$right, value)
+        }
+      }
+      # If value == node$value, don't insert (no duplicates)
+    },
+    
+    # Recursive helper for search
+    search_recursive = function(node, value) {
+      if (is.null(node) || node$value == value) {
+        return(!is.null(node))
+      }
+      
+      if (value < node$value) {
+        return(private$search_recursive(node$left, value))
+      } else {
+        return(private$search_recursive(node$right, value))
+      }
+    },
+    
+    # Recursive helper for deletion
+    delete_recursive = function(node, value) {
+      if (is.null(node)) {
+        return(NULL)
+      }
+      
+      if (value < node$value) {
+        node$left <- private$delete_recursive(node$left, value)
+      } else if (value > node$value) {
+        node$right <- private$delete_recursive(node$right, value)
+      } else {
+        # Node to delete found
+        if (is.null(node$left)) {
+          return(node$right)
+        } else if (is.null(node$right)) {
+          return(node$left)
+        }
+        
+        # Node has two children - find inorder successor
+        successor <- private$find_min_recursive(node$right)
+        node$value <- successor$value
+        node$right <- private$delete_recursive(node$right, successor$value)
+      }
+      
+      return(node)
+    },
+    
+    # Find minimum node
+    find_min_recursive = function(node) {
+      while (!is.null(node$left)) {
+        node <- node$left
+      }
+      return(node)
+    },
+    
+    # Find maximum node
+    find_max_recursive = function(node) {
+      while (!is.null(node$right)) {
+        node <- node$right
+      }
+      return(node)
+    },
+    
+    # In-order traversal helper
+    inorder_recursive = function(node, result) {
+      if (!is.null(node)) {
+        result <<- private$inorder_recursive(node$left, result)
+        result <<- c(result, node$value)
+        result <<- private$inorder_recursive(node$right, result)
+      }
+      return(result)
+    },
+    
+    # Pre-order traversal helper
+    preorder_recursive = function(node, result) {
+      if (!is.null(node)) {
+        result <<- c(result, node$value)
+        result <<- private$preorder_recursive(node$left, result)
+        result <<- private$preorder_recursive(node$right, result)
+      }
+      return(result)
+    },
+    
+    # Post-order traversal helper
+    postorder_recursive = function(node, result) {
+      if (!is.null(node)) {
+        result <<- private$postorder_recursive(node$left, result)
+        result <<- private$postorder_recursive(node$right, result)
+        result <<- c(result, node$value)
+      }
+      return(result)
+    },
+    
+    # Height calculation helper
+    height_recursive = function(node) {
+      if (is.null(node)) {
+        return(-1)  # Height of empty tree is -1
+      }
+      
+      left_height <- private$height_recursive(node$left)
+      right_height <- private$height_recursive(node$right)
+      
+      return(1 + max(left_height, right_height))
+    },
+    
+    # BST validation helper
+    is_valid_bst_recursive = function(node, min_val, max_val) {
+      if (is.null(node)) {
+        return(TRUE)
+      }
+      
+      if (node$value <= min_val || node$value >= max_val) {
+        return(FALSE)
+      }
+      
+      return(private$is_valid_bst_recursive(node$left, min_val, node$value) &&
+             private$is_valid_bst_recursive(node$right, node$value, max_val))
+    },
+    
+    # Tree printing helper
+    print_tree_recursive = function(node, prefix, is_last) {
+      if (!is.null(node)) {
+        cat(prefix)
+        cat(if (is_last) "└── " else "├── ")
+        cat(node$value, "\n")
+        
+        new_prefix <- paste0(prefix, if (is_last) "    " else "│   ")
+        
+        if (!is.null(node$left) || !is.null(node$right)) {
+          if (!is.null(node$left)) {
+            private$print_tree_recursive(node$left, new_prefix, is.null(node$right))
+          }
+          if (!is.null(node$right)) {
+            private$print_tree_recursive(node$right, new_prefix, TRUE)
+          }
+        }
+      }
+    }
+  )
+)
+
+# Utility functions for BST operations
+
+# Create BST from array
+create_bst_from_array <- function(arr) {
+  #' Create a BST from an array of values
+  #' @param arr: Array of values to insert
+  #' @return: BST object
+  
+  bst <- BST$new()
+  for (value in arr) {
+    bst$insert(value)
+  }
+  return(bst)
+}
+
+# Check if two BSTs are identical
+are_identical_bsts <- function(bst1, bst2) {
+  #' Check if two BSTs have identical structure and values
+  #' @param bst1: First BST
+  #' @param bst2: Second BST
+  #' @return: TRUE if identical, FALSE otherwise
+  
+  traversal1 <- bst1$preorder_traversal()
+  traversal2 <- bst2$preorder_traversal()
+  
+  return(identical(traversal1, traversal2))
+}
+
+# Find kth smallest element in BST
+kth_smallest <- function(bst, k) {
+  #' Find the kth smallest element in BST
+  #' @param bst: BST object
+  #' @param k: Position (1-indexed)
+  #' @return: kth smallest value or NULL if k is out of bounds
+  
+  inorder <- bst$inorder_traversal()
+  if (k > 0 && k <= length(inorder)) {
+    return(inorder[k])
+  }
+  return(NULL)
+}
+
+# Example usage and testing
+cat("=== Binary Search Tree (BST) Implementation ===\n\n")
+```
+
+```
+## === Binary Search Tree (BST) Implementation ===
+```
+
+``` r
+# Test 1: Basic BST operations
+cat("1. Basic BST Operations\n")
+```
+
+```
+## 1. Basic BST Operations
+```
+
+``` r
+bst <- BST$new()
+
+# Insert values
+values <- c(50, 30, 70, 20, 40, 60, 80)
+cat("Inserting values:", paste(values, collapse = ", "), "\n")
+```
+
+```
+## Inserting values: 50, 30, 70, 20, 40, 60, 80
+```
+
+``` r
+for (value in values) {
+  bst$insert(value)
+}
+
+cat("Tree size:", bst$get_size(), "\n")
+```
+
+```
+## Tree size: 7
+```
+
+``` r
+cat("Tree height:", bst$height(), "\n")
+```
+
+```
+## Tree height: 2
+```
+
+``` r
+cat("Is valid BST:", bst$is_valid_bst(), "\n\n")
+```
+
+```
+## Is valid BST: TRUE
+```
+
+``` r
+# Test 2: Tree visualization
+cat("2. Tree Structure\n")
+```
+
+```
+## 2. Tree Structure
+```
+
+``` r
+bst$print_tree()
+```
+
+```
+## └── 50 
+##     ├── 30 
+##     │   ├── 20 
+##     │   └── 40 
+##     └── 70 
+##         ├── 60 
+##         └── 80
+```
+
+``` r
+cat("\n")
+```
+
+``` r
+# Test 3: Search operations
+cat("3. Search Operations\n")
+```
+
+```
+## 3. Search Operations
+```
+
+``` r
+search_values <- c(40, 25, 80, 100)
+for (value in search_values) {
+  found <- bst$search(value)
+  cat("Search for", value, ":", if (found) "Found" else "Not found", "\n")
+}
+```
+
+```
+## Search for 40 : Found 
+## Search for 25 : Not found 
+## Search for 80 : Found 
+## Search for 100 : Not found
+```
+
+``` r
+cat("\n")
+```
+
+``` r
+# Test 4: Min/Max operations
+cat("4. Min/Max Operations\n")
+```
+
+```
+## 4. Min/Max Operations
+```
+
+``` r
+cat("Minimum value:", bst$find_min(), "\n")
+```
+
+```
+## Minimum value: 20
+```
+
+``` r
+cat("Maximum value:", bst$find_max(), "\n\n")
+```
+
+```
+## Maximum value: 80
+```
+
+``` r
+# Test 5: Tree traversals
+cat("5. Tree Traversals\n")
+```
+
+```
+## 5. Tree Traversals
+```
+
+``` r
+cat("In-order (sorted):   ", paste(bst$inorder_traversal(), collapse = ", "), "\n")
+```
+
+```
+## In-order (sorted):
+```
+
+``` r
+cat("Pre-order:           ", paste(bst$preorder_traversal(), collapse = ", "), "\n")
+```
+
+```
+## Pre-order:
+```
+
+``` r
+cat("Post-order:          ", paste(bst$postorder_traversal(), collapse = ", "), "\n")
+```
+
+```
+## Post-order:
+```
+
+``` r
+cat("Level-order (BFS):   ", paste(bst$level_order_traversal(), collapse = ", "), "\n\n")
+```
+
+```
+## Level-order (BFS):    50, 30, 70, 20, 40, 60, 80
+```
+
+``` r
+# Test 6: Deletion operations
+cat("6. Deletion Operations\n")
+```
+
+```
+## 6. Deletion Operations
+```
+
+``` r
+delete_values <- c(20, 30, 50)  # Delete leaf, node with one child, root
+
+for (value in delete_values) {
+  cat("Deleting", value, ":", if (bst$delete(value)) "Success" else "Failed", "\n")
+  cat("Tree after deletion:\n")
+  bst$print_tree()
+  cat("In-order traversal:", paste(bst$inorder_traversal(), collapse = ", "), "\n")
+  cat("Tree size:", bst$get_size(), "\n\n")
+}
+```
+
+```
+## Deleting 20 : Success 
+## Tree after deletion:
+## └── 50 
+##     ├── 30 
+##     │   └── 40 
+##     └── 70 
+##         ├── 60 
+##         └── 80 
+## In-order traversal:  
+## Tree size: 6 
+## 
+## Deleting 30 : Success 
+## Tree after deletion:
+## └── 50 
+##     ├── 40 
+##     └── 70 
+##         ├── 60 
+##         └── 80 
+## In-order traversal:  
+## Tree size: 5 
+## 
+## Deleting 50 : Success 
+## Tree after deletion:
+## └── 60 
+##     ├── 40 
+##     └── 70 
+##         └── 80 
+## In-order traversal:  
+## Tree size: 4
+```
+
+``` r
+# Test 7: Create BST from sorted vs unsorted array
+cat("7. BST Creation Comparison\n")
+```
+
+```
+## 7. BST Creation Comparison
+```
+
+``` r
+# Sorted array (creates skewed tree)
+sorted_array <- c(1, 2, 3, 4, 5, 6, 7)
+bst_sorted <- create_bst_from_array(sorted_array)
+cat("BST from sorted array [1,2,3,4,5,6,7]:\n")
+```
+
+```
+## BST from sorted array [1,2,3,4,5,6,7]:
+```
+
+``` r
+cat("Height:", bst_sorted$height(), "(should be close to log₂(7) ≈ 2.8 for balanced)\n")
+```
+
+```
+## Height: 6 (should be close to log₂(7) ≈ 2.8 for balanced)
+```
+
+``` r
+bst_sorted$print_tree()
+```
+
+```
+## └── 1 
+##     └── 2 
+##         └── 3 
+##             └── 4 
+##                 └── 5 
+##                     └── 6 
+##                         └── 7
+```
+
+``` r
+# Shuffled array (more balanced)
+shuffled_array <- c(4, 2, 6, 1, 3, 5, 7)
+bst_shuffled <- create_bst_from_array(shuffled_array)
+cat("BST from shuffled array [4,2,6,1,3,5,7]:\n")
+```
+
+```
+## BST from shuffled array [4,2,6,1,3,5,7]:
+```
+
+``` r
+cat("Height:", bst_shuffled$height(), "\n")
+```
+
+```
+## Height: 2
+```
+
+``` r
+bst_shuffled$print_tree()
+```
+
+```
+## └── 4 
+##     ├── 2 
+##     │   ├── 1 
+##     │   └── 3 
+##     └── 6 
+##         ├── 5 
+##         └── 7
+```
+
+``` r
+# Test 8: kth smallest element
+cat("8. Finding kth Smallest Elements\n")
+```
+
+```
+## 8. Finding kth Smallest Elements
+```
+
+``` r
+for (k in 1:min(5, bst_shuffled$get_size())) {
+  kth_val <- kth_smallest(bst_shuffled, k)
+  cat(k, "smallest element:", kth_val, "\n")
+}
+```
+
+```
+## 1 smallest element: 
+## 2 smallest element: 
+## 3 smallest element: 
+## 4 smallest element: 
+## 5 smallest element:
+```
+
+``` r
+cat("\n")
+```
+
+``` r
+# Test 9: Edge cases
+cat("9. Edge Cases\n")
+```
+
+```
+## 9. Edge Cases
+```
+
+``` r
+empty_bst <- BST$new()
+cat("Empty BST:\n")
+```
+
+```
+## Empty BST:
+```
+
+``` r
+cat("Is empty:", empty_bst$is_empty(), "\n")
+```
+
+```
+## Is empty: TRUE
+```
+
+``` r
+cat("Size:", empty_bst$get_size(), "\n")
+```
+
+```
+## Size: 0
+```
+
+``` r
+cat("Height:", empty_bst$height(), "\n")
+```
+
+```
+## Height: -1
+```
+
+``` r
+cat("Min value:", empty_bst$find_min(), "\n")
+```
+
+```
+## Min value:
+```
+
+``` r
+cat("Search for 5:", empty_bst$search(5), "\n")
+```
+
+```
+## Search for 5: FALSE
+```
+
+``` r
+cat("Delete 5:", empty_bst$delete(5), "\n")
+```
+
+```
+## Delete 5: FALSE
+```
+
+``` r
+# Single node BST
+single_bst <- BST$new()
+single_bst$insert(42)
+cat("\nSingle node BST:\n")
+```
+
+```
+## 
+## Single node BST:
+```
+
+``` r
+cat("Size:", single_bst$get_size(), "\n")
+```
+
+```
+## Size: 1
+```
+
+``` r
+cat("Height:", single_bst$height(), "\n")
+```
+
+```
+## Height: 0
+```
+
+``` r
+cat("Min/Max:", single_bst$find_min(), "/", single_bst$find_max(), "\n")
+```
+
+```
+## Min/Max: 42 / 42
+```
+
+``` r
+single_bst$print_tree()
+```
+
+```
+## └── 42
+```
+
+``` r
+# Test 10: Real-world example - Student grades
+cat("\n10. Real-world Example - Student Grade Management\n")
+```
+
+```
+## 
+## 10. Real-world Example - Student Grade Management
+```
+
+``` r
+grade_bst <- BST$new()
+grades <- c(85, 92, 78, 96, 83, 88, 91, 79, 87, 94)
+
+cat("Student grades:", paste(grades, collapse = ", "), "\n")
+```
+
+```
+## Student grades: 85, 92, 78, 96, 83, 88, 91, 79, 87, 94
+```
+
+``` r
+for (grade in grades) {
+  grade_bst$insert(grade)
+}
+
+cat("Grades in ascending order:", paste(grade_bst$inorder_traversal(), collapse = ", "), "\n")
+```
+
+```
+## Grades in ascending order:
+```
+
+``` r
+cat("Highest grade:", grade_bst$find_max(), "\n")
+```
+
+```
+## Highest grade: 96
+```
+
+``` r
+cat("Lowest grade:", grade_bst$find_min(), "\n")
+```
+
+```
+## Lowest grade: 78
+```
+
+``` r
+cat("Median grade (middle element):", kth_smallest(grade_bst, ceiling(grade_bst$get_size()/2)), "\n")
+```
+
+```
+## Median grade (middle element):
+```
+
+``` r
+# Find students above certain grade
+threshold <- 90
+above_threshold <- grade_bst$inorder_traversal()
+above_threshold <- above_threshold[above_threshold >= threshold]
+cat("Grades >=", threshold, ":", paste(above_threshold, collapse = ", "), "\n")
+```
+
+```
+## Grades >= 90 :
+```
+
+``` r
+cat("\nGrade distribution tree:\n")
+```
+
+```
+## 
+## Grade distribution tree:
+```
+
+``` r
+grade_bst$print_tree()
+```
+
+```
+## └── 85 
+##     ├── 78 
+##     │   └── 83 
+##     │       └── 79 
+##     └── 92 
+##         ├── 88 
+##         │   ├── 87 
+##         │   └── 91 
+##         └── 96 
+##             └── 94
+```
+
diff --git a/Desktop/open-source/R/documentation/breadth_first_search.html b/Desktop/open-source/R/documentation/breadth_first_search.html
new file mode 100644
index 00000000..415f98ed
--- /dev/null
+++ b/Desktop/open-source/R/documentation/breadth_first_search.html
@@ -0,0 +1,387 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Breadth-First Search (BFS) Algorithm
+#
+# BFS is a graph traversal algorithm that explores all vertices at the current depth
+# before moving to vertices at the next depth level. It uses a queue data structure.
+#
+# Time Complexity: O(V + E) where V is vertices and E is edges
+# Space Complexity: O(V) for the visited array and queue
+#
+# Input: An adjacency list representation of a graph and a starting vertex
+# Output: The order in which vertices are visited during BFS traversal
+
+# BFS function using queue (implemented with vector)
+breadth_first_search &lt;- function(graph, start_vertex) {
+  # Get all vertices in the graph
+  all_vertices &lt;- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array and queue
+  visited &lt;- rep(FALSE, max(all_vertices))
+  names(visited) &lt;- 1:max(all_vertices)
+  queue &lt;- c(start_vertex)
+  result &lt;- c()
+  
+  # Mark starting vertex as visited
+  visited[start_vertex] &lt;- TRUE
+  
+  while (length(queue) &gt; 0) {
+    # Dequeue vertex from front of queue
+    vertex &lt;- queue[1]
+    queue &lt;- queue[-1]
+    result &lt;- c(result, vertex)
+    
+    # Add all unvisited neighbors to queue
+    if (as.character(vertex) %in% names(graph)) {
+      for (neighbor in graph[[as.character(vertex)]]) {
+        if (!visited[neighbor]) {
+          visited[neighbor] &lt;- TRUE
+          queue &lt;- c(queue, neighbor)
+        }
+      }
+    }
+  }
+  
+  return(result)
+}
+
+# BFS to find shortest path between two vertices
+bfs_shortest_path &lt;- function(graph, start_vertex, end_vertex) {
+  # Get all vertices in the graph
+  all_vertices &lt;- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array, queue, and parent tracking
+  visited &lt;- rep(FALSE, max(all_vertices))
+  names(visited) &lt;- 1:max(all_vertices)
+  parent &lt;- rep(-1, max(all_vertices))
+  names(parent) &lt;- 1:max(all_vertices)
+  queue &lt;- c(start_vertex)
+  
+  # Mark starting vertex as visited
+  visited[start_vertex] &lt;- TRUE
+  
+  while (length(queue) &gt; 0) {
+    # Dequeue vertex from front of queue
+    vertex &lt;- queue[1]
+    queue &lt;- queue[-1]
+    
+    # If we reached the target vertex, reconstruct path
+    if (vertex == end_vertex) {
+      path &lt;- c()
+      current &lt;- end_vertex
+      
+      # Backtrack using parent array
+      while (current != -1) {
+        path &lt;- c(current, path)
+        current &lt;- parent[current]
+      }
+      
+      return(list(
+        path = path,
+        distance = length(path) - 1
+      ))
+    }
+    
+    # Add all unvisited neighbors to queue
+    if (as.character(vertex) %in% names(graph)) {
+      for (neighbor in graph[[as.character(vertex)]]) {
+        if (!visited[neighbor]) {
+          visited[neighbor] &lt;- TRUE
+          parent[neighbor] &lt;- vertex
+          queue &lt;- c(queue, neighbor)
+        }
+      }
+    }
+  }
+  
+  # No path found
+  return(list(
+    path = NULL,
+    distance = -1
+  ))
+}
+
+# BFS to find all vertices at a specific distance
+bfs_vertices_at_distance &lt;- function(graph, start_vertex, target_distance) {
+  # Get all vertices in the graph
+  all_vertices &lt;- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array, queue with distances
+  visited &lt;- rep(FALSE, max(all_vertices))
+  names(visited) &lt;- 1:max(all_vertices)
+  queue &lt;- list(list(vertex = start_vertex, distance = 0))
+  vertices_at_distance &lt;- c()
+  
+  # Mark starting vertex as visited
+  visited[start_vertex] &lt;- TRUE
+  
+  while (length(queue) &gt; 0) {
+    # Dequeue vertex with distance from front of queue
+    current &lt;- queue[[1]]
+    queue &lt;- queue[-1]
+    vertex &lt;- current$vertex
+    distance &lt;- current$distance
+    
+    # If current distance matches target, add to result
+    if (distance == target_distance) {
+      vertices_at_distance &lt;- c(vertices_at_distance, vertex)
+    }
+    
+    # Don't explore further if we've reached target distance
+    if (distance &lt; target_distance) {
+      # Add all unvisited neighbors to queue
+      if (as.character(vertex) %in% names(graph)) {
+        for (neighbor in graph[[as.character(vertex)]]) {
+          if (!visited[neighbor]) {
+            visited[neighbor] &lt;- TRUE
+            queue &lt;- c(queue, list(list(vertex = neighbor, distance = distance + 1)))
+          }
+        }
+      }
+    }
+  }
+  
+  return(vertices_at_distance)
+}
+
+# Example usage and testing
+cat(&quot;=== Breadth-First Search (BFS) Algorithm ===\n&quot;)
+</code></pre>
+<pre><code>## === Breadth-First Search (BFS) Algorithm ===
+</code></pre>
+<pre><code class="language-r"># Create a sample graph as adjacency list
+# Graph structure:
+#     1
+#    / \
+#   2   3
+#  / \   \
+# 4   5   6
+graph &lt;- list(
+  &quot;1&quot; = c(2, 3),
+  &quot;2&quot; = c(4, 5),
+  &quot;3&quot; = c(6),
+  &quot;4&quot; = c(),
+  &quot;5&quot; = c(),
+  &quot;6&quot; = c()
+)
+
+cat(&quot;Graph structure (adjacency list):\n&quot;)
+</code></pre>
+<pre><code>## Graph structure (adjacency list):
+</code></pre>
+<pre><code class="language-r">for (vertex in names(graph)) {
+  cat(&quot;Vertex&quot;, vertex, &quot;-&gt; [&quot;, paste(graph[[vertex]], collapse = &quot;, &quot;), &quot;]\n&quot;)
+}
+</code></pre>
+<pre><code>## Vertex 1 -&gt; [ 2, 3 ]
+## Vertex 2 -&gt; [ 4, 5 ]
+## Vertex 3 -&gt; [ 6 ]
+## Vertex 4 -&gt; [  ]
+## Vertex 5 -&gt; [  ]
+## Vertex 6 -&gt; [  ]
+</code></pre>
+<pre><code class="language-r"># Test BFS traversal
+cat(&quot;\nBFS starting from vertex 1:\n&quot;)
+</code></pre>
+<pre><code>## 
+## BFS starting from vertex 1:
+</code></pre>
+<pre><code class="language-r">result &lt;- breadth_first_search(graph, 1)
+cat(&quot;Traversal order:&quot;, paste(result, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Traversal order: 1 -&gt; 2 -&gt; 3 -&gt; 4 -&gt; 5 -&gt; 6
+</code></pre>
+<pre><code class="language-r"># Test BFS from different starting vertex
+cat(&quot;\nBFS starting from vertex 2:\n&quot;)
+</code></pre>
+<pre><code>## 
+## BFS starting from vertex 2:
+</code></pre>
+<pre><code class="language-r">result_from_2 &lt;- breadth_first_search(graph, 2)
+cat(&quot;Traversal order:&quot;, paste(result_from_2, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Traversal order: 2 -&gt; 4 -&gt; 5
+</code></pre>
+<pre><code class="language-r"># Test shortest path finding
+cat(&quot;\n=== Shortest Path Finding ===\n&quot;)
+</code></pre>
+<pre><code>## 
+## === Shortest Path Finding ===
+</code></pre>
+<pre><code class="language-r">path_result &lt;- bfs_shortest_path(graph, 1, 5)
+if (!is.null(path_result$path)) {
+  cat(&quot;Shortest path from 1 to 5:&quot;, paste(path_result$path, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+  cat(&quot;Distance:&quot;, path_result$distance, &quot;\n&quot;)
+} else {
+  cat(&quot;No path found from 1 to 5\n&quot;)
+}
+</code></pre>
+<pre><code>## Shortest path from 1 to 5: 1 -&gt; 2 -&gt; 5 
+## Distance: 2
+</code></pre>
+<pre><code class="language-r"># Test vertices at specific distance
+cat(&quot;\n=== Vertices at Specific Distance ===\n&quot;)
+</code></pre>
+<pre><code>## 
+## === Vertices at Specific Distance ===
+</code></pre>
+<pre><code class="language-r">vertices_dist_2 &lt;- bfs_vertices_at_distance(graph, 1, 2)
+cat(&quot;Vertices at distance 2 from vertex 1:&quot;, paste(vertices_dist_2, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Vertices at distance 2 from vertex 1: 4, 5, 6
+</code></pre>
+<pre><code class="language-r"># Example with a more complex connected graph
+cat(&quot;\n=== Example with More Complex Graph ===\n&quot;)
+</code></pre>
+<pre><code>## 
+## === Example with More Complex Graph ===
+</code></pre>
+<pre><code class="language-r">complex_graph &lt;- list(
+  &quot;1&quot; = c(2, 3),
+  &quot;2&quot; = c(1, 4, 5),
+  &quot;3&quot; = c(1, 6),
+  &quot;4&quot; = c(2, 7),
+  &quot;5&quot; = c(2, 8),
+  &quot;6&quot; = c(3, 9),
+  &quot;7&quot; = c(4),
+  &quot;8&quot; = c(5),
+  &quot;9&quot; = c(6)
+)
+
+cat(&quot;Complex graph BFS starting from vertex 1:\n&quot;)
+</code></pre>
+<pre><code>## Complex graph BFS starting from vertex 1:
+</code></pre>
+<pre><code class="language-r">complex_result &lt;- breadth_first_search(complex_graph, 1)
+cat(&quot;Traversal order:&quot;, paste(complex_result, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Traversal order: 1 -&gt; 2 -&gt; 3 -&gt; 4 -&gt; 5 -&gt; 6 -&gt; 7 -&gt; 8 -&gt; 9
+</code></pre>
+<pre><code class="language-r"># Test shortest path in complex graph
+path_complex &lt;- bfs_shortest_path(complex_graph, 1, 9)
+if (!is.null(path_complex$path)) {
+  cat(&quot;Shortest path from 1 to 9:&quot;, paste(path_complex$path, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+  cat(&quot;Distance:&quot;, path_complex$distance, &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>## Shortest path from 1 to 9: 1 -&gt; 3 -&gt; 6 -&gt; 9 
+## Distance: 3
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/breadth_first_search.md b/Desktop/open-source/R/documentation/breadth_first_search.md
new file mode 100644
index 00000000..1de85dc0
--- /dev/null
+++ b/Desktop/open-source/R/documentation/breadth_first_search.md
@@ -0,0 +1,329 @@
+
+
+``` r
+# Breadth-First Search (BFS) Algorithm
+#
+# BFS is a graph traversal algorithm that explores all vertices at the current depth
+# before moving to vertices at the next depth level. It uses a queue data structure.
+#
+# Time Complexity: O(V + E) where V is vertices and E is edges
+# Space Complexity: O(V) for the visited array and queue
+#
+# Input: An adjacency list representation of a graph and a starting vertex
+# Output: The order in which vertices are visited during BFS traversal
+
+# BFS function using queue (implemented with vector)
+breadth_first_search <- function(graph, start_vertex) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array and queue
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  queue <- c(start_vertex)
+  result <- c()
+  
+  # Mark starting vertex as visited
+  visited[start_vertex] <- TRUE
+  
+  while (length(queue) > 0) {
+    # Dequeue vertex from front of queue
+    vertex <- queue[1]
+    queue <- queue[-1]
+    result <- c(result, vertex)
+    
+    # Add all unvisited neighbors to queue
+    if (as.character(vertex) %in% names(graph)) {
+      for (neighbor in graph[[as.character(vertex)]]) {
+        if (!visited[neighbor]) {
+          visited[neighbor] <- TRUE
+          queue <- c(queue, neighbor)
+        }
+      }
+    }
+  }
+  
+  return(result)
+}
+
+# BFS to find shortest path between two vertices
+bfs_shortest_path <- function(graph, start_vertex, end_vertex) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array, queue, and parent tracking
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  parent <- rep(-1, max(all_vertices))
+  names(parent) <- 1:max(all_vertices)
+  queue <- c(start_vertex)
+  
+  # Mark starting vertex as visited
+  visited[start_vertex] <- TRUE
+  
+  while (length(queue) > 0) {
+    # Dequeue vertex from front of queue
+    vertex <- queue[1]
+    queue <- queue[-1]
+    
+    # If we reached the target vertex, reconstruct path
+    if (vertex == end_vertex) {
+      path <- c()
+      current <- end_vertex
+      
+      # Backtrack using parent array
+      while (current != -1) {
+        path <- c(current, path)
+        current <- parent[current]
+      }
+      
+      return(list(
+        path = path,
+        distance = length(path) - 1
+      ))
+    }
+    
+    # Add all unvisited neighbors to queue
+    if (as.character(vertex) %in% names(graph)) {
+      for (neighbor in graph[[as.character(vertex)]]) {
+        if (!visited[neighbor]) {
+          visited[neighbor] <- TRUE
+          parent[neighbor] <- vertex
+          queue <- c(queue, neighbor)
+        }
+      }
+    }
+  }
+  
+  # No path found
+  return(list(
+    path = NULL,
+    distance = -1
+  ))
+}
+
+# BFS to find all vertices at a specific distance
+bfs_vertices_at_distance <- function(graph, start_vertex, target_distance) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array, queue with distances
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  queue <- list(list(vertex = start_vertex, distance = 0))
+  vertices_at_distance <- c()
+  
+  # Mark starting vertex as visited
+  visited[start_vertex] <- TRUE
+  
+  while (length(queue) > 0) {
+    # Dequeue vertex with distance from front of queue
+    current <- queue[[1]]
+    queue <- queue[-1]
+    vertex <- current$vertex
+    distance <- current$distance
+    
+    # If current distance matches target, add to result
+    if (distance == target_distance) {
+      vertices_at_distance <- c(vertices_at_distance, vertex)
+    }
+    
+    # Don't explore further if we've reached target distance
+    if (distance < target_distance) {
+      # Add all unvisited neighbors to queue
+      if (as.character(vertex) %in% names(graph)) {
+        for (neighbor in graph[[as.character(vertex)]]) {
+          if (!visited[neighbor]) {
+            visited[neighbor] <- TRUE
+            queue <- c(queue, list(list(vertex = neighbor, distance = distance + 1)))
+          }
+        }
+      }
+    }
+  }
+  
+  return(vertices_at_distance)
+}
+
+# Example usage and testing
+cat("=== Breadth-First Search (BFS) Algorithm ===\n")
+```
+
+```
+## === Breadth-First Search (BFS) Algorithm ===
+```
+
+``` r
+# Create a sample graph as adjacency list
+# Graph structure:
+#     1
+#    / \
+#   2   3
+#  / \   \
+# 4   5   6
+graph <- list(
+  "1" = c(2, 3),
+  "2" = c(4, 5),
+  "3" = c(6),
+  "4" = c(),
+  "5" = c(),
+  "6" = c()
+)
+
+cat("Graph structure (adjacency list):\n")
+```
+
+```
+## Graph structure (adjacency list):
+```
+
+``` r
+for (vertex in names(graph)) {
+  cat("Vertex", vertex, "-> [", paste(graph[[vertex]], collapse = ", "), "]\n")
+}
+```
+
+```
+## Vertex 1 -> [ 2, 3 ]
+## Vertex 2 -> [ 4, 5 ]
+## Vertex 3 -> [ 6 ]
+## Vertex 4 -> [  ]
+## Vertex 5 -> [  ]
+## Vertex 6 -> [  ]
+```
+
+``` r
+# Test BFS traversal
+cat("\nBFS starting from vertex 1:\n")
+```
+
+```
+## 
+## BFS starting from vertex 1:
+```
+
+``` r
+result <- breadth_first_search(graph, 1)
+cat("Traversal order:", paste(result, collapse = " -> "), "\n")
+```
+
+```
+## Traversal order: 1 -> 2 -> 3 -> 4 -> 5 -> 6
+```
+
+``` r
+# Test BFS from different starting vertex
+cat("\nBFS starting from vertex 2:\n")
+```
+
+```
+## 
+## BFS starting from vertex 2:
+```
+
+``` r
+result_from_2 <- breadth_first_search(graph, 2)
+cat("Traversal order:", paste(result_from_2, collapse = " -> "), "\n")
+```
+
+```
+## Traversal order: 2 -> 4 -> 5
+```
+
+``` r
+# Test shortest path finding
+cat("\n=== Shortest Path Finding ===\n")
+```
+
+```
+## 
+## === Shortest Path Finding ===
+```
+
+``` r
+path_result <- bfs_shortest_path(graph, 1, 5)
+if (!is.null(path_result$path)) {
+  cat("Shortest path from 1 to 5:", paste(path_result$path, collapse = " -> "), "\n")
+  cat("Distance:", path_result$distance, "\n")
+} else {
+  cat("No path found from 1 to 5\n")
+}
+```
+
+```
+## Shortest path from 1 to 5: 1 -> 2 -> 5 
+## Distance: 2
+```
+
+``` r
+# Test vertices at specific distance
+cat("\n=== Vertices at Specific Distance ===\n")
+```
+
+```
+## 
+## === Vertices at Specific Distance ===
+```
+
+``` r
+vertices_dist_2 <- bfs_vertices_at_distance(graph, 1, 2)
+cat("Vertices at distance 2 from vertex 1:", paste(vertices_dist_2, collapse = ", "), "\n")
+```
+
+```
+## Vertices at distance 2 from vertex 1: 4, 5, 6
+```
+
+``` r
+# Example with a more complex connected graph
+cat("\n=== Example with More Complex Graph ===\n")
+```
+
+```
+## 
+## === Example with More Complex Graph ===
+```
+
+``` r
+complex_graph <- list(
+  "1" = c(2, 3),
+  "2" = c(1, 4, 5),
+  "3" = c(1, 6),
+  "4" = c(2, 7),
+  "5" = c(2, 8),
+  "6" = c(3, 9),
+  "7" = c(4),
+  "8" = c(5),
+  "9" = c(6)
+)
+
+cat("Complex graph BFS starting from vertex 1:\n")
+```
+
+```
+## Complex graph BFS starting from vertex 1:
+```
+
+``` r
+complex_result <- breadth_first_search(complex_graph, 1)
+cat("Traversal order:", paste(complex_result, collapse = " -> "), "\n")
+```
+
+```
+## Traversal order: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
+```
+
+``` r
+# Test shortest path in complex graph
+path_complex <- bfs_shortest_path(complex_graph, 1, 9)
+if (!is.null(path_complex$path)) {
+  cat("Shortest path from 1 to 9:", paste(path_complex$path, collapse = " -> "), "\n")
+  cat("Distance:", path_complex$distance, "\n")
+}
+```
+
+```
+## Shortest path from 1 to 9: 1 -> 3 -> 6 -> 9 
+## Distance: 3
+```
+
diff --git a/Desktop/open-source/R/documentation/coin_change.html b/Desktop/open-source/R/documentation/coin_change.html
new file mode 100644
index 00000000..dc1670f4
--- /dev/null
+++ b/Desktop/open-source/R/documentation/coin_change.html
@@ -0,0 +1,223 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Coin Change Problem
+#
+# The Coin Change problem finds the minimum number of coins needed to make a certain amount
+# using a given set of coin denominations.
+#
+# Time Complexity: O(amount * n) where n = number of coin denominations
+# Space Complexity: O(amount)
+#
+# Applications:
+# - Currency and cash management
+# - Making change in vending machines or payment systems
+# - Dynamic resource allocation
+# - Minimum cost problems in algorithms
+
+# Function to compute minimum coins required
+coin_change &lt;- function(coins, amount) {
+  #' Compute minimum number of coins needed to make the given amount
+  #' @param coins: Numeric vector of coin denominations
+  #' @param amount: Total amount to make
+  #' @return: Minimum number of coins required, or -1 if not possible
+  
+  # Initialize DP array
+  dp &lt;- rep(Inf, amount + 1)
+  dp[0 + 1] &lt;- 0  # zero coins needed for amount 0
+  
+  for (i in 1:amount) {
+    for (coin in coins) {
+      if (coin &lt;= i) {
+        dp[i + 1] &lt;- min(dp[i + 1], 1 + dp[i - coin + 1])
+      }
+    }
+  }
+  
+  if (dp[amount + 1] == Inf) {
+    return(-1)
+  } else {
+    return(dp[amount + 1])
+  }
+}
+
+# Function to print the DP table (for educational purposes)
+print_coin_change_dp &lt;- function(dp, amount) {
+  cat(&quot;DP Table for Coin Change:\n&quot;)
+  for (i in 0:amount) {
+    cat(sprintf(&quot;Amount %2d: %s\n&quot;, i, dp[i + 1]))
+  }
+  cat(&quot;\n&quot;)
+}
+
+
+# Example Usage &amp; Testing
+cat(&quot;=== Coin Change Problem ===\n\n&quot;)
+</code></pre>
+<pre><code>## === Coin Change Problem ===
+</code></pre>
+<pre><code class="language-r"># Test 1: Basic Example
+coins &lt;- c(1, 2, 5)
+amount &lt;- 11
+cat(&quot;Coins:&quot;, paste(coins, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Coins: 1, 2, 5
+</code></pre>
+<pre><code class="language-r">cat(&quot;Amount:&quot;, amount, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Amount: 11
+</code></pre>
+<pre><code class="language-r">min_coins &lt;- coin_change(coins, amount)
+cat(&quot;Minimum Coins Needed:&quot;, min_coins, &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Minimum Coins Needed: 3
+</code></pre>
+<pre><code class="language-r"># Test 2: No solution case
+coins &lt;- c(2, 4)
+amount &lt;- 7
+cat(&quot;Coins:&quot;, paste(coins, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Coins: 2, 4
+</code></pre>
+<pre><code class="language-r">cat(&quot;Amount:&quot;, amount, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Amount: 7
+</code></pre>
+<pre><code class="language-r">min_coins &lt;- coin_change(coins, amount)
+cat(&quot;Minimum Coins Needed:&quot;, min_coins, &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Minimum Coins Needed: -1
+</code></pre>
+<pre><code class="language-r"># Test 3: Larger dataset
+coins &lt;- c(1, 3, 4, 5)
+amount &lt;- 7
+cat(&quot;Coins:&quot;, paste(coins, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Coins: 1, 3, 4, 5
+</code></pre>
+<pre><code class="language-r">cat(&quot;Amount:&quot;, amount, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Amount: 7
+</code></pre>
+<pre><code class="language-r">min_coins &lt;- coin_change(coins, amount)
+cat(&quot;Minimum Coins Needed:&quot;, min_coins, &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Minimum Coins Needed: 2
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/coin_change.md b/Desktop/open-source/R/documentation/coin_change.md
new file mode 100644
index 00000000..dab79cb5
--- /dev/null
+++ b/Desktop/open-source/R/documentation/coin_change.md
@@ -0,0 +1,145 @@
+
+
+``` r
+# Coin Change Problem
+#
+# The Coin Change problem finds the minimum number of coins needed to make a certain amount
+# using a given set of coin denominations.
+#
+# Time Complexity: O(amount * n) where n = number of coin denominations
+# Space Complexity: O(amount)
+#
+# Applications:
+# - Currency and cash management
+# - Making change in vending machines or payment systems
+# - Dynamic resource allocation
+# - Minimum cost problems in algorithms
+
+# Function to compute minimum coins required
+coin_change <- function(coins, amount) {
+  #' Compute minimum number of coins needed to make the given amount
+  #' @param coins: Numeric vector of coin denominations
+  #' @param amount: Total amount to make
+  #' @return: Minimum number of coins required, or -1 if not possible
+  
+  # Initialize DP array
+  dp <- rep(Inf, amount + 1)
+  dp[0 + 1] <- 0  # zero coins needed for amount 0
+  
+  for (i in 1:amount) {
+    for (coin in coins) {
+      if (coin <= i) {
+        dp[i + 1] <- min(dp[i + 1], 1 + dp[i - coin + 1])
+      }
+    }
+  }
+  
+  if (dp[amount + 1] == Inf) {
+    return(-1)
+  } else {
+    return(dp[amount + 1])
+  }
+}
+
+# Function to print the DP table (for educational purposes)
+print_coin_change_dp <- function(dp, amount) {
+  cat("DP Table for Coin Change:\n")
+  for (i in 0:amount) {
+    cat(sprintf("Amount %2d: %s\n", i, dp[i + 1]))
+  }
+  cat("\n")
+}
+
+
+# Example Usage & Testing
+cat("=== Coin Change Problem ===\n\n")
+```
+
+```
+## === Coin Change Problem ===
+```
+
+``` r
+# Test 1: Basic Example
+coins <- c(1, 2, 5)
+amount <- 11
+cat("Coins:", paste(coins, collapse = ", "), "\n")
+```
+
+```
+## Coins: 1, 2, 5
+```
+
+``` r
+cat("Amount:", amount, "\n")
+```
+
+```
+## Amount: 11
+```
+
+``` r
+min_coins <- coin_change(coins, amount)
+cat("Minimum Coins Needed:", min_coins, "\n\n")
+```
+
+```
+## Minimum Coins Needed: 3
+```
+
+``` r
+# Test 2: No solution case
+coins <- c(2, 4)
+amount <- 7
+cat("Coins:", paste(coins, collapse = ", "), "\n")
+```
+
+```
+## Coins: 2, 4
+```
+
+``` r
+cat("Amount:", amount, "\n")
+```
+
+```
+## Amount: 7
+```
+
+``` r
+min_coins <- coin_change(coins, amount)
+cat("Minimum Coins Needed:", min_coins, "\n\n")
+```
+
+```
+## Minimum Coins Needed: -1
+```
+
+``` r
+# Test 3: Larger dataset
+coins <- c(1, 3, 4, 5)
+amount <- 7
+cat("Coins:", paste(coins, collapse = ", "), "\n")
+```
+
+```
+## Coins: 1, 3, 4, 5
+```
+
+``` r
+cat("Amount:", amount, "\n")
+```
+
+```
+## Amount: 7
+```
+
+``` r
+min_coins <- coin_change(coins, amount)
+cat("Minimum Coins Needed:", min_coins, "\n\n")
+```
+
+```
+## Minimum Coins Needed: 2
+```
+
diff --git a/Desktop/open-source/R/documentation/data_normalization_standardization.html b/Desktop/open-source/R/documentation/data_normalization_standardization.html
new file mode 100644
index 00000000..7c8fb1fa
--- /dev/null
+++ b/Desktop/open-source/R/documentation/data_normalization_standardization.html
@@ -0,0 +1,494 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># normalization &amp; standardization
+normalization&lt;-function(x){
+  return((x-min(x))/(max(x)-min(x)))
+}
+
+standardization&lt;-function(x){
+  return((x-mean(x))/sd(x))
+}
+
+head(iris)
+</code></pre>
+<pre><code>##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
+## 1          5.1         3.5          1.4         0.2  setosa
+## 2          4.9         3.0          1.4         0.2  setosa
+## 3          4.7         3.2          1.3         0.2  setosa
+## 4          4.6         3.1          1.5         0.2  setosa
+## 5          5.0         3.6          1.4         0.2  setosa
+## 6          5.4         3.9          1.7         0.4  setosa
+</code></pre>
+<pre><code class="language-r"># Sepal.Length Sepal.Width Petal.Length Petal.Width Species
+# 1          5.1         3.5          1.4         0.2  setosa
+# 2          4.9         3.0          1.4         0.2  setosa
+# 3          4.7         3.2          1.3         0.2  setosa
+# 4          4.6         3.1          1.5         0.2  setosa
+# 5          5.0         3.6          1.4         0.2  setosa
+# 6          5.4         3.9          1.7         0.4  setosa
+
+iris&lt;-iris[,-5]
+head(iris)
+</code></pre>
+<pre><code>##   Sepal.Length Sepal.Width Petal.Length Petal.Width
+## 1          5.1         3.5          1.4         0.2
+## 2          4.9         3.0          1.4         0.2
+## 3          4.7         3.2          1.3         0.2
+## 4          4.6         3.1          1.5         0.2
+## 5          5.0         3.6          1.4         0.2
+## 6          5.4         3.9          1.7         0.4
+</code></pre>
+<pre><code class="language-r"># Sepal.Length Sepal.Width Petal.Length Petal.Width
+# 1          5.1         3.5          1.4         0.2
+# 2          4.9         3.0          1.4         0.2
+# 3          4.7         3.2          1.3         0.2
+# 4          4.6         3.1          1.5         0.2
+# 5          5.0         3.6          1.4         0.2
+# 6          5.4         3.9          1.7         0.4
+
+#normalize
+apply(as.matrix(iris),2,normalization)
+</code></pre>
+<pre><code>##        Sepal.Length Sepal.Width Petal.Length Petal.Width
+##   [1,]   0.22222222  0.62500000   0.06779661  0.04166667
+##   [2,]   0.16666667  0.41666667   0.06779661  0.04166667
+##   [3,]   0.11111111  0.50000000   0.05084746  0.04166667
+##   [4,]   0.08333333  0.45833333   0.08474576  0.04166667
+##   [5,]   0.19444444  0.66666667   0.06779661  0.04166667
+##   [6,]   0.30555556  0.79166667   0.11864407  0.12500000
+##   [7,]   0.08333333  0.58333333   0.06779661  0.08333333
+##   [8,]   0.19444444  0.58333333   0.08474576  0.04166667
+##   [9,]   0.02777778  0.37500000   0.06779661  0.04166667
+##  [10,]   0.16666667  0.45833333   0.08474576  0.00000000
+##  [11,]   0.30555556  0.70833333   0.08474576  0.04166667
+##  [12,]   0.13888889  0.58333333   0.10169492  0.04166667
+##  [13,]   0.13888889  0.41666667   0.06779661  0.00000000
+##  [14,]   0.00000000  0.41666667   0.01694915  0.00000000
+##  [15,]   0.41666667  0.83333333   0.03389831  0.04166667
+##  [16,]   0.38888889  1.00000000   0.08474576  0.12500000
+##  [17,]   0.30555556  0.79166667   0.05084746  0.12500000
+##  [18,]   0.22222222  0.62500000   0.06779661  0.08333333
+##  [19,]   0.38888889  0.75000000   0.11864407  0.08333333
+##  [20,]   0.22222222  0.75000000   0.08474576  0.08333333
+##  [21,]   0.30555556  0.58333333   0.11864407  0.04166667
+##  [22,]   0.22222222  0.70833333   0.08474576  0.12500000
+##  [23,]   0.08333333  0.66666667   0.00000000  0.04166667
+##  [24,]   0.22222222  0.54166667   0.11864407  0.16666667
+##  [25,]   0.13888889  0.58333333   0.15254237  0.04166667
+##  [26,]   0.19444444  0.41666667   0.10169492  0.04166667
+##  [27,]   0.19444444  0.58333333   0.10169492  0.12500000
+##  [28,]   0.25000000  0.62500000   0.08474576  0.04166667
+##  [29,]   0.25000000  0.58333333   0.06779661  0.04166667
+##  [30,]   0.11111111  0.50000000   0.10169492  0.04166667
+##  [31,]   0.13888889  0.45833333   0.10169492  0.04166667
+##  [32,]   0.30555556  0.58333333   0.08474576  0.12500000
+##  [33,]   0.25000000  0.87500000   0.08474576  0.00000000
+##  [34,]   0.33333333  0.91666667   0.06779661  0.04166667
+##  [35,]   0.16666667  0.45833333   0.08474576  0.04166667
+##  [36,]   0.19444444  0.50000000   0.03389831  0.04166667
+##  [37,]   0.33333333  0.62500000   0.05084746  0.04166667
+##  [38,]   0.16666667  0.66666667   0.06779661  0.00000000
+##  [39,]   0.02777778  0.41666667   0.05084746  0.04166667
+##  [40,]   0.22222222  0.58333333   0.08474576  0.04166667
+##  [41,]   0.19444444  0.62500000   0.05084746  0.08333333
+##  [42,]   0.05555556  0.12500000   0.05084746  0.08333333
+##  [43,]   0.02777778  0.50000000   0.05084746  0.04166667
+##  [44,]   0.19444444  0.62500000   0.10169492  0.20833333
+##  [45,]   0.22222222  0.75000000   0.15254237  0.12500000
+##  [46,]   0.13888889  0.41666667   0.06779661  0.08333333
+##  [47,]   0.22222222  0.75000000   0.10169492  0.04166667
+##  [48,]   0.08333333  0.50000000   0.06779661  0.04166667
+##  [49,]   0.27777778  0.70833333   0.08474576  0.04166667
+##  [50,]   0.19444444  0.54166667   0.06779661  0.04166667
+##  [51,]   0.75000000  0.50000000   0.62711864  0.54166667
+##  [52,]   0.58333333  0.50000000   0.59322034  0.58333333
+##  [53,]   0.72222222  0.45833333   0.66101695  0.58333333
+##  [54,]   0.33333333  0.12500000   0.50847458  0.50000000
+##  [55,]   0.61111111  0.33333333   0.61016949  0.58333333
+##  [56,]   0.38888889  0.33333333   0.59322034  0.50000000
+##  [57,]   0.55555556  0.54166667   0.62711864  0.62500000
+##  [58,]   0.16666667  0.16666667   0.38983051  0.37500000
+##  [59,]   0.63888889  0.37500000   0.61016949  0.50000000
+##  [60,]   0.25000000  0.29166667   0.49152542  0.54166667
+##  [61,]   0.19444444  0.00000000   0.42372881  0.37500000
+##  [62,]   0.44444444  0.41666667   0.54237288  0.58333333
+##  [63,]   0.47222222  0.08333333   0.50847458  0.37500000
+##  [64,]   0.50000000  0.37500000   0.62711864  0.54166667
+##  [65,]   0.36111111  0.37500000   0.44067797  0.50000000
+##  [66,]   0.66666667  0.45833333   0.57627119  0.54166667
+##  [67,]   0.36111111  0.41666667   0.59322034  0.58333333
+##  [68,]   0.41666667  0.29166667   0.52542373  0.37500000
+##  [69,]   0.52777778  0.08333333   0.59322034  0.58333333
+##  [70,]   0.36111111  0.20833333   0.49152542  0.41666667
+##  [71,]   0.44444444  0.50000000   0.64406780  0.70833333
+##  [72,]   0.50000000  0.33333333   0.50847458  0.50000000
+##  [73,]   0.55555556  0.20833333   0.66101695  0.58333333
+##  [74,]   0.50000000  0.33333333   0.62711864  0.45833333
+##  [75,]   0.58333333  0.37500000   0.55932203  0.50000000
+##  [76,]   0.63888889  0.41666667   0.57627119  0.54166667
+##  [77,]   0.69444444  0.33333333   0.64406780  0.54166667
+##  [78,]   0.66666667  0.41666667   0.67796610  0.66666667
+##  [79,]   0.47222222  0.37500000   0.59322034  0.58333333
+##  [80,]   0.38888889  0.25000000   0.42372881  0.37500000
+##  [81,]   0.33333333  0.16666667   0.47457627  0.41666667
+##  [82,]   0.33333333  0.16666667   0.45762712  0.37500000
+##  [83,]   0.41666667  0.29166667   0.49152542  0.45833333
+##  [84,]   0.47222222  0.29166667   0.69491525  0.62500000
+##  [85,]   0.30555556  0.41666667   0.59322034  0.58333333
+##  [86,]   0.47222222  0.58333333   0.59322034  0.62500000
+##  [87,]   0.66666667  0.45833333   0.62711864  0.58333333
+##  [88,]   0.55555556  0.12500000   0.57627119  0.50000000
+##  [89,]   0.36111111  0.41666667   0.52542373  0.50000000
+##  [90,]   0.33333333  0.20833333   0.50847458  0.50000000
+##  [91,]   0.33333333  0.25000000   0.57627119  0.45833333
+##  [92,]   0.50000000  0.41666667   0.61016949  0.54166667
+##  [93,]   0.41666667  0.25000000   0.50847458  0.45833333
+##  [94,]   0.19444444  0.12500000   0.38983051  0.37500000
+##  [95,]   0.36111111  0.29166667   0.54237288  0.50000000
+##  [96,]   0.38888889  0.41666667   0.54237288  0.45833333
+##  [97,]   0.38888889  0.37500000   0.54237288  0.50000000
+##  [98,]   0.52777778  0.37500000   0.55932203  0.50000000
+##  [99,]   0.22222222  0.20833333   0.33898305  0.41666667
+## [100,]   0.38888889  0.33333333   0.52542373  0.50000000
+## [101,]   0.55555556  0.54166667   0.84745763  1.00000000
+## [102,]   0.41666667  0.29166667   0.69491525  0.75000000
+## [103,]   0.77777778  0.41666667   0.83050847  0.83333333
+## [104,]   0.55555556  0.37500000   0.77966102  0.70833333
+## [105,]   0.61111111  0.41666667   0.81355932  0.87500000
+## [106,]   0.91666667  0.41666667   0.94915254  0.83333333
+## [107,]   0.16666667  0.20833333   0.59322034  0.66666667
+## [108,]   0.83333333  0.37500000   0.89830508  0.70833333
+## [109,]   0.66666667  0.20833333   0.81355932  0.70833333
+## [110,]   0.80555556  0.66666667   0.86440678  1.00000000
+## [111,]   0.61111111  0.50000000   0.69491525  0.79166667
+## [112,]   0.58333333  0.29166667   0.72881356  0.75000000
+## [113,]   0.69444444  0.41666667   0.76271186  0.83333333
+## [114,]   0.38888889  0.20833333   0.67796610  0.79166667
+## [115,]   0.41666667  0.33333333   0.69491525  0.95833333
+## [116,]   0.58333333  0.50000000   0.72881356  0.91666667
+## [117,]   0.61111111  0.41666667   0.76271186  0.70833333
+## [118,]   0.94444444  0.75000000   0.96610169  0.87500000
+## [119,]   0.94444444  0.25000000   1.00000000  0.91666667
+## [120,]   0.47222222  0.08333333   0.67796610  0.58333333
+## [121,]   0.72222222  0.50000000   0.79661017  0.91666667
+## [122,]   0.36111111  0.33333333   0.66101695  0.79166667
+## [123,]   0.94444444  0.33333333   0.96610169  0.79166667
+## [124,]   0.55555556  0.29166667   0.66101695  0.70833333
+## [125,]   0.66666667  0.54166667   0.79661017  0.83333333
+## [126,]   0.80555556  0.50000000   0.84745763  0.70833333
+## [127,]   0.52777778  0.33333333   0.64406780  0.70833333
+## [128,]   0.50000000  0.41666667   0.66101695  0.70833333
+## [129,]   0.58333333  0.33333333   0.77966102  0.83333333
+## [130,]   0.80555556  0.41666667   0.81355932  0.62500000
+## [131,]   0.86111111  0.33333333   0.86440678  0.75000000
+## [132,]   1.00000000  0.75000000   0.91525424  0.79166667
+## [133,]   0.58333333  0.33333333   0.77966102  0.87500000
+## [134,]   0.55555556  0.33333333   0.69491525  0.58333333
+## [135,]   0.50000000  0.25000000   0.77966102  0.54166667
+## [136,]   0.94444444  0.41666667   0.86440678  0.91666667
+## [137,]   0.55555556  0.58333333   0.77966102  0.95833333
+## [138,]   0.58333333  0.45833333   0.76271186  0.70833333
+## [139,]   0.47222222  0.41666667   0.64406780  0.70833333
+## [140,]   0.72222222  0.45833333   0.74576271  0.83333333
+## [141,]   0.66666667  0.45833333   0.77966102  0.95833333
+## [142,]   0.72222222  0.45833333   0.69491525  0.91666667
+## [143,]   0.41666667  0.29166667   0.69491525  0.75000000
+## [144,]   0.69444444  0.50000000   0.83050847  0.91666667
+## [145,]   0.66666667  0.54166667   0.79661017  1.00000000
+## [146,]   0.66666667  0.41666667   0.71186441  0.91666667
+## [147,]   0.55555556  0.20833333   0.67796610  0.75000000
+## [148,]   0.61111111  0.41666667   0.71186441  0.79166667
+## [149,]   0.52777778  0.58333333   0.74576271  0.91666667
+## [150,]   0.44444444  0.41666667   0.69491525  0.70833333
+</code></pre>
+<pre><code class="language-r"># Sepal.Length Sepal.Width Petal.Length Petal.Width
+# [1,]   0.22222222  0.62500000   0.06779661  0.04166667
+# [2,]   0.16666667  0.41666667   0.06779661  0.04166667
+# [3,]   0.11111111  0.50000000   0.05084746  0.04166667
+# [4,]   0.08333333  0.45833333   0.08474576  0.04166667
+# [5,]   0.19444444  0.66666667   0.06779661  0.04166667
+# [6,]   0.30555556  0.79166667   0.11864407  0.12500000
+# [7,]   0.08333333  0.58333333   0.06779661  0.08333333
+
+#standardize
+apply(as.matrix(iris),2,standardization)
+</code></pre>
+<pre><code>##        Sepal.Length Sepal.Width Petal.Length   Petal.Width
+##   [1,]  -0.89767388  1.01560199  -1.33575163 -1.3110521482
+##   [2,]  -1.13920048 -0.13153881  -1.33575163 -1.3110521482
+##   [3,]  -1.38072709  0.32731751  -1.39239929 -1.3110521482
+##   [4,]  -1.50149039  0.09788935  -1.27910398 -1.3110521482
+##   [5,]  -1.01843718  1.24503015  -1.33575163 -1.3110521482
+##   [6,]  -0.53538397  1.93331463  -1.16580868 -1.0486667950
+##   [7,]  -1.50149039  0.78617383  -1.33575163 -1.1798594716
+##   [8,]  -1.01843718  0.78617383  -1.27910398 -1.3110521482
+##   [9,]  -1.74301699 -0.36096697  -1.33575163 -1.3110521482
+##  [10,]  -1.13920048  0.09788935  -1.27910398 -1.4422448248
+##  [11,]  -0.53538397  1.47445831  -1.27910398 -1.3110521482
+##  [12,]  -1.25996379  0.78617383  -1.22245633 -1.3110521482
+##  [13,]  -1.25996379 -0.13153881  -1.33575163 -1.4422448248
+##  [14,]  -1.86378030 -0.13153881  -1.50569459 -1.4422448248
+##  [15,]  -0.05233076  2.16274279  -1.44904694 -1.3110521482
+##  [16,]  -0.17309407  3.08045544  -1.27910398 -1.0486667950
+##  [17,]  -0.53538397  1.93331463  -1.39239929 -1.0486667950
+##  [18,]  -0.89767388  1.01560199  -1.33575163 -1.1798594716
+##  [19,]  -0.17309407  1.70388647  -1.16580868 -1.1798594716
+##  [20,]  -0.89767388  1.70388647  -1.27910398 -1.1798594716
+##  [21,]  -0.53538397  0.78617383  -1.16580868 -1.3110521482
+##  [22,]  -0.89767388  1.47445831  -1.27910398 -1.0486667950
+##  [23,]  -1.50149039  1.24503015  -1.56234224 -1.3110521482
+##  [24,]  -0.89767388  0.55674567  -1.16580868 -0.9174741184
+##  [25,]  -1.25996379  0.78617383  -1.05251337 -1.3110521482
+##  [26,]  -1.01843718 -0.13153881  -1.22245633 -1.3110521482
+##  [27,]  -1.01843718  0.78617383  -1.22245633 -1.0486667950
+##  [28,]  -0.77691058  1.01560199  -1.27910398 -1.3110521482
+##  [29,]  -0.77691058  0.78617383  -1.33575163 -1.3110521482
+##  [30,]  -1.38072709  0.32731751  -1.22245633 -1.3110521482
+##  [31,]  -1.25996379  0.09788935  -1.22245633 -1.3110521482
+##  [32,]  -0.53538397  0.78617383  -1.27910398 -1.0486667950
+##  [33,]  -0.77691058  2.39217095  -1.27910398 -1.4422448248
+##  [34,]  -0.41462067  2.62159911  -1.33575163 -1.3110521482
+##  [35,]  -1.13920048  0.09788935  -1.27910398 -1.3110521482
+##  [36,]  -1.01843718  0.32731751  -1.44904694 -1.3110521482
+##  [37,]  -0.41462067  1.01560199  -1.39239929 -1.3110521482
+##  [38,]  -1.13920048  1.24503015  -1.33575163 -1.4422448248
+##  [39,]  -1.74301699 -0.13153881  -1.39239929 -1.3110521482
+##  [40,]  -0.89767388  0.78617383  -1.27910398 -1.3110521482
+##  [41,]  -1.01843718  1.01560199  -1.39239929 -1.1798594716
+##  [42,]  -1.62225369 -1.73753594  -1.39239929 -1.1798594716
+##  [43,]  -1.74301699  0.32731751  -1.39239929 -1.3110521482
+##  [44,]  -1.01843718  1.01560199  -1.22245633 -0.7862814418
+##  [45,]  -0.89767388  1.70388647  -1.05251337 -1.0486667950
+##  [46,]  -1.25996379 -0.13153881  -1.33575163 -1.1798594716
+##  [47,]  -0.89767388  1.70388647  -1.22245633 -1.3110521482
+##  [48,]  -1.50149039  0.32731751  -1.33575163 -1.3110521482
+##  [49,]  -0.65614727  1.47445831  -1.27910398 -1.3110521482
+##  [50,]  -1.01843718  0.55674567  -1.33575163 -1.3110521482
+##  [51,]   1.39682886  0.32731751   0.53362088  0.2632599711
+##  [52,]   0.67224905  0.32731751   0.42032558  0.3944526477
+##  [53,]   1.27606556  0.09788935   0.64691619  0.3944526477
+##  [54,]  -0.41462067 -1.73753594   0.13708732  0.1320672944
+##  [55,]   0.79301235 -0.59039513   0.47697323  0.3944526477
+##  [56,]  -0.17309407 -0.59039513   0.42032558  0.1320672944
+##  [57,]   0.55148575  0.55674567   0.53362088  0.5256453243
+##  [58,]  -1.13920048 -1.50810778  -0.25944625 -0.2615107354
+##  [59,]   0.91377565 -0.36096697   0.47697323  0.1320672944
+##  [60,]  -0.77691058 -0.81982329   0.08043967  0.2632599711
+##  [61,]  -1.01843718 -2.42582042  -0.14615094 -0.2615107354
+##  [62,]   0.06843254 -0.13153881   0.25038262  0.3944526477
+##  [63,]   0.18919584 -1.96696410   0.13708732 -0.2615107354
+##  [64,]   0.30995914 -0.36096697   0.53362088  0.2632599711
+##  [65,]  -0.29385737 -0.36096697  -0.08950329  0.1320672944
+##  [66,]   1.03453895  0.09788935   0.36367793  0.2632599711
+##  [67,]  -0.29385737 -0.13153881   0.42032558  0.3944526477
+##  [68,]  -0.05233076 -0.81982329   0.19373497 -0.2615107354
+##  [69,]   0.43072244 -1.96696410   0.42032558  0.3944526477
+##  [70,]  -0.29385737 -1.27867961   0.08043967 -0.1303180588
+##  [71,]   0.06843254  0.32731751   0.59026853  0.7880306775
+##  [72,]   0.30995914 -0.59039513   0.13708732  0.1320672944
+##  [73,]   0.55148575 -1.27867961   0.64691619  0.3944526477
+##  [74,]   0.30995914 -0.59039513   0.53362088  0.0008746178
+##  [75,]   0.67224905 -0.36096697   0.30703027  0.1320672944
+##  [76,]   0.91377565 -0.13153881   0.36367793  0.2632599711
+##  [77,]   1.15530226 -0.59039513   0.59026853  0.2632599711
+##  [78,]   1.03453895 -0.13153881   0.70356384  0.6568380009
+##  [79,]   0.18919584 -0.36096697   0.42032558  0.3944526477
+##  [80,]  -0.17309407 -1.04925145  -0.14615094 -0.2615107354
+##  [81,]  -0.41462067 -1.50810778   0.02379201 -0.1303180588
+##  [82,]  -0.41462067 -1.50810778  -0.03285564 -0.2615107354
+##  [83,]  -0.05233076 -0.81982329   0.08043967  0.0008746178
+##  [84,]   0.18919584 -0.81982329   0.76021149  0.5256453243
+##  [85,]  -0.53538397 -0.13153881   0.42032558  0.3944526477
+##  [86,]   0.18919584  0.78617383   0.42032558  0.5256453243
+##  [87,]   1.03453895  0.09788935   0.53362088  0.3944526477
+##  [88,]   0.55148575 -1.73753594   0.36367793  0.1320672944
+##  [89,]  -0.29385737 -0.13153881   0.19373497  0.1320672944
+##  [90,]  -0.41462067 -1.27867961   0.13708732  0.1320672944
+##  [91,]  -0.41462067 -1.04925145   0.36367793  0.0008746178
+##  [92,]   0.30995914 -0.13153881   0.47697323  0.2632599711
+##  [93,]  -0.05233076 -1.04925145   0.13708732  0.0008746178
+##  [94,]  -1.01843718 -1.73753594  -0.25944625 -0.2615107354
+##  [95,]  -0.29385737 -0.81982329   0.25038262  0.1320672944
+##  [96,]  -0.17309407 -0.13153881   0.25038262  0.0008746178
+##  [97,]  -0.17309407 -0.36096697   0.25038262  0.1320672944
+##  [98,]   0.43072244 -0.36096697   0.30703027  0.1320672944
+##  [99,]  -0.89767388 -1.27867961  -0.42938920 -0.1303180588
+## [100,]  -0.17309407 -0.59039513   0.19373497  0.1320672944
+## [101,]   0.55148575  0.55674567   1.27004036  1.7063794137
+## [102,]  -0.05233076 -0.81982329   0.76021149  0.9192233541
+## [103,]   1.51759216 -0.13153881   1.21339271  1.1816087073
+## [104,]   0.55148575 -0.36096697   1.04344975  0.7880306775
+## [105,]   0.79301235 -0.13153881   1.15674505  1.3128013839
+## [106,]   2.12140867 -0.13153881   1.60992627  1.1816087073
+## [107,]  -1.13920048 -1.27867961   0.42032558  0.6568380009
+## [108,]   1.75911877 -0.36096697   1.43998331  0.7880306775
+## [109,]   1.03453895 -1.27867961   1.15674505  0.7880306775
+## [110,]   1.63835547  1.24503015   1.32668801  1.7063794137
+## [111,]   0.79301235  0.32731751   0.76021149  1.0504160307
+## [112,]   0.67224905 -0.81982329   0.87350679  0.9192233541
+## [113,]   1.15530226 -0.13153881   0.98680210  1.1816087073
+## [114,]  -0.17309407 -1.27867961   0.70356384  1.0504160307
+## [115,]  -0.05233076 -0.59039513   0.76021149  1.5751867371
+## [116,]   0.67224905  0.32731751   0.87350679  1.4439940605
+## [117,]   0.79301235 -0.13153881   0.98680210  0.7880306775
+## [118,]   2.24217198  1.70388647   1.66657392  1.3128013839
+## [119,]   2.24217198 -1.04925145   1.77986923  1.4439940605
+## [120,]   0.18919584 -1.96696410   0.70356384  0.3944526477
+## [121,]   1.27606556  0.32731751   1.10009740  1.4439940605
+## [122,]  -0.29385737 -0.59039513   0.64691619  1.0504160307
+## [123,]   2.24217198 -0.59039513   1.66657392  1.0504160307
+## [124,]   0.55148575 -0.81982329   0.64691619  0.7880306775
+## [125,]   1.03453895  0.55674567   1.10009740  1.1816087073
+## [126,]   1.63835547  0.32731751   1.27004036  0.7880306775
+## [127,]   0.43072244 -0.59039513   0.59026853  0.7880306775
+## [128,]   0.30995914 -0.13153881   0.64691619  0.7880306775
+## [129,]   0.67224905 -0.59039513   1.04344975  1.1816087073
+## [130,]   1.63835547 -0.13153881   1.15674505  0.5256453243
+## [131,]   1.87988207 -0.59039513   1.32668801  0.9192233541
+## [132,]   2.48369858  1.70388647   1.49663097  1.0504160307
+## [133,]   0.67224905 -0.59039513   1.04344975  1.3128013839
+## [134,]   0.55148575 -0.59039513   0.76021149  0.3944526477
+## [135,]   0.30995914 -1.04925145   1.04344975  0.2632599711
+## [136,]   2.24217198 -0.13153881   1.32668801  1.4439940605
+## [137,]   0.55148575  0.78617383   1.04344975  1.5751867371
+## [138,]   0.67224905  0.09788935   0.98680210  0.7880306775
+## [139,]   0.18919584 -0.13153881   0.59026853  0.7880306775
+## [140,]   1.27606556  0.09788935   0.93015445  1.1816087073
+## [141,]   1.03453895  0.09788935   1.04344975  1.5751867371
+## [142,]   1.27606556  0.09788935   0.76021149  1.4439940605
+## [143,]  -0.05233076 -0.81982329   0.76021149  0.9192233541
+## [144,]   1.15530226  0.32731751   1.21339271  1.4439940605
+## [145,]   1.03453895  0.55674567   1.10009740  1.7063794137
+## [146,]   1.03453895 -0.13153881   0.81685914  1.4439940605
+## [147,]   0.55148575 -1.27867961   0.70356384  0.9192233541
+## [148,]   0.79301235 -0.13153881   0.81685914  1.0504160307
+## [149,]   0.43072244  0.78617383   0.93015445  1.4439940605
+## [150,]   0.06843254 -0.13153881   0.76021149  0.7880306775
+</code></pre>
+<pre><code class="language-r"># Sepal.Length Sepal.Width Petal.Length   Petal.Width
+# [1,]  -0.89767388  1.01560199  -1.33575163 -1.3110521482
+# [2,]  -1.13920048 -0.13153881  -1.33575163 -1.3110521482
+# [3,]  -1.38072709  0.32731751  -1.39239929 -1.3110521482
+# [4,]  -1.50149039  0.09788935  -1.27910398 -1.3110521482
+# [5,]  -1.01843718  1.24503015  -1.33575163 -1.3110521482
+# [6,]  -0.53538397  1.93331463  -1.16580868 -1.0486667950
+# [7,]  -1.50149039  0.78617383  -1.33575163 -1.1798594716
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/data_normalization_standardization.md b/Desktop/open-source/R/documentation/data_normalization_standardization.md
new file mode 100644
index 00000000..b9de33e1
--- /dev/null
+++ b/Desktop/open-source/R/documentation/data_normalization_standardization.md
@@ -0,0 +1,394 @@
+
+
+``` r
+# normalization & standardization
+normalization<-function(x){
+  return((x-min(x))/(max(x)-min(x)))
+}
+
+standardization<-function(x){
+  return((x-mean(x))/sd(x))
+}
+
+head(iris)
+```
+
+```
+##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
+## 1          5.1         3.5          1.4         0.2  setosa
+## 2          4.9         3.0          1.4         0.2  setosa
+## 3          4.7         3.2          1.3         0.2  setosa
+## 4          4.6         3.1          1.5         0.2  setosa
+## 5          5.0         3.6          1.4         0.2  setosa
+## 6          5.4         3.9          1.7         0.4  setosa
+```
+
+``` r
+# Sepal.Length Sepal.Width Petal.Length Petal.Width Species
+# 1          5.1         3.5          1.4         0.2  setosa
+# 2          4.9         3.0          1.4         0.2  setosa
+# 3          4.7         3.2          1.3         0.2  setosa
+# 4          4.6         3.1          1.5         0.2  setosa
+# 5          5.0         3.6          1.4         0.2  setosa
+# 6          5.4         3.9          1.7         0.4  setosa
+
+iris<-iris[,-5]
+head(iris)
+```
+
+```
+##   Sepal.Length Sepal.Width Petal.Length Petal.Width
+## 1          5.1         3.5          1.4         0.2
+## 2          4.9         3.0          1.4         0.2
+## 3          4.7         3.2          1.3         0.2
+## 4          4.6         3.1          1.5         0.2
+## 5          5.0         3.6          1.4         0.2
+## 6          5.4         3.9          1.7         0.4
+```
+
+``` r
+# Sepal.Length Sepal.Width Petal.Length Petal.Width
+# 1          5.1         3.5          1.4         0.2
+# 2          4.9         3.0          1.4         0.2
+# 3          4.7         3.2          1.3         0.2
+# 4          4.6         3.1          1.5         0.2
+# 5          5.0         3.6          1.4         0.2
+# 6          5.4         3.9          1.7         0.4
+
+#normalize
+apply(as.matrix(iris),2,normalization)
+```
+
+```
+##        Sepal.Length Sepal.Width Petal.Length Petal.Width
+##   [1,]   0.22222222  0.62500000   0.06779661  0.04166667
+##   [2,]   0.16666667  0.41666667   0.06779661  0.04166667
+##   [3,]   0.11111111  0.50000000   0.05084746  0.04166667
+##   [4,]   0.08333333  0.45833333   0.08474576  0.04166667
+##   [5,]   0.19444444  0.66666667   0.06779661  0.04166667
+##   [6,]   0.30555556  0.79166667   0.11864407  0.12500000
+##   [7,]   0.08333333  0.58333333   0.06779661  0.08333333
+##   [8,]   0.19444444  0.58333333   0.08474576  0.04166667
+##   [9,]   0.02777778  0.37500000   0.06779661  0.04166667
+##  [10,]   0.16666667  0.45833333   0.08474576  0.00000000
+##  [11,]   0.30555556  0.70833333   0.08474576  0.04166667
+##  [12,]   0.13888889  0.58333333   0.10169492  0.04166667
+##  [13,]   0.13888889  0.41666667   0.06779661  0.00000000
+##  [14,]   0.00000000  0.41666667   0.01694915  0.00000000
+##  [15,]   0.41666667  0.83333333   0.03389831  0.04166667
+##  [16,]   0.38888889  1.00000000   0.08474576  0.12500000
+##  [17,]   0.30555556  0.79166667   0.05084746  0.12500000
+##  [18,]   0.22222222  0.62500000   0.06779661  0.08333333
+##  [19,]   0.38888889  0.75000000   0.11864407  0.08333333
+##  [20,]   0.22222222  0.75000000   0.08474576  0.08333333
+##  [21,]   0.30555556  0.58333333   0.11864407  0.04166667
+##  [22,]   0.22222222  0.70833333   0.08474576  0.12500000
+##  [23,]   0.08333333  0.66666667   0.00000000  0.04166667
+##  [24,]   0.22222222  0.54166667   0.11864407  0.16666667
+##  [25,]   0.13888889  0.58333333   0.15254237  0.04166667
+##  [26,]   0.19444444  0.41666667   0.10169492  0.04166667
+##  [27,]   0.19444444  0.58333333   0.10169492  0.12500000
+##  [28,]   0.25000000  0.62500000   0.08474576  0.04166667
+##  [29,]   0.25000000  0.58333333   0.06779661  0.04166667
+##  [30,]   0.11111111  0.50000000   0.10169492  0.04166667
+##  [31,]   0.13888889  0.45833333   0.10169492  0.04166667
+##  [32,]   0.30555556  0.58333333   0.08474576  0.12500000
+##  [33,]   0.25000000  0.87500000   0.08474576  0.00000000
+##  [34,]   0.33333333  0.91666667   0.06779661  0.04166667
+##  [35,]   0.16666667  0.45833333   0.08474576  0.04166667
+##  [36,]   0.19444444  0.50000000   0.03389831  0.04166667
+##  [37,]   0.33333333  0.62500000   0.05084746  0.04166667
+##  [38,]   0.16666667  0.66666667   0.06779661  0.00000000
+##  [39,]   0.02777778  0.41666667   0.05084746  0.04166667
+##  [40,]   0.22222222  0.58333333   0.08474576  0.04166667
+##  [41,]   0.19444444  0.62500000   0.05084746  0.08333333
+##  [42,]   0.05555556  0.12500000   0.05084746  0.08333333
+##  [43,]   0.02777778  0.50000000   0.05084746  0.04166667
+##  [44,]   0.19444444  0.62500000   0.10169492  0.20833333
+##  [45,]   0.22222222  0.75000000   0.15254237  0.12500000
+##  [46,]   0.13888889  0.41666667   0.06779661  0.08333333
+##  [47,]   0.22222222  0.75000000   0.10169492  0.04166667
+##  [48,]   0.08333333  0.50000000   0.06779661  0.04166667
+##  [49,]   0.27777778  0.70833333   0.08474576  0.04166667
+##  [50,]   0.19444444  0.54166667   0.06779661  0.04166667
+##  [51,]   0.75000000  0.50000000   0.62711864  0.54166667
+##  [52,]   0.58333333  0.50000000   0.59322034  0.58333333
+##  [53,]   0.72222222  0.45833333   0.66101695  0.58333333
+##  [54,]   0.33333333  0.12500000   0.50847458  0.50000000
+##  [55,]   0.61111111  0.33333333   0.61016949  0.58333333
+##  [56,]   0.38888889  0.33333333   0.59322034  0.50000000
+##  [57,]   0.55555556  0.54166667   0.62711864  0.62500000
+##  [58,]   0.16666667  0.16666667   0.38983051  0.37500000
+##  [59,]   0.63888889  0.37500000   0.61016949  0.50000000
+##  [60,]   0.25000000  0.29166667   0.49152542  0.54166667
+##  [61,]   0.19444444  0.00000000   0.42372881  0.37500000
+##  [62,]   0.44444444  0.41666667   0.54237288  0.58333333
+##  [63,]   0.47222222  0.08333333   0.50847458  0.37500000
+##  [64,]   0.50000000  0.37500000   0.62711864  0.54166667
+##  [65,]   0.36111111  0.37500000   0.44067797  0.50000000
+##  [66,]   0.66666667  0.45833333   0.57627119  0.54166667
+##  [67,]   0.36111111  0.41666667   0.59322034  0.58333333
+##  [68,]   0.41666667  0.29166667   0.52542373  0.37500000
+##  [69,]   0.52777778  0.08333333   0.59322034  0.58333333
+##  [70,]   0.36111111  0.20833333   0.49152542  0.41666667
+##  [71,]   0.44444444  0.50000000   0.64406780  0.70833333
+##  [72,]   0.50000000  0.33333333   0.50847458  0.50000000
+##  [73,]   0.55555556  0.20833333   0.66101695  0.58333333
+##  [74,]   0.50000000  0.33333333   0.62711864  0.45833333
+##  [75,]   0.58333333  0.37500000   0.55932203  0.50000000
+##  [76,]   0.63888889  0.41666667   0.57627119  0.54166667
+##  [77,]   0.69444444  0.33333333   0.64406780  0.54166667
+##  [78,]   0.66666667  0.41666667   0.67796610  0.66666667
+##  [79,]   0.47222222  0.37500000   0.59322034  0.58333333
+##  [80,]   0.38888889  0.25000000   0.42372881  0.37500000
+##  [81,]   0.33333333  0.16666667   0.47457627  0.41666667
+##  [82,]   0.33333333  0.16666667   0.45762712  0.37500000
+##  [83,]   0.41666667  0.29166667   0.49152542  0.45833333
+##  [84,]   0.47222222  0.29166667   0.69491525  0.62500000
+##  [85,]   0.30555556  0.41666667   0.59322034  0.58333333
+##  [86,]   0.47222222  0.58333333   0.59322034  0.62500000
+##  [87,]   0.66666667  0.45833333   0.62711864  0.58333333
+##  [88,]   0.55555556  0.12500000   0.57627119  0.50000000
+##  [89,]   0.36111111  0.41666667   0.52542373  0.50000000
+##  [90,]   0.33333333  0.20833333   0.50847458  0.50000000
+##  [91,]   0.33333333  0.25000000   0.57627119  0.45833333
+##  [92,]   0.50000000  0.41666667   0.61016949  0.54166667
+##  [93,]   0.41666667  0.25000000   0.50847458  0.45833333
+##  [94,]   0.19444444  0.12500000   0.38983051  0.37500000
+##  [95,]   0.36111111  0.29166667   0.54237288  0.50000000
+##  [96,]   0.38888889  0.41666667   0.54237288  0.45833333
+##  [97,]   0.38888889  0.37500000   0.54237288  0.50000000
+##  [98,]   0.52777778  0.37500000   0.55932203  0.50000000
+##  [99,]   0.22222222  0.20833333   0.33898305  0.41666667
+## [100,]   0.38888889  0.33333333   0.52542373  0.50000000
+## [101,]   0.55555556  0.54166667   0.84745763  1.00000000
+## [102,]   0.41666667  0.29166667   0.69491525  0.75000000
+## [103,]   0.77777778  0.41666667   0.83050847  0.83333333
+## [104,]   0.55555556  0.37500000   0.77966102  0.70833333
+## [105,]   0.61111111  0.41666667   0.81355932  0.87500000
+## [106,]   0.91666667  0.41666667   0.94915254  0.83333333
+## [107,]   0.16666667  0.20833333   0.59322034  0.66666667
+## [108,]   0.83333333  0.37500000   0.89830508  0.70833333
+## [109,]   0.66666667  0.20833333   0.81355932  0.70833333
+## [110,]   0.80555556  0.66666667   0.86440678  1.00000000
+## [111,]   0.61111111  0.50000000   0.69491525  0.79166667
+## [112,]   0.58333333  0.29166667   0.72881356  0.75000000
+## [113,]   0.69444444  0.41666667   0.76271186  0.83333333
+## [114,]   0.38888889  0.20833333   0.67796610  0.79166667
+## [115,]   0.41666667  0.33333333   0.69491525  0.95833333
+## [116,]   0.58333333  0.50000000   0.72881356  0.91666667
+## [117,]   0.61111111  0.41666667   0.76271186  0.70833333
+## [118,]   0.94444444  0.75000000   0.96610169  0.87500000
+## [119,]   0.94444444  0.25000000   1.00000000  0.91666667
+## [120,]   0.47222222  0.08333333   0.67796610  0.58333333
+## [121,]   0.72222222  0.50000000   0.79661017  0.91666667
+## [122,]   0.36111111  0.33333333   0.66101695  0.79166667
+## [123,]   0.94444444  0.33333333   0.96610169  0.79166667
+## [124,]   0.55555556  0.29166667   0.66101695  0.70833333
+## [125,]   0.66666667  0.54166667   0.79661017  0.83333333
+## [126,]   0.80555556  0.50000000   0.84745763  0.70833333
+## [127,]   0.52777778  0.33333333   0.64406780  0.70833333
+## [128,]   0.50000000  0.41666667   0.66101695  0.70833333
+## [129,]   0.58333333  0.33333333   0.77966102  0.83333333
+## [130,]   0.80555556  0.41666667   0.81355932  0.62500000
+## [131,]   0.86111111  0.33333333   0.86440678  0.75000000
+## [132,]   1.00000000  0.75000000   0.91525424  0.79166667
+## [133,]   0.58333333  0.33333333   0.77966102  0.87500000
+## [134,]   0.55555556  0.33333333   0.69491525  0.58333333
+## [135,]   0.50000000  0.25000000   0.77966102  0.54166667
+## [136,]   0.94444444  0.41666667   0.86440678  0.91666667
+## [137,]   0.55555556  0.58333333   0.77966102  0.95833333
+## [138,]   0.58333333  0.45833333   0.76271186  0.70833333
+## [139,]   0.47222222  0.41666667   0.64406780  0.70833333
+## [140,]   0.72222222  0.45833333   0.74576271  0.83333333
+## [141,]   0.66666667  0.45833333   0.77966102  0.95833333
+## [142,]   0.72222222  0.45833333   0.69491525  0.91666667
+## [143,]   0.41666667  0.29166667   0.69491525  0.75000000
+## [144,]   0.69444444  0.50000000   0.83050847  0.91666667
+## [145,]   0.66666667  0.54166667   0.79661017  1.00000000
+## [146,]   0.66666667  0.41666667   0.71186441  0.91666667
+## [147,]   0.55555556  0.20833333   0.67796610  0.75000000
+## [148,]   0.61111111  0.41666667   0.71186441  0.79166667
+## [149,]   0.52777778  0.58333333   0.74576271  0.91666667
+## [150,]   0.44444444  0.41666667   0.69491525  0.70833333
+```
+
+``` r
+# Sepal.Length Sepal.Width Petal.Length Petal.Width
+# [1,]   0.22222222  0.62500000   0.06779661  0.04166667
+# [2,]   0.16666667  0.41666667   0.06779661  0.04166667
+# [3,]   0.11111111  0.50000000   0.05084746  0.04166667
+# [4,]   0.08333333  0.45833333   0.08474576  0.04166667
+# [5,]   0.19444444  0.66666667   0.06779661  0.04166667
+# [6,]   0.30555556  0.79166667   0.11864407  0.12500000
+# [7,]   0.08333333  0.58333333   0.06779661  0.08333333
+
+#standardize
+apply(as.matrix(iris),2,standardization)
+```
+
+```
+##        Sepal.Length Sepal.Width Petal.Length   Petal.Width
+##   [1,]  -0.89767388  1.01560199  -1.33575163 -1.3110521482
+##   [2,]  -1.13920048 -0.13153881  -1.33575163 -1.3110521482
+##   [3,]  -1.38072709  0.32731751  -1.39239929 -1.3110521482
+##   [4,]  -1.50149039  0.09788935  -1.27910398 -1.3110521482
+##   [5,]  -1.01843718  1.24503015  -1.33575163 -1.3110521482
+##   [6,]  -0.53538397  1.93331463  -1.16580868 -1.0486667950
+##   [7,]  -1.50149039  0.78617383  -1.33575163 -1.1798594716
+##   [8,]  -1.01843718  0.78617383  -1.27910398 -1.3110521482
+##   [9,]  -1.74301699 -0.36096697  -1.33575163 -1.3110521482
+##  [10,]  -1.13920048  0.09788935  -1.27910398 -1.4422448248
+##  [11,]  -0.53538397  1.47445831  -1.27910398 -1.3110521482
+##  [12,]  -1.25996379  0.78617383  -1.22245633 -1.3110521482
+##  [13,]  -1.25996379 -0.13153881  -1.33575163 -1.4422448248
+##  [14,]  -1.86378030 -0.13153881  -1.50569459 -1.4422448248
+##  [15,]  -0.05233076  2.16274279  -1.44904694 -1.3110521482
+##  [16,]  -0.17309407  3.08045544  -1.27910398 -1.0486667950
+##  [17,]  -0.53538397  1.93331463  -1.39239929 -1.0486667950
+##  [18,]  -0.89767388  1.01560199  -1.33575163 -1.1798594716
+##  [19,]  -0.17309407  1.70388647  -1.16580868 -1.1798594716
+##  [20,]  -0.89767388  1.70388647  -1.27910398 -1.1798594716
+##  [21,]  -0.53538397  0.78617383  -1.16580868 -1.3110521482
+##  [22,]  -0.89767388  1.47445831  -1.27910398 -1.0486667950
+##  [23,]  -1.50149039  1.24503015  -1.56234224 -1.3110521482
+##  [24,]  -0.89767388  0.55674567  -1.16580868 -0.9174741184
+##  [25,]  -1.25996379  0.78617383  -1.05251337 -1.3110521482
+##  [26,]  -1.01843718 -0.13153881  -1.22245633 -1.3110521482
+##  [27,]  -1.01843718  0.78617383  -1.22245633 -1.0486667950
+##  [28,]  -0.77691058  1.01560199  -1.27910398 -1.3110521482
+##  [29,]  -0.77691058  0.78617383  -1.33575163 -1.3110521482
+##  [30,]  -1.38072709  0.32731751  -1.22245633 -1.3110521482
+##  [31,]  -1.25996379  0.09788935  -1.22245633 -1.3110521482
+##  [32,]  -0.53538397  0.78617383  -1.27910398 -1.0486667950
+##  [33,]  -0.77691058  2.39217095  -1.27910398 -1.4422448248
+##  [34,]  -0.41462067  2.62159911  -1.33575163 -1.3110521482
+##  [35,]  -1.13920048  0.09788935  -1.27910398 -1.3110521482
+##  [36,]  -1.01843718  0.32731751  -1.44904694 -1.3110521482
+##  [37,]  -0.41462067  1.01560199  -1.39239929 -1.3110521482
+##  [38,]  -1.13920048  1.24503015  -1.33575163 -1.4422448248
+##  [39,]  -1.74301699 -0.13153881  -1.39239929 -1.3110521482
+##  [40,]  -0.89767388  0.78617383  -1.27910398 -1.3110521482
+##  [41,]  -1.01843718  1.01560199  -1.39239929 -1.1798594716
+##  [42,]  -1.62225369 -1.73753594  -1.39239929 -1.1798594716
+##  [43,]  -1.74301699  0.32731751  -1.39239929 -1.3110521482
+##  [44,]  -1.01843718  1.01560199  -1.22245633 -0.7862814418
+##  [45,]  -0.89767388  1.70388647  -1.05251337 -1.0486667950
+##  [46,]  -1.25996379 -0.13153881  -1.33575163 -1.1798594716
+##  [47,]  -0.89767388  1.70388647  -1.22245633 -1.3110521482
+##  [48,]  -1.50149039  0.32731751  -1.33575163 -1.3110521482
+##  [49,]  -0.65614727  1.47445831  -1.27910398 -1.3110521482
+##  [50,]  -1.01843718  0.55674567  -1.33575163 -1.3110521482
+##  [51,]   1.39682886  0.32731751   0.53362088  0.2632599711
+##  [52,]   0.67224905  0.32731751   0.42032558  0.3944526477
+##  [53,]   1.27606556  0.09788935   0.64691619  0.3944526477
+##  [54,]  -0.41462067 -1.73753594   0.13708732  0.1320672944
+##  [55,]   0.79301235 -0.59039513   0.47697323  0.3944526477
+##  [56,]  -0.17309407 -0.59039513   0.42032558  0.1320672944
+##  [57,]   0.55148575  0.55674567   0.53362088  0.5256453243
+##  [58,]  -1.13920048 -1.50810778  -0.25944625 -0.2615107354
+##  [59,]   0.91377565 -0.36096697   0.47697323  0.1320672944
+##  [60,]  -0.77691058 -0.81982329   0.08043967  0.2632599711
+##  [61,]  -1.01843718 -2.42582042  -0.14615094 -0.2615107354
+##  [62,]   0.06843254 -0.13153881   0.25038262  0.3944526477
+##  [63,]   0.18919584 -1.96696410   0.13708732 -0.2615107354
+##  [64,]   0.30995914 -0.36096697   0.53362088  0.2632599711
+##  [65,]  -0.29385737 -0.36096697  -0.08950329  0.1320672944
+##  [66,]   1.03453895  0.09788935   0.36367793  0.2632599711
+##  [67,]  -0.29385737 -0.13153881   0.42032558  0.3944526477
+##  [68,]  -0.05233076 -0.81982329   0.19373497 -0.2615107354
+##  [69,]   0.43072244 -1.96696410   0.42032558  0.3944526477
+##  [70,]  -0.29385737 -1.27867961   0.08043967 -0.1303180588
+##  [71,]   0.06843254  0.32731751   0.59026853  0.7880306775
+##  [72,]   0.30995914 -0.59039513   0.13708732  0.1320672944
+##  [73,]   0.55148575 -1.27867961   0.64691619  0.3944526477
+##  [74,]   0.30995914 -0.59039513   0.53362088  0.0008746178
+##  [75,]   0.67224905 -0.36096697   0.30703027  0.1320672944
+##  [76,]   0.91377565 -0.13153881   0.36367793  0.2632599711
+##  [77,]   1.15530226 -0.59039513   0.59026853  0.2632599711
+##  [78,]   1.03453895 -0.13153881   0.70356384  0.6568380009
+##  [79,]   0.18919584 -0.36096697   0.42032558  0.3944526477
+##  [80,]  -0.17309407 -1.04925145  -0.14615094 -0.2615107354
+##  [81,]  -0.41462067 -1.50810778   0.02379201 -0.1303180588
+##  [82,]  -0.41462067 -1.50810778  -0.03285564 -0.2615107354
+##  [83,]  -0.05233076 -0.81982329   0.08043967  0.0008746178
+##  [84,]   0.18919584 -0.81982329   0.76021149  0.5256453243
+##  [85,]  -0.53538397 -0.13153881   0.42032558  0.3944526477
+##  [86,]   0.18919584  0.78617383   0.42032558  0.5256453243
+##  [87,]   1.03453895  0.09788935   0.53362088  0.3944526477
+##  [88,]   0.55148575 -1.73753594   0.36367793  0.1320672944
+##  [89,]  -0.29385737 -0.13153881   0.19373497  0.1320672944
+##  [90,]  -0.41462067 -1.27867961   0.13708732  0.1320672944
+##  [91,]  -0.41462067 -1.04925145   0.36367793  0.0008746178
+##  [92,]   0.30995914 -0.13153881   0.47697323  0.2632599711
+##  [93,]  -0.05233076 -1.04925145   0.13708732  0.0008746178
+##  [94,]  -1.01843718 -1.73753594  -0.25944625 -0.2615107354
+##  [95,]  -0.29385737 -0.81982329   0.25038262  0.1320672944
+##  [96,]  -0.17309407 -0.13153881   0.25038262  0.0008746178
+##  [97,]  -0.17309407 -0.36096697   0.25038262  0.1320672944
+##  [98,]   0.43072244 -0.36096697   0.30703027  0.1320672944
+##  [99,]  -0.89767388 -1.27867961  -0.42938920 -0.1303180588
+## [100,]  -0.17309407 -0.59039513   0.19373497  0.1320672944
+## [101,]   0.55148575  0.55674567   1.27004036  1.7063794137
+## [102,]  -0.05233076 -0.81982329   0.76021149  0.9192233541
+## [103,]   1.51759216 -0.13153881   1.21339271  1.1816087073
+## [104,]   0.55148575 -0.36096697   1.04344975  0.7880306775
+## [105,]   0.79301235 -0.13153881   1.15674505  1.3128013839
+## [106,]   2.12140867 -0.13153881   1.60992627  1.1816087073
+## [107,]  -1.13920048 -1.27867961   0.42032558  0.6568380009
+## [108,]   1.75911877 -0.36096697   1.43998331  0.7880306775
+## [109,]   1.03453895 -1.27867961   1.15674505  0.7880306775
+## [110,]   1.63835547  1.24503015   1.32668801  1.7063794137
+## [111,]   0.79301235  0.32731751   0.76021149  1.0504160307
+## [112,]   0.67224905 -0.81982329   0.87350679  0.9192233541
+## [113,]   1.15530226 -0.13153881   0.98680210  1.1816087073
+## [114,]  -0.17309407 -1.27867961   0.70356384  1.0504160307
+## [115,]  -0.05233076 -0.59039513   0.76021149  1.5751867371
+## [116,]   0.67224905  0.32731751   0.87350679  1.4439940605
+## [117,]   0.79301235 -0.13153881   0.98680210  0.7880306775
+## [118,]   2.24217198  1.70388647   1.66657392  1.3128013839
+## [119,]   2.24217198 -1.04925145   1.77986923  1.4439940605
+## [120,]   0.18919584 -1.96696410   0.70356384  0.3944526477
+## [121,]   1.27606556  0.32731751   1.10009740  1.4439940605
+## [122,]  -0.29385737 -0.59039513   0.64691619  1.0504160307
+## [123,]   2.24217198 -0.59039513   1.66657392  1.0504160307
+## [124,]   0.55148575 -0.81982329   0.64691619  0.7880306775
+## [125,]   1.03453895  0.55674567   1.10009740  1.1816087073
+## [126,]   1.63835547  0.32731751   1.27004036  0.7880306775
+## [127,]   0.43072244 -0.59039513   0.59026853  0.7880306775
+## [128,]   0.30995914 -0.13153881   0.64691619  0.7880306775
+## [129,]   0.67224905 -0.59039513   1.04344975  1.1816087073
+## [130,]   1.63835547 -0.13153881   1.15674505  0.5256453243
+## [131,]   1.87988207 -0.59039513   1.32668801  0.9192233541
+## [132,]   2.48369858  1.70388647   1.49663097  1.0504160307
+## [133,]   0.67224905 -0.59039513   1.04344975  1.3128013839
+## [134,]   0.55148575 -0.59039513   0.76021149  0.3944526477
+## [135,]   0.30995914 -1.04925145   1.04344975  0.2632599711
+## [136,]   2.24217198 -0.13153881   1.32668801  1.4439940605
+## [137,]   0.55148575  0.78617383   1.04344975  1.5751867371
+## [138,]   0.67224905  0.09788935   0.98680210  0.7880306775
+## [139,]   0.18919584 -0.13153881   0.59026853  0.7880306775
+## [140,]   1.27606556  0.09788935   0.93015445  1.1816087073
+## [141,]   1.03453895  0.09788935   1.04344975  1.5751867371
+## [142,]   1.27606556  0.09788935   0.76021149  1.4439940605
+## [143,]  -0.05233076 -0.81982329   0.76021149  0.9192233541
+## [144,]   1.15530226  0.32731751   1.21339271  1.4439940605
+## [145,]   1.03453895  0.55674567   1.10009740  1.7063794137
+## [146,]   1.03453895 -0.13153881   0.81685914  1.4439940605
+## [147,]   0.55148575 -1.27867961   0.70356384  0.9192233541
+## [148,]   0.79301235 -0.13153881   0.81685914  1.0504160307
+## [149,]   0.43072244  0.78617383   0.93015445  1.4439940605
+## [150,]   0.06843254 -0.13153881   0.76021149  0.7880306775
+```
+
+``` r
+# Sepal.Length Sepal.Width Petal.Length   Petal.Width
+# [1,]  -0.89767388  1.01560199  -1.33575163 -1.3110521482
+# [2,]  -1.13920048 -0.13153881  -1.33575163 -1.3110521482
+# [3,]  -1.38072709  0.32731751  -1.39239929 -1.3110521482
+# [4,]  -1.50149039  0.09788935  -1.27910398 -1.3110521482
+# [5,]  -1.01843718  1.24503015  -1.33575163 -1.3110521482
+# [6,]  -0.53538397  1.93331463  -1.16580868 -1.0486667950
+# [7,]  -1.50149039  0.78617383  -1.33575163 -1.1798594716
+```
+
diff --git a/Desktop/open-source/R/documentation/data_processing.html b/Desktop/open-source/R/documentation/data_processing.html
new file mode 100644
index 00000000..2d033dc7
--- /dev/null
+++ b/Desktop/open-source/R/documentation/data_processing.html
@@ -0,0 +1,358 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(xlsx)
+</code></pre>
+<pre><code>## Error in library(xlsx): there is no package called 'xlsx'
+</code></pre>
+<pre><code class="language-r">## Loading required package: rJava
+## Loading required package: xlsxjars
+
+setwd(&quot;/Users/chenfeiyang&quot;)
+</code></pre>
+<pre><code>## Error in setwd(&quot;/Users/chenfeiyang&quot;): cannot change working directory
+</code></pre>
+<pre><code class="language-r">cameraData &lt;- read.xlsx(&quot;./data/cameras.xlsx&quot;, sheetIndex = 1, header = TRUE)
+</code></pre>
+<pre><code>## Error in read.xlsx(&quot;./data/cameras.xlsx&quot;, sheetIndex = 1, header = TRUE): could not find function &quot;read.xlsx&quot;
+</code></pre>
+<pre><code class="language-r">cameraData &lt;- read.xlsx(&quot;./data/cameras.xlsx&quot;, &quot;Baltimore Fixed Speed Cameras&quot;, 
+    header = TRUE)
+</code></pre>
+<pre><code>## Error in read.xlsx(&quot;./data/cameras.xlsx&quot;, &quot;Baltimore Fixed Speed Cameras&quot;, : could not find function &quot;read.xlsx&quot;
+</code></pre>
+<pre><code class="language-r">head(cameraData)
+</code></pre>
+<pre><code>## Error in head(cameraData): object 'cameraData' not found
+</code></pre>
+<pre><code class="language-r">##                          address direction      street  crossStreet
+## 1       S CATON AVE &amp; BENSON AVE       N/B   Caton Ave   Benson Ave
+## 2       S CATON AVE &amp; BENSON AVE       S/B   Caton Ave   Benson Ave
+## 3 WILKENS AVE &amp; PINE HEIGHTS AVE       E/B Wilkens Ave Pine Heights
+## 4        THE ALAMEDA &amp; E 33RD ST       S/B The Alameda      33rd St
+## 5        E 33RD ST &amp; THE ALAMEDA       E/B      E 33rd  The Alameda
+## 6        ERDMAN AVE &amp; N MACON ST       E/B      Erdman     Macon St
+##                 intersection                      Location.1
+## 1     Caton Ave &amp; Benson Ave (39.2693779962, -76.6688185297)
+## 2     Caton Ave &amp; Benson Ave (39.2693157898, -76.6689698176)
+## 3 Wilkens Ave &amp; Pine Heights  (39.2720252302, -76.676960806)
+## 4     The Alameda  &amp; 33rd St (39.3285013141, -76.5953545714)
+## 5      E 33rd  &amp; The Alameda (39.3283410623, -76.5953594625)
+## 6         Erdman  &amp; Macon St (39.3068045671, -76.5593167803)
+
+# Read specific rows and columns in Excel
+colIndex &lt;- 2:3
+rowIndex &lt;- 1:4
+cameraDataSubset &lt;- read.xlsx(&quot;./data/cameras.xlsx&quot;, sheetIndex = 1, colIndex = colIndex, 
+    rowIndex = rowIndex)
+</code></pre>
+<pre><code>## Error in read.xlsx(&quot;./data/cameras.xlsx&quot;, sheetIndex = 1, colIndex = colIndex, : could not find function &quot;read.xlsx&quot;
+</code></pre>
+<pre><code class="language-r">cameraDataSubset
+</code></pre>
+<pre><code>## Error: object 'cameraDataSubset' not found
+</code></pre>
+<pre><code class="language-r">##   direction      street
+## 1       N/B   Caton Ave
+## 2       S/B   Caton Ave
+## 3       E/B Wilkens Ave
+
+# Subsetting - quick review
+set.seed(13435)
+X &lt;- data.frame(var1 = sample(1:5), var2 = sample(6:10), var3 = sample(11:15))
+X &lt;- X[sample(1:5), ]
+X$var2[c(1, 3)] = NA
+X
+</code></pre>
+<pre><code>##   var1 var2 var3
+## 5    2   NA   11
+## 4    4   10   12
+## 1    3   NA   14
+## 2    1    7   15
+## 3    5    6   13
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3
+## 1    2   NA   15
+## 4    1   10   11
+## 2    3   NA   12
+## 3    5    6   14
+## 5    4    9   13
+
+X[, 1]
+</code></pre>
+<pre><code>## [1] 2 4 3 1 5
+</code></pre>
+<pre><code class="language-r">## [1] 2 1 3 5 4
+X[, &quot;var1&quot;]
+</code></pre>
+<pre><code>## [1] 2 4 3 1 5
+</code></pre>
+<pre><code class="language-r">## [1] 2 1 3 5 4
+X[1:2, &quot;var2&quot;]
+</code></pre>
+<pre><code>## [1] NA 10
+</code></pre>
+<pre><code class="language-r">## [1] NA 10
+
+# Logicals and: &amp; , or: |
+X[(X$var1 &lt;= 3 &amp; X$var3 &gt; 11), ]
+</code></pre>
+<pre><code>##   var1 var2 var3
+## 1    3   NA   14
+## 2    1    7   15
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3
+## 1    2   NA   15
+## 2    3   NA   12
+X[(X$var1 &lt;= 3 | X$var3 &gt; 15), ]
+</code></pre>
+<pre><code>##   var1 var2 var3
+## 5    2   NA   11
+## 1    3   NA   14
+## 2    1    7   15
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3
+## 1    2   NA   15
+## 4    1   10   11
+## 2    3   NA   12
+
+## Dealing with missing values
+X[which(X$var2 &gt; 8), ]
+</code></pre>
+<pre><code>##   var1 var2 var3
+## 4    4   10   12
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3
+## 4    1   10   11
+## 5    4    9   13
+
+# Sorting
+sort(X$var1)
+</code></pre>
+<pre><code>## [1] 1 2 3 4 5
+</code></pre>
+<pre><code class="language-r">## [1] 1 2 3 4 5
+sort(X$var1, decreasing = TRUE)
+</code></pre>
+<pre><code>## [1] 5 4 3 2 1
+</code></pre>
+<pre><code class="language-r">## [1] 5 4 3 2 1
+sort(X$var2, na.last = TRUE)
+</code></pre>
+<pre><code>## [1]  6  7 10 NA NA
+</code></pre>
+<pre><code class="language-r">## [1]  6  9 10 NA NA
+
+# Ordering
+X[order(X$var1), ]
+</code></pre>
+<pre><code>##   var1 var2 var3
+## 2    1    7   15
+## 5    2   NA   11
+## 1    3   NA   14
+## 4    4   10   12
+## 3    5    6   13
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3
+## 4    1   10   11
+## 1    2   NA   15
+## 2    3   NA   12
+## 5    4    9   13
+## 3    5    6   14
+
+X[order(X$var1, X$var3), ]
+</code></pre>
+<pre><code>##   var1 var2 var3
+## 2    1    7   15
+## 5    2   NA   11
+## 1    3   NA   14
+## 4    4   10   12
+## 3    5    6   13
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3
+## 4    1   10   11
+## 1    2   NA   15
+## 2    3   NA   12
+## 5    4    9   13
+## 3    5    6   14
+
+## Sort using the arrange function of the plyr package
+
+library(plyr)
+</code></pre>
+<pre><code>## Error in library(plyr): there is no package called 'plyr'
+</code></pre>
+<pre><code class="language-r">arrange(X, var1)
+</code></pre>
+<pre><code>## Error in arrange(X, var1): could not find function &quot;arrange&quot;
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3
+## 1    1   10   11
+## 2    2   NA   15
+## 3    3   NA   12
+## 4    4    9   13
+## 5    5    6   14
+
+arrange(X, desc(var1))
+</code></pre>
+<pre><code>## Error in arrange(X, desc(var1)): could not find function &quot;arrange&quot;
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3
+## 1    5    6   14
+## 2    4    9   13
+## 3    3   NA   12
+## 4    2   NA   15
+## 5    1   10   11
+
+# Add row and column
+X$var4 &lt;- rnorm(5)
+X
+</code></pre>
+<pre><code>##   var1 var2 var3       var4
+## 5    2   NA   11 -0.4150458
+## 4    4   10   12  2.5437602
+## 1    3   NA   14  1.5545298
+## 2    1    7   15 -0.6192328
+## 3    5    6   13 -0.9261035
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3     var4
+## 1    2   NA   15  0.18760
+## 4    1   10   11  1.78698
+## 2    3   NA   12  0.49669
+## 3    5    6   14  0.06318
+## 5    4    9   13 -0.53613
+
+Y &lt;- cbind(X, rnorm(5))
+Y
+</code></pre>
+<pre><code>##   var1 var2 var3       var4    rnorm(5)
+## 5    2   NA   11 -0.4150458 -0.66549949
+## 4    4   10   12  2.5437602 -0.02166735
+## 1    3   NA   14  1.5545298 -0.17411953
+## 2    1    7   15 -0.6192328  0.23900438
+## 3    5    6   13 -0.9261035 -1.83245959
+</code></pre>
+<pre><code class="language-r">##   var1 var2 var3     var4 rnorm(5)
+## 1    2   NA   15  0.18760  0.62578
+## 4    1   10   11  1.78698 -2.45084
+## 2    3   NA   12  0.49669  0.08909
+## 3    5    6   14  0.06318  0.47839
+## 5    4    9   13 -0.53613  1.00053
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/data_processing.md b/Desktop/open-source/R/documentation/data_processing.md
new file mode 100644
index 00000000..458d1251
--- /dev/null
+++ b/Desktop/open-source/R/documentation/data_processing.md
@@ -0,0 +1,338 @@
+
+
+``` r
+library(xlsx)
+```
+
+```
+## Error in library(xlsx): there is no package called 'xlsx'
+```
+
+``` r
+## Loading required package: rJava
+## Loading required package: xlsxjars
+
+setwd("/Users/chenfeiyang")
+```
+
+```
+## Error in setwd("/Users/chenfeiyang"): cannot change working directory
+```
+
+``` r
+cameraData <- read.xlsx("./data/cameras.xlsx", sheetIndex = 1, header = TRUE)
+```
+
+```
+## Error in read.xlsx("./data/cameras.xlsx", sheetIndex = 1, header = TRUE): could not find function "read.xlsx"
+```
+
+``` r
+cameraData <- read.xlsx("./data/cameras.xlsx", "Baltimore Fixed Speed Cameras", 
+    header = TRUE)
+```
+
+```
+## Error in read.xlsx("./data/cameras.xlsx", "Baltimore Fixed Speed Cameras", : could not find function "read.xlsx"
+```
+
+``` r
+head(cameraData)
+```
+
+```
+## Error in head(cameraData): object 'cameraData' not found
+```
+
+``` r
+##                          address direction      street  crossStreet
+## 1       S CATON AVE & BENSON AVE       N/B   Caton Ave   Benson Ave
+## 2       S CATON AVE & BENSON AVE       S/B   Caton Ave   Benson Ave
+## 3 WILKENS AVE & PINE HEIGHTS AVE       E/B Wilkens Ave Pine Heights
+## 4        THE ALAMEDA & E 33RD ST       S/B The Alameda      33rd St
+## 5        E 33RD ST & THE ALAMEDA       E/B      E 33rd  The Alameda
+## 6        ERDMAN AVE & N MACON ST       E/B      Erdman     Macon St
+##                 intersection                      Location.1
+## 1     Caton Ave & Benson Ave (39.2693779962, -76.6688185297)
+## 2     Caton Ave & Benson Ave (39.2693157898, -76.6689698176)
+## 3 Wilkens Ave & Pine Heights  (39.2720252302, -76.676960806)
+## 4     The Alameda  & 33rd St (39.3285013141, -76.5953545714)
+## 5      E 33rd  & The Alameda (39.3283410623, -76.5953594625)
+## 6         Erdman  & Macon St (39.3068045671, -76.5593167803)
+
+# Read specific rows and columns in Excel
+colIndex <- 2:3
+rowIndex <- 1:4
+cameraDataSubset <- read.xlsx("./data/cameras.xlsx", sheetIndex = 1, colIndex = colIndex, 
+    rowIndex = rowIndex)
+```
+
+```
+## Error in read.xlsx("./data/cameras.xlsx", sheetIndex = 1, colIndex = colIndex, : could not find function "read.xlsx"
+```
+
+``` r
+cameraDataSubset
+```
+
+```
+## Error: object 'cameraDataSubset' not found
+```
+
+``` r
+##   direction      street
+## 1       N/B   Caton Ave
+## 2       S/B   Caton Ave
+## 3       E/B Wilkens Ave
+
+# Subsetting - quick review
+set.seed(13435)
+X <- data.frame(var1 = sample(1:5), var2 = sample(6:10), var3 = sample(11:15))
+X <- X[sample(1:5), ]
+X$var2[c(1, 3)] = NA
+X
+```
+
+```
+##   var1 var2 var3
+## 5    2   NA   11
+## 4    4   10   12
+## 1    3   NA   14
+## 2    1    7   15
+## 3    5    6   13
+```
+
+``` r
+##   var1 var2 var3
+## 1    2   NA   15
+## 4    1   10   11
+## 2    3   NA   12
+## 3    5    6   14
+## 5    4    9   13
+
+X[, 1]
+```
+
+```
+## [1] 2 4 3 1 5
+```
+
+``` r
+## [1] 2 1 3 5 4
+X[, "var1"]
+```
+
+```
+## [1] 2 4 3 1 5
+```
+
+``` r
+## [1] 2 1 3 5 4
+X[1:2, "var2"]
+```
+
+```
+## [1] NA 10
+```
+
+``` r
+## [1] NA 10
+
+# Logicals and: & , or: |
+X[(X$var1 <= 3 & X$var3 > 11), ]
+```
+
+```
+##   var1 var2 var3
+## 1    3   NA   14
+## 2    1    7   15
+```
+
+``` r
+##   var1 var2 var3
+## 1    2   NA   15
+## 2    3   NA   12
+X[(X$var1 <= 3 | X$var3 > 15), ]
+```
+
+```
+##   var1 var2 var3
+## 5    2   NA   11
+## 1    3   NA   14
+## 2    1    7   15
+```
+
+``` r
+##   var1 var2 var3
+## 1    2   NA   15
+## 4    1   10   11
+## 2    3   NA   12
+
+## Dealing with missing values
+X[which(X$var2 > 8), ]
+```
+
+```
+##   var1 var2 var3
+## 4    4   10   12
+```
+
+``` r
+##   var1 var2 var3
+## 4    1   10   11
+## 5    4    9   13
+
+# Sorting
+sort(X$var1)
+```
+
+```
+## [1] 1 2 3 4 5
+```
+
+``` r
+## [1] 1 2 3 4 5
+sort(X$var1, decreasing = TRUE)
+```
+
+```
+## [1] 5 4 3 2 1
+```
+
+``` r
+## [1] 5 4 3 2 1
+sort(X$var2, na.last = TRUE)
+```
+
+```
+## [1]  6  7 10 NA NA
+```
+
+``` r
+## [1]  6  9 10 NA NA
+
+# Ordering
+X[order(X$var1), ]
+```
+
+```
+##   var1 var2 var3
+## 2    1    7   15
+## 5    2   NA   11
+## 1    3   NA   14
+## 4    4   10   12
+## 3    5    6   13
+```
+
+``` r
+##   var1 var2 var3
+## 4    1   10   11
+## 1    2   NA   15
+## 2    3   NA   12
+## 5    4    9   13
+## 3    5    6   14
+
+X[order(X$var1, X$var3), ]
+```
+
+```
+##   var1 var2 var3
+## 2    1    7   15
+## 5    2   NA   11
+## 1    3   NA   14
+## 4    4   10   12
+## 3    5    6   13
+```
+
+``` r
+##   var1 var2 var3
+## 4    1   10   11
+## 1    2   NA   15
+## 2    3   NA   12
+## 5    4    9   13
+## 3    5    6   14
+
+## Sort using the arrange function of the plyr package
+
+library(plyr)
+```
+
+```
+## Error in library(plyr): there is no package called 'plyr'
+```
+
+``` r
+arrange(X, var1)
+```
+
+```
+## Error in arrange(X, var1): could not find function "arrange"
+```
+
+``` r
+##   var1 var2 var3
+## 1    1   10   11
+## 2    2   NA   15
+## 3    3   NA   12
+## 4    4    9   13
+## 5    5    6   14
+
+arrange(X, desc(var1))
+```
+
+```
+## Error in arrange(X, desc(var1)): could not find function "arrange"
+```
+
+``` r
+##   var1 var2 var3
+## 1    5    6   14
+## 2    4    9   13
+## 3    3   NA   12
+## 4    2   NA   15
+## 5    1   10   11
+
+# Add row and column
+X$var4 <- rnorm(5)
+X
+```
+
+```
+##   var1 var2 var3       var4
+## 5    2   NA   11 -0.4150458
+## 4    4   10   12  2.5437602
+## 1    3   NA   14  1.5545298
+## 2    1    7   15 -0.6192328
+## 3    5    6   13 -0.9261035
+```
+
+``` r
+##   var1 var2 var3     var4
+## 1    2   NA   15  0.18760
+## 4    1   10   11  1.78698
+## 2    3   NA   12  0.49669
+## 3    5    6   14  0.06318
+## 5    4    9   13 -0.53613
+
+Y <- cbind(X, rnorm(5))
+Y
+```
+
+```
+##   var1 var2 var3       var4    rnorm(5)
+## 5    2   NA   11 -0.4150458 -0.66549949
+## 4    4   10   12  2.5437602 -0.02166735
+## 1    3   NA   14  1.5545298 -0.17411953
+## 2    1    7   15 -0.6192328  0.23900438
+## 3    5    6   13 -0.9261035 -1.83245959
+```
+
+``` r
+##   var1 var2 var3     var4 rnorm(5)
+## 1    2   NA   15  0.18760  0.62578
+## 4    1   10   11  1.78698 -2.45084
+## 2    3   NA   12  0.49669  0.08909
+## 3    5    6   14  0.06318  0.47839
+## 5    4    9   13 -0.53613  1.00053
+```
+
diff --git a/Desktop/open-source/R/documentation/dbscan_clustering.html b/Desktop/open-source/R/documentation/dbscan_clustering.html
new file mode 100644
index 00000000..c34e6083
--- /dev/null
+++ b/Desktop/open-source/R/documentation/dbscan_clustering.html
@@ -0,0 +1,132 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(dbscan)
+</code></pre>
+<pre><code>## Error in library(dbscan): there is no package called 'dbscan'
+</code></pre>
+<pre><code class="language-r">cl &lt;- dbscan(iris[,-5], eps = .5, minPts = 5)
+</code></pre>
+<pre><code>## Error in dbscan(iris[, -5], eps = 0.5, minPts = 5): could not find function &quot;dbscan&quot;
+</code></pre>
+<pre><code class="language-r">plot(iris[,-5], col = cl$cluster)
+</code></pre>
+<pre><code>## Error in pairs.default(data.matrix(x), ...): object 'cl' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/dbscan_clustering.md b/Desktop/open-source/R/documentation/dbscan_clustering.md
new file mode 100644
index 00000000..a082d545
--- /dev/null
+++ b/Desktop/open-source/R/documentation/dbscan_clustering.md
@@ -0,0 +1,26 @@
+
+
+``` r
+library(dbscan)
+```
+
+```
+## Error in library(dbscan): there is no package called 'dbscan'
+```
+
+``` r
+cl <- dbscan(iris[,-5], eps = .5, minPts = 5)
+```
+
+```
+## Error in dbscan(iris[, -5], eps = 0.5, minPts = 5): could not find function "dbscan"
+```
+
+``` r
+plot(iris[,-5], col = cl$cluster)
+```
+
+```
+## Error in pairs.default(data.matrix(x), ...): object 'cl' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/decision_tree.html b/Desktop/open-source/R/documentation/decision_tree.html
new file mode 100644
index 00000000..85037ff5
--- /dev/null
+++ b/Desktop/open-source/R/documentation/decision_tree.html
@@ -0,0 +1,139 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(rpart)
+x &lt;- cbind(x_train,y_train)
+</code></pre>
+<pre><code>## Error in cbind(x_train, y_train): object 'x_train' not found
+</code></pre>
+<pre><code class="language-r"># grow tree 
+fit &lt;- rpart(y_train ~ ., data = x,method=&quot;class&quot;)
+</code></pre>
+<pre><code>## Error in model.frame.default(formula = y_train ~ ., data = x, na.action = function (x) : 'data' must be a data.frame, environment, or list
+</code></pre>
+<pre><code class="language-r">summary(fit)
+</code></pre>
+<pre><code>## Error in summary(fit): object 'fit' not found
+</code></pre>
+<pre><code class="language-r"># Predict Output 
+predicted= predict(fit,x_test)
+</code></pre>
+<pre><code>## Error in predict(fit, x_test): object 'fit' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/decision_tree.md b/Desktop/open-source/R/documentation/decision_tree.md
new file mode 100644
index 00000000..de23c9ce
--- /dev/null
+++ b/Desktop/open-source/R/documentation/decision_tree.md
@@ -0,0 +1,37 @@
+
+
+``` r
+library(rpart)
+x <- cbind(x_train,y_train)
+```
+
+```
+## Error in cbind(x_train, y_train): object 'x_train' not found
+```
+
+``` r
+# grow tree 
+fit <- rpart(y_train ~ ., data = x,method="class")
+```
+
+```
+## Error in model.frame.default(formula = y_train ~ ., data = x, na.action = function (x) : 'data' must be a data.frame, environment, or list
+```
+
+``` r
+summary(fit)
+```
+
+```
+## Error in summary(fit): object 'fit' not found
+```
+
+``` r
+# Predict Output 
+predicted= predict(fit,x_test)
+```
+
+```
+## Error in predict(fit, x_test): object 'fit' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/depth_first_search.html b/Desktop/open-source/R/documentation/depth_first_search.html
new file mode 100644
index 00000000..aed783ef
--- /dev/null
+++ b/Desktop/open-source/R/documentation/depth_first_search.html
@@ -0,0 +1,309 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Depth-First Search (DFS) Algorithm
+# 
+# DFS is a graph traversal algorithm that explores as far as possible along each branch
+# before backtracking. It uses a stack data structure (implemented via recursion here).
+#
+# Time Complexity: O(V + E) where V is vertices and E is edges
+# Space Complexity: O(V) for the visited array and recursion stack
+#
+# Input: An adjacency list representation of a graph and a starting vertex
+# Output: The order in which vertices are visited during DFS traversal
+
+# Recursive DFS function
+dfs_recursive &lt;- function(graph, vertex, visited, result) {
+  # Mark current vertex as visited
+  visited[vertex] &lt;- TRUE
+  result &lt;- c(result, vertex)
+  
+  # Visit all unvisited adjacent vertices
+  if (vertex %in% names(graph)) {
+    for (neighbor in graph[[as.character(vertex)]]) {
+      if (!visited[neighbor]) {
+        result &lt;- dfs_recursive(graph, neighbor, visited, result)
+      }
+    }
+  }
+  
+  return(result)
+}
+
+# Main DFS function
+depth_first_search &lt;- function(graph, start_vertex) {
+  # Get all vertices in the graph
+  all_vertices &lt;- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array
+  visited &lt;- rep(FALSE, max(all_vertices))
+  names(visited) &lt;- 1:max(all_vertices)
+  
+  # Perform DFS starting from the given vertex
+  result &lt;- dfs_recursive(graph, start_vertex, visited, c())
+  
+  return(result)
+}
+
+# Iterative DFS function using explicit stack
+dfs_iterative &lt;- function(graph, start_vertex) {
+  # Get all vertices in the graph
+  all_vertices &lt;- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array and stack
+  visited &lt;- rep(FALSE, max(all_vertices))
+  names(visited) &lt;- 1:max(all_vertices)
+  stack &lt;- c(start_vertex)
+  result &lt;- c()
+  
+  while (length(stack) &gt; 0) {
+    # Pop vertex from stack
+    vertex &lt;- stack[length(stack)]
+    stack &lt;- stack[-length(stack)]
+    
+    if (!visited[vertex]) {
+      # Mark as visited and add to result
+      visited[vertex] &lt;- TRUE
+      result &lt;- c(result, vertex)
+      
+      # Add all unvisited neighbors to stack (in reverse order to maintain left-to-right traversal)
+      if (as.character(vertex) %in% names(graph)) {
+        neighbors &lt;- graph[[as.character(vertex)]]
+        for (neighbor in rev(neighbors)) {
+          if (!visited[neighbor]) {
+            stack &lt;- c(stack, neighbor)
+          }
+        }
+      }
+    }
+  }
+  
+  return(result)
+}
+
+# Example usage and testing
+cat(&quot;=== Depth-First Search (DFS) Algorithm ===\n&quot;)
+</code></pre>
+<pre><code>## === Depth-First Search (DFS) Algorithm ===
+</code></pre>
+<pre><code class="language-r"># Create a sample graph as adjacency list
+# Graph structure:
+#     1
+#    / \
+#   2   3
+#  / \   \
+# 4   5   6
+graph &lt;- list(
+  &quot;1&quot; = c(2, 3),
+  &quot;2&quot; = c(4, 5),
+  &quot;3&quot; = c(6),
+  &quot;4&quot; = c(),
+  &quot;5&quot; = c(),
+  &quot;6&quot; = c()
+)
+
+cat(&quot;Graph structure (adjacency list):\n&quot;)
+</code></pre>
+<pre><code>## Graph structure (adjacency list):
+</code></pre>
+<pre><code class="language-r">for (vertex in names(graph)) {
+  cat(&quot;Vertex&quot;, vertex, &quot;-&gt; [&quot;, paste(graph[[vertex]], collapse = &quot;, &quot;), &quot;]\n&quot;)
+}
+</code></pre>
+<pre><code>## Vertex 1 -&gt; [ 2, 3 ]
+## Vertex 2 -&gt; [ 4, 5 ]
+## Vertex 3 -&gt; [ 6 ]
+## Vertex 4 -&gt; [  ]
+## Vertex 5 -&gt; [  ]
+## Vertex 6 -&gt; [  ]
+</code></pre>
+<pre><code class="language-r"># Test recursive DFS
+cat(&quot;\nRecursive DFS starting from vertex 1:\n&quot;)
+</code></pre>
+<pre><code>## 
+## Recursive DFS starting from vertex 1:
+</code></pre>
+<pre><code class="language-r">result_recursive &lt;- depth_first_search(graph, 1)
+cat(&quot;Traversal order:&quot;, paste(result_recursive, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Traversal order: 1 -&gt; 2 -&gt; 4 -&gt; 5 -&gt; 3 -&gt; 6
+</code></pre>
+<pre><code class="language-r"># Test iterative DFS
+cat(&quot;\nIterative DFS starting from vertex 1:\n&quot;)
+</code></pre>
+<pre><code>## 
+## Iterative DFS starting from vertex 1:
+</code></pre>
+<pre><code class="language-r">result_iterative &lt;- dfs_iterative(graph, 1)
+cat(&quot;Traversal order:&quot;, paste(result_iterative, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Traversal order: 1 -&gt; 2 -&gt; 4 -&gt; 5 -&gt; 3 -&gt; 6
+</code></pre>
+<pre><code class="language-r"># Test with different starting vertex
+cat(&quot;\nRecursive DFS starting from vertex 2:\n&quot;)
+</code></pre>
+<pre><code>## 
+## Recursive DFS starting from vertex 2:
+</code></pre>
+<pre><code class="language-r">result_from_2 &lt;- depth_first_search(graph, 2)
+cat(&quot;Traversal order:&quot;, paste(result_from_2, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Traversal order: 2 -&gt; 4 -&gt; 5
+</code></pre>
+<pre><code class="language-r"># Example with a more complex graph (with cycles)
+cat(&quot;\n=== Example with Cyclic Graph ===\n&quot;)
+</code></pre>
+<pre><code>## 
+## === Example with Cyclic Graph ===
+</code></pre>
+<pre><code class="language-r">cyclic_graph &lt;- list(
+  &quot;1&quot; = c(2, 3),
+  &quot;2&quot; = c(1, 4),
+  &quot;3&quot; = c(1, 5),
+  &quot;4&quot; = c(2, 6),
+  &quot;5&quot; = c(3, 6),
+  &quot;6&quot; = c(4, 5)
+)
+
+cat(&quot;Cyclic graph structure:\n&quot;)
+</code></pre>
+<pre><code>## Cyclic graph structure:
+</code></pre>
+<pre><code class="language-r">for (vertex in names(cyclic_graph)) {
+  cat(&quot;Vertex&quot;, vertex, &quot;-&gt; [&quot;, paste(cyclic_graph[[vertex]], collapse = &quot;, &quot;), &quot;]\n&quot;)
+}
+</code></pre>
+<pre><code>## Vertex 1 -&gt; [ 2, 3 ]
+## Vertex 2 -&gt; [ 1, 4 ]
+## Vertex 3 -&gt; [ 1, 5 ]
+## Vertex 4 -&gt; [ 2, 6 ]
+## Vertex 5 -&gt; [ 3, 6 ]
+## Vertex 6 -&gt; [ 4, 5 ]
+</code></pre>
+<pre><code class="language-r">cat(&quot;\nDFS on cyclic graph starting from vertex 1:\n&quot;)
+</code></pre>
+<pre><code>## 
+## DFS on cyclic graph starting from vertex 1:
+</code></pre>
+<pre><code class="language-r">cyclic_result &lt;- depth_first_search(cyclic_graph, 1)
+cat(&quot;Traversal order:&quot;, paste(cyclic_result, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Traversal order: 1 -&gt; 2 -&gt; 4 -&gt; 6 -&gt; 5 -&gt; 3 -&gt; 3 -&gt; 5 -&gt; 6 -&gt; 4 -&gt; 2
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/depth_first_search.md b/Desktop/open-source/R/documentation/depth_first_search.md
new file mode 100644
index 00000000..31ea24c5
--- /dev/null
+++ b/Desktop/open-source/R/documentation/depth_first_search.md
@@ -0,0 +1,247 @@
+
+
+``` r
+# Depth-First Search (DFS) Algorithm
+# 
+# DFS is a graph traversal algorithm that explores as far as possible along each branch
+# before backtracking. It uses a stack data structure (implemented via recursion here).
+#
+# Time Complexity: O(V + E) where V is vertices and E is edges
+# Space Complexity: O(V) for the visited array and recursion stack
+#
+# Input: An adjacency list representation of a graph and a starting vertex
+# Output: The order in which vertices are visited during DFS traversal
+
+# Recursive DFS function
+dfs_recursive <- function(graph, vertex, visited, result) {
+  # Mark current vertex as visited
+  visited[vertex] <- TRUE
+  result <- c(result, vertex)
+  
+  # Visit all unvisited adjacent vertices
+  if (vertex %in% names(graph)) {
+    for (neighbor in graph[[as.character(vertex)]]) {
+      if (!visited[neighbor]) {
+        result <- dfs_recursive(graph, neighbor, visited, result)
+      }
+    }
+  }
+  
+  return(result)
+}
+
+# Main DFS function
+depth_first_search <- function(graph, start_vertex) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  
+  # Perform DFS starting from the given vertex
+  result <- dfs_recursive(graph, start_vertex, visited, c())
+  
+  return(result)
+}
+
+# Iterative DFS function using explicit stack
+dfs_iterative <- function(graph, start_vertex) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array and stack
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  stack <- c(start_vertex)
+  result <- c()
+  
+  while (length(stack) > 0) {
+    # Pop vertex from stack
+    vertex <- stack[length(stack)]
+    stack <- stack[-length(stack)]
+    
+    if (!visited[vertex]) {
+      # Mark as visited and add to result
+      visited[vertex] <- TRUE
+      result <- c(result, vertex)
+      
+      # Add all unvisited neighbors to stack (in reverse order to maintain left-to-right traversal)
+      if (as.character(vertex) %in% names(graph)) {
+        neighbors <- graph[[as.character(vertex)]]
+        for (neighbor in rev(neighbors)) {
+          if (!visited[neighbor]) {
+            stack <- c(stack, neighbor)
+          }
+        }
+      }
+    }
+  }
+  
+  return(result)
+}
+
+# Example usage and testing
+cat("=== Depth-First Search (DFS) Algorithm ===\n")
+```
+
+```
+## === Depth-First Search (DFS) Algorithm ===
+```
+
+``` r
+# Create a sample graph as adjacency list
+# Graph structure:
+#     1
+#    / \
+#   2   3
+#  / \   \
+# 4   5   6
+graph <- list(
+  "1" = c(2, 3),
+  "2" = c(4, 5),
+  "3" = c(6),
+  "4" = c(),
+  "5" = c(),
+  "6" = c()
+)
+
+cat("Graph structure (adjacency list):\n")
+```
+
+```
+## Graph structure (adjacency list):
+```
+
+``` r
+for (vertex in names(graph)) {
+  cat("Vertex", vertex, "-> [", paste(graph[[vertex]], collapse = ", "), "]\n")
+}
+```
+
+```
+## Vertex 1 -> [ 2, 3 ]
+## Vertex 2 -> [ 4, 5 ]
+## Vertex 3 -> [ 6 ]
+## Vertex 4 -> [  ]
+## Vertex 5 -> [  ]
+## Vertex 6 -> [  ]
+```
+
+``` r
+# Test recursive DFS
+cat("\nRecursive DFS starting from vertex 1:\n")
+```
+
+```
+## 
+## Recursive DFS starting from vertex 1:
+```
+
+``` r
+result_recursive <- depth_first_search(graph, 1)
+cat("Traversal order:", paste(result_recursive, collapse = " -> "), "\n")
+```
+
+```
+## Traversal order: 1 -> 2 -> 4 -> 5 -> 3 -> 6
+```
+
+``` r
+# Test iterative DFS
+cat("\nIterative DFS starting from vertex 1:\n")
+```
+
+```
+## 
+## Iterative DFS starting from vertex 1:
+```
+
+``` r
+result_iterative <- dfs_iterative(graph, 1)
+cat("Traversal order:", paste(result_iterative, collapse = " -> "), "\n")
+```
+
+```
+## Traversal order: 1 -> 2 -> 4 -> 5 -> 3 -> 6
+```
+
+``` r
+# Test with different starting vertex
+cat("\nRecursive DFS starting from vertex 2:\n")
+```
+
+```
+## 
+## Recursive DFS starting from vertex 2:
+```
+
+``` r
+result_from_2 <- depth_first_search(graph, 2)
+cat("Traversal order:", paste(result_from_2, collapse = " -> "), "\n")
+```
+
+```
+## Traversal order: 2 -> 4 -> 5
+```
+
+``` r
+# Example with a more complex graph (with cycles)
+cat("\n=== Example with Cyclic Graph ===\n")
+```
+
+```
+## 
+## === Example with Cyclic Graph ===
+```
+
+``` r
+cyclic_graph <- list(
+  "1" = c(2, 3),
+  "2" = c(1, 4),
+  "3" = c(1, 5),
+  "4" = c(2, 6),
+  "5" = c(3, 6),
+  "6" = c(4, 5)
+)
+
+cat("Cyclic graph structure:\n")
+```
+
+```
+## Cyclic graph structure:
+```
+
+``` r
+for (vertex in names(cyclic_graph)) {
+  cat("Vertex", vertex, "-> [", paste(cyclic_graph[[vertex]], collapse = ", "), "]\n")
+}
+```
+
+```
+## Vertex 1 -> [ 2, 3 ]
+## Vertex 2 -> [ 1, 4 ]
+## Vertex 3 -> [ 1, 5 ]
+## Vertex 4 -> [ 2, 6 ]
+## Vertex 5 -> [ 3, 6 ]
+## Vertex 6 -> [ 4, 5 ]
+```
+
+``` r
+cat("\nDFS on cyclic graph starting from vertex 1:\n")
+```
+
+```
+## 
+## DFS on cyclic graph starting from vertex 1:
+```
+
+``` r
+cyclic_result <- depth_first_search(cyclic_graph, 1)
+cat("Traversal order:", paste(cyclic_result, collapse = " -> "), "\n")
+```
+
+```
+## Traversal order: 1 -> 2 -> 4 -> 6 -> 5 -> 3 -> 3 -> 5 -> 6 -> 4 -> 2
+```
+
diff --git a/Desktop/open-source/R/documentation/dijkstra_shortest_path.html b/Desktop/open-source/R/documentation/dijkstra_shortest_path.html
new file mode 100644
index 00000000..134a3d81
--- /dev/null
+++ b/Desktop/open-source/R/documentation/dijkstra_shortest_path.html
@@ -0,0 +1,440 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Dijkstra's Shortest Path Algorithm
+#
+# Dijkstra's algorithm finds the shortest path between a source vertex and all other vertices
+# in a weighted graph with non-negative edge weights. It uses a greedy approach with a priority queue.
+#
+# Time Complexity: O((V + E) log V) with binary heap, O(V^2) with simple array
+# Space Complexity: O(V) for distance and visited arrays
+#
+# Input: A weighted graph represented as adjacency list with weights, and a source vertex
+# Output: Shortest distances from source to all vertices and the paths
+
+# Priority queue implementation using simple vector (for educational purposes)
+# In production, use more efficient data structures
+create_priority_queue &lt;- function() {
+  list(
+    elements = data.frame(vertex = integer(0), distance = numeric(0)),
+    size = 0
+  )
+}
+
+# Insert element into priority queue
+pq_insert &lt;- function(pq, vertex, distance) {
+  pq$elements &lt;- rbind(pq$elements, data.frame(vertex = vertex, distance = distance))
+  pq$size &lt;- pq$size + 1
+  return(pq)
+}
+
+# Extract minimum element from priority queue
+pq_extract_min &lt;- function(pq) {
+  if (pq$size == 0) {
+    return(list(pq = pq, min_element = NULL))
+  }
+  
+  min_idx &lt;- which.min(pq$elements$distance)
+  min_element &lt;- pq$elements[min_idx, ]
+  pq$elements &lt;- pq$elements[-min_idx, ]
+  pq$size &lt;- pq$size - 1
+  
+  return(list(pq = pq, min_element = min_element))
+}
+
+# Check if priority queue is empty
+pq_is_empty &lt;- function(pq) {
+  return(pq$size == 0)
+}
+
+# Main Dijkstra's algorithm implementation
+dijkstra_shortest_path &lt;- function(graph, source) {
+  # Get all vertices in the graph
+  all_vertices &lt;- unique(c(names(graph), unlist(lapply(graph, function(x) x$vertex))))
+  num_vertices &lt;- max(all_vertices)
+  
+  # Initialize distances and previous vertices
+  distances &lt;- rep(Inf, num_vertices)
+  previous &lt;- rep(-1, num_vertices)
+  visited &lt;- rep(FALSE, num_vertices)
+  
+  # Set source distance to 0
+  distances[source] &lt;- 0
+  
+  # Create priority queue and add source
+  pq &lt;- create_priority_queue()
+  pq &lt;- pq_insert(pq, source, 0)
+  
+  while (!pq_is_empty(pq)) {
+    # Extract vertex with minimum distance
+    result &lt;- pq_extract_min(pq)
+    pq &lt;- result$pq
+    current &lt;- result$min_element
+    
+    if (is.null(current)) break
+    
+    u &lt;- current$vertex
+    
+    # Skip if already visited
+    if (visited[u]) next
+    
+    # Mark as visited
+    visited[u] &lt;- TRUE
+    
+    # Update distances to neighbors
+    if (as.character(u) %in% names(graph)) {
+      for (edge in graph[[as.character(u)]]) {
+        v &lt;- edge$vertex
+        weight &lt;- edge$weight
+        
+        # Relaxation step
+        if (!visited[v] &amp;&amp; distances[u] + weight &lt; distances[v]) {
+          distances[v] &lt;- distances[u] + weight
+          previous[v] &lt;- u
+          pq &lt;- pq_insert(pq, v, distances[v])
+        }
+      }
+    }
+  }
+  
+  return(list(
+    distances = distances,
+    previous = previous
+  ))
+}
+
+# Reconstruct shortest path from source to target
+get_shortest_path &lt;- function(dijkstra_result, source, target) {
+  previous &lt;- dijkstra_result$previous
+  distances &lt;- dijkstra_result$distances
+  
+  # Check if target is reachable
+  if (distances[target] == Inf) {
+    return(list(
+      path = NULL,
+      distance = Inf
+    ))
+  }
+  
+  # Reconstruct path by backtracking
+  path &lt;- c()
+  current &lt;- target
+  
+  while (current != -1) {
+    path &lt;- c(current, path)
+    current &lt;- previous[current]
+  }
+  
+  return(list(
+    path = path,
+    distance = distances[target]
+  ))
+}
+
+# Find shortest paths to all vertices
+get_all_shortest_paths &lt;- function(dijkstra_result, source) {
+  distances &lt;- dijkstra_result$distances
+  previous &lt;- dijkstra_result$previous
+  paths &lt;- list()
+  
+  for (target in 1:length(distances)) {
+    if (distances[target] != Inf) {
+      path_result &lt;- get_shortest_path(dijkstra_result, source, target)
+      paths[[as.character(target)]] &lt;- path_result
+    }
+  }
+  
+  return(paths)
+}
+
+# Example usage and testing
+cat(&quot;=== Dijkstra's Shortest Path Algorithm ===\n&quot;)
+</code></pre>
+<pre><code>## === Dijkstra's Shortest Path Algorithm ===
+</code></pre>
+<pre><code class="language-r"># Create a weighted graph as adjacency list
+# Graph structure with weights:
+#       1
+#     /   \
+#   4/     \2
+#   /       \
+#  2         3
+#  |3      /1
+#  |      /
+#  4-----5
+#     2
+weighted_graph &lt;- list(
+  &quot;1&quot; = list(
+    list(vertex = 2, weight = 4),
+    list(vertex = 3, weight = 2)
+  ),
+  &quot;2&quot; = list(
+    list(vertex = 4, weight = 3)
+  ),
+  &quot;3&quot; = list(
+    list(vertex = 5, weight = 1)
+  ),
+  &quot;4&quot; = list(
+    list(vertex = 5, weight = 2)
+  ),
+  &quot;5&quot; = list()
+)
+
+cat(&quot;Weighted graph structure:\n&quot;)
+</code></pre>
+<pre><code>## Weighted graph structure:
+</code></pre>
+<pre><code class="language-r">for (vertex in names(weighted_graph)) {
+  edges &lt;- weighted_graph[[vertex]]
+  if (length(edges) &gt; 0) {
+    edge_strs &lt;- sapply(edges, function(e) paste0(e$vertex, &quot;(&quot;, e$weight, &quot;)&quot;))
+    cat(&quot;Vertex&quot;, vertex, &quot;-&gt; [&quot;, paste(edge_strs, collapse = &quot;, &quot;), &quot;]\n&quot;)
+  } else {
+    cat(&quot;Vertex&quot;, vertex, &quot;-&gt; []\n&quot;)
+  }
+}
+</code></pre>
+<pre><code>## Vertex 1 -&gt; [ 2(4), 3(2) ]
+## Vertex 2 -&gt; [ 4(3) ]
+## Vertex 3 -&gt; [ 5(1) ]
+## Vertex 4 -&gt; [ 5(2) ]
+## Vertex 5 -&gt; []
+</code></pre>
+<pre><code class="language-r"># Run Dijkstra's algorithm from vertex 1
+cat(&quot;\nRunning Dijkstra's algorithm from vertex 1:\n&quot;)
+</code></pre>
+<pre><code>## 
+## Running Dijkstra's algorithm from vertex 1:
+</code></pre>
+<pre><code class="language-r">result &lt;- dijkstra_shortest_path(weighted_graph, 1)
+
+# Display shortest distances
+cat(&quot;Shortest distances from vertex 1:\n&quot;)
+</code></pre>
+<pre><code>## Shortest distances from vertex 1:
+</code></pre>
+<pre><code class="language-r">for (i in 1:length(result$distances)) {
+  if (result$distances[i] != Inf) {
+    cat(&quot;To vertex&quot;, i, &quot;: distance =&quot;, result$distances[i], &quot;\n&quot;)
+  }
+}
+</code></pre>
+<pre><code>## To vertex 1 : distance = 0 
+## To vertex 2 : distance = 4 
+## To vertex 3 : distance = 2 
+## To vertex 4 : distance = 7 
+## To vertex 5 : distance = 3
+</code></pre>
+<pre><code class="language-r"># Get shortest path to specific vertex
+cat(&quot;\nShortest path from 1 to 5:\n&quot;)
+</code></pre>
+<pre><code>## 
+## Shortest path from 1 to 5:
+</code></pre>
+<pre><code class="language-r">path_to_5 &lt;- get_shortest_path(result, 1, 5)
+if (!is.null(path_to_5$path)) {
+  cat(&quot;Path:&quot;, paste(path_to_5$path, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+  cat(&quot;Distance:&quot;, path_to_5$distance, &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>## Path: 1 -&gt; 3 -&gt; 5 
+## Distance: 3
+</code></pre>
+<pre><code class="language-r"># Get all shortest paths
+cat(&quot;\nAll shortest paths from vertex 1:\n&quot;)
+</code></pre>
+<pre><code>## 
+## All shortest paths from vertex 1:
+</code></pre>
+<pre><code class="language-r">all_paths &lt;- get_all_shortest_paths(result, 1)
+for (target in names(all_paths)) {
+  path_info &lt;- all_paths[[target]]
+  cat(&quot;To vertex&quot;, target, &quot;: &quot;, paste(path_info$path, collapse = &quot; -&gt; &quot;), 
+      &quot; (distance:&quot;, path_info$distance, &quot;)\n&quot;)
+}
+</code></pre>
+<pre><code>## To vertex 1 :  1  (distance: 0 )
+## To vertex 2 :  1 -&gt; 2  (distance: 4 )
+## To vertex 3 :  1 -&gt; 3  (distance: 2 )
+## To vertex 4 :  1 -&gt; 2 -&gt; 4  (distance: 7 )
+## To vertex 5 :  1 -&gt; 3 -&gt; 5  (distance: 3 )
+</code></pre>
+<pre><code class="language-r"># Example with a more complex graph
+cat(&quot;\n=== More Complex Weighted Graph Example ===\n&quot;)
+</code></pre>
+<pre><code>## 
+## === More Complex Weighted Graph Example ===
+</code></pre>
+<pre><code class="language-r">complex_weighted_graph &lt;- list(
+  &quot;1&quot; = list(
+    list(vertex = 2, weight = 7),
+    list(vertex = 3, weight = 9),
+    list(vertex = 6, weight = 14)
+  ),
+  &quot;2&quot; = list(
+    list(vertex = 3, weight = 10),
+    list(vertex = 4, weight = 15)
+  ),
+  &quot;3&quot; = list(
+    list(vertex = 4, weight = 11),
+    list(vertex = 6, weight = 2)
+  ),
+  &quot;4&quot; = list(
+    list(vertex = 5, weight = 6)
+  ),
+  &quot;5&quot; = list(),
+  &quot;6&quot; = list(
+    list(vertex = 5, weight = 9)
+  )
+)
+
+cat(&quot;Complex weighted graph from vertex 1:\n&quot;)
+</code></pre>
+<pre><code>## Complex weighted graph from vertex 1:
+</code></pre>
+<pre><code class="language-r">complex_result &lt;- dijkstra_shortest_path(complex_weighted_graph, 1)
+
+cat(&quot;Shortest distances:\n&quot;)
+</code></pre>
+<pre><code>## Shortest distances:
+</code></pre>
+<pre><code class="language-r">for (i in 1:length(complex_result$distances)) {
+  if (complex_result$distances[i] != Inf) {
+    cat(&quot;To vertex&quot;, i, &quot;: distance =&quot;, complex_result$distances[i], &quot;\n&quot;)
+  }
+}
+</code></pre>
+<pre><code>## To vertex 1 : distance = 0 
+## To vertex 2 : distance = 7 
+## To vertex 3 : distance = 9 
+## To vertex 4 : distance = 20 
+## To vertex 5 : distance = 20 
+## To vertex 6 : distance = 11
+</code></pre>
+<pre><code class="language-r"># Shortest path to vertex 5
+path_to_5_complex &lt;- get_shortest_path(complex_result, 1, 5)
+if (!is.null(path_to_5_complex$path)) {
+  cat(&quot;Shortest path from 1 to 5:&quot;, paste(path_to_5_complex$path, collapse = &quot; -&gt; &quot;), &quot;\n&quot;)
+  cat(&quot;Distance:&quot;, path_to_5_complex$distance, &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>## Shortest path from 1 to 5: 1 -&gt; 3 -&gt; 6 -&gt; 5 
+## Distance: 20
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/dijkstra_shortest_path.md b/Desktop/open-source/R/documentation/dijkstra_shortest_path.md
new file mode 100644
index 00000000..41868d84
--- /dev/null
+++ b/Desktop/open-source/R/documentation/dijkstra_shortest_path.md
@@ -0,0 +1,382 @@
+
+
+``` r
+# Dijkstra's Shortest Path Algorithm
+#
+# Dijkstra's algorithm finds the shortest path between a source vertex and all other vertices
+# in a weighted graph with non-negative edge weights. It uses a greedy approach with a priority queue.
+#
+# Time Complexity: O((V + E) log V) with binary heap, O(V^2) with simple array
+# Space Complexity: O(V) for distance and visited arrays
+#
+# Input: A weighted graph represented as adjacency list with weights, and a source vertex
+# Output: Shortest distances from source to all vertices and the paths
+
+# Priority queue implementation using simple vector (for educational purposes)
+# In production, use more efficient data structures
+create_priority_queue <- function() {
+  list(
+    elements = data.frame(vertex = integer(0), distance = numeric(0)),
+    size = 0
+  )
+}
+
+# Insert element into priority queue
+pq_insert <- function(pq, vertex, distance) {
+  pq$elements <- rbind(pq$elements, data.frame(vertex = vertex, distance = distance))
+  pq$size <- pq$size + 1
+  return(pq)
+}
+
+# Extract minimum element from priority queue
+pq_extract_min <- function(pq) {
+  if (pq$size == 0) {
+    return(list(pq = pq, min_element = NULL))
+  }
+  
+  min_idx <- which.min(pq$elements$distance)
+  min_element <- pq$elements[min_idx, ]
+  pq$elements <- pq$elements[-min_idx, ]
+  pq$size <- pq$size - 1
+  
+  return(list(pq = pq, min_element = min_element))
+}
+
+# Check if priority queue is empty
+pq_is_empty <- function(pq) {
+  return(pq$size == 0)
+}
+
+# Main Dijkstra's algorithm implementation
+dijkstra_shortest_path <- function(graph, source) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(lapply(graph, function(x) x$vertex))))
+  num_vertices <- max(all_vertices)
+  
+  # Initialize distances and previous vertices
+  distances <- rep(Inf, num_vertices)
+  previous <- rep(-1, num_vertices)
+  visited <- rep(FALSE, num_vertices)
+  
+  # Set source distance to 0
+  distances[source] <- 0
+  
+  # Create priority queue and add source
+  pq <- create_priority_queue()
+  pq <- pq_insert(pq, source, 0)
+  
+  while (!pq_is_empty(pq)) {
+    # Extract vertex with minimum distance
+    result <- pq_extract_min(pq)
+    pq <- result$pq
+    current <- result$min_element
+    
+    if (is.null(current)) break
+    
+    u <- current$vertex
+    
+    # Skip if already visited
+    if (visited[u]) next
+    
+    # Mark as visited
+    visited[u] <- TRUE
+    
+    # Update distances to neighbors
+    if (as.character(u) %in% names(graph)) {
+      for (edge in graph[[as.character(u)]]) {
+        v <- edge$vertex
+        weight <- edge$weight
+        
+        # Relaxation step
+        if (!visited[v] && distances[u] + weight < distances[v]) {
+          distances[v] <- distances[u] + weight
+          previous[v] <- u
+          pq <- pq_insert(pq, v, distances[v])
+        }
+      }
+    }
+  }
+  
+  return(list(
+    distances = distances,
+    previous = previous
+  ))
+}
+
+# Reconstruct shortest path from source to target
+get_shortest_path <- function(dijkstra_result, source, target) {
+  previous <- dijkstra_result$previous
+  distances <- dijkstra_result$distances
+  
+  # Check if target is reachable
+  if (distances[target] == Inf) {
+    return(list(
+      path = NULL,
+      distance = Inf
+    ))
+  }
+  
+  # Reconstruct path by backtracking
+  path <- c()
+  current <- target
+  
+  while (current != -1) {
+    path <- c(current, path)
+    current <- previous[current]
+  }
+  
+  return(list(
+    path = path,
+    distance = distances[target]
+  ))
+}
+
+# Find shortest paths to all vertices
+get_all_shortest_paths <- function(dijkstra_result, source) {
+  distances <- dijkstra_result$distances
+  previous <- dijkstra_result$previous
+  paths <- list()
+  
+  for (target in 1:length(distances)) {
+    if (distances[target] != Inf) {
+      path_result <- get_shortest_path(dijkstra_result, source, target)
+      paths[[as.character(target)]] <- path_result
+    }
+  }
+  
+  return(paths)
+}
+
+# Example usage and testing
+cat("=== Dijkstra's Shortest Path Algorithm ===\n")
+```
+
+```
+## === Dijkstra's Shortest Path Algorithm ===
+```
+
+``` r
+# Create a weighted graph as adjacency list
+# Graph structure with weights:
+#       1
+#     /   \
+#   4/     \2
+#   /       \
+#  2         3
+#  |3      /1
+#  |      /
+#  4-----5
+#     2
+weighted_graph <- list(
+  "1" = list(
+    list(vertex = 2, weight = 4),
+    list(vertex = 3, weight = 2)
+  ),
+  "2" = list(
+    list(vertex = 4, weight = 3)
+  ),
+  "3" = list(
+    list(vertex = 5, weight = 1)
+  ),
+  "4" = list(
+    list(vertex = 5, weight = 2)
+  ),
+  "5" = list()
+)
+
+cat("Weighted graph structure:\n")
+```
+
+```
+## Weighted graph structure:
+```
+
+``` r
+for (vertex in names(weighted_graph)) {
+  edges <- weighted_graph[[vertex]]
+  if (length(edges) > 0) {
+    edge_strs <- sapply(edges, function(e) paste0(e$vertex, "(", e$weight, ")"))
+    cat("Vertex", vertex, "-> [", paste(edge_strs, collapse = ", "), "]\n")
+  } else {
+    cat("Vertex", vertex, "-> []\n")
+  }
+}
+```
+
+```
+## Vertex 1 -> [ 2(4), 3(2) ]
+## Vertex 2 -> [ 4(3) ]
+## Vertex 3 -> [ 5(1) ]
+## Vertex 4 -> [ 5(2) ]
+## Vertex 5 -> []
+```
+
+``` r
+# Run Dijkstra's algorithm from vertex 1
+cat("\nRunning Dijkstra's algorithm from vertex 1:\n")
+```
+
+```
+## 
+## Running Dijkstra's algorithm from vertex 1:
+```
+
+``` r
+result <- dijkstra_shortest_path(weighted_graph, 1)
+
+# Display shortest distances
+cat("Shortest distances from vertex 1:\n")
+```
+
+```
+## Shortest distances from vertex 1:
+```
+
+``` r
+for (i in 1:length(result$distances)) {
+  if (result$distances[i] != Inf) {
+    cat("To vertex", i, ": distance =", result$distances[i], "\n")
+  }
+}
+```
+
+```
+## To vertex 1 : distance = 0 
+## To vertex 2 : distance = 4 
+## To vertex 3 : distance = 2 
+## To vertex 4 : distance = 7 
+## To vertex 5 : distance = 3
+```
+
+``` r
+# Get shortest path to specific vertex
+cat("\nShortest path from 1 to 5:\n")
+```
+
+```
+## 
+## Shortest path from 1 to 5:
+```
+
+``` r
+path_to_5 <- get_shortest_path(result, 1, 5)
+if (!is.null(path_to_5$path)) {
+  cat("Path:", paste(path_to_5$path, collapse = " -> "), "\n")
+  cat("Distance:", path_to_5$distance, "\n")
+}
+```
+
+```
+## Path: 1 -> 3 -> 5 
+## Distance: 3
+```
+
+``` r
+# Get all shortest paths
+cat("\nAll shortest paths from vertex 1:\n")
+```
+
+```
+## 
+## All shortest paths from vertex 1:
+```
+
+``` r
+all_paths <- get_all_shortest_paths(result, 1)
+for (target in names(all_paths)) {
+  path_info <- all_paths[[target]]
+  cat("To vertex", target, ": ", paste(path_info$path, collapse = " -> "), 
+      " (distance:", path_info$distance, ")\n")
+}
+```
+
+```
+## To vertex 1 :  1  (distance: 0 )
+## To vertex 2 :  1 -> 2  (distance: 4 )
+## To vertex 3 :  1 -> 3  (distance: 2 )
+## To vertex 4 :  1 -> 2 -> 4  (distance: 7 )
+## To vertex 5 :  1 -> 3 -> 5  (distance: 3 )
+```
+
+``` r
+# Example with a more complex graph
+cat("\n=== More Complex Weighted Graph Example ===\n")
+```
+
+```
+## 
+## === More Complex Weighted Graph Example ===
+```
+
+``` r
+complex_weighted_graph <- list(
+  "1" = list(
+    list(vertex = 2, weight = 7),
+    list(vertex = 3, weight = 9),
+    list(vertex = 6, weight = 14)
+  ),
+  "2" = list(
+    list(vertex = 3, weight = 10),
+    list(vertex = 4, weight = 15)
+  ),
+  "3" = list(
+    list(vertex = 4, weight = 11),
+    list(vertex = 6, weight = 2)
+  ),
+  "4" = list(
+    list(vertex = 5, weight = 6)
+  ),
+  "5" = list(),
+  "6" = list(
+    list(vertex = 5, weight = 9)
+  )
+)
+
+cat("Complex weighted graph from vertex 1:\n")
+```
+
+```
+## Complex weighted graph from vertex 1:
+```
+
+``` r
+complex_result <- dijkstra_shortest_path(complex_weighted_graph, 1)
+
+cat("Shortest distances:\n")
+```
+
+```
+## Shortest distances:
+```
+
+``` r
+for (i in 1:length(complex_result$distances)) {
+  if (complex_result$distances[i] != Inf) {
+    cat("To vertex", i, ": distance =", complex_result$distances[i], "\n")
+  }
+}
+```
+
+```
+## To vertex 1 : distance = 0 
+## To vertex 2 : distance = 7 
+## To vertex 3 : distance = 9 
+## To vertex 4 : distance = 20 
+## To vertex 5 : distance = 20 
+## To vertex 6 : distance = 11
+```
+
+``` r
+# Shortest path to vertex 5
+path_to_5_complex <- get_shortest_path(complex_result, 1, 5)
+if (!is.null(path_to_5_complex$path)) {
+  cat("Shortest path from 1 to 5:", paste(path_to_5_complex$path, collapse = " -> "), "\n")
+  cat("Distance:", path_to_5_complex$distance, "\n")
+}
+```
+
+```
+## Shortest path from 1 to 5: 1 -> 3 -> 6 -> 5 
+## Distance: 20
+```
+
diff --git a/Desktop/open-source/R/documentation/dimensionality_reduction_algorithms.html b/Desktop/open-source/R/documentation/dimensionality_reduction_algorithms.html
new file mode 100644
index 00000000..9105bd39
--- /dev/null
+++ b/Desktop/open-source/R/documentation/dimensionality_reduction_algorithms.html
@@ -0,0 +1,133 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(stats)
+pca &lt;- princomp(train, cor = TRUE)
+</code></pre>
+<pre><code>## Error in princomp(train, cor = TRUE): object 'train' not found
+</code></pre>
+<pre><code class="language-r">train_reduced  &lt;- predict(pca,train)
+</code></pre>
+<pre><code>## Error in predict(pca, train): object 'pca' not found
+</code></pre>
+<pre><code class="language-r">test_reduced  &lt;- predict(pca,test)
+</code></pre>
+<pre><code>## Error in predict(pca, test): object 'pca' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/dimensionality_reduction_algorithms.md b/Desktop/open-source/R/documentation/dimensionality_reduction_algorithms.md
new file mode 100644
index 00000000..ae21219f
--- /dev/null
+++ b/Desktop/open-source/R/documentation/dimensionality_reduction_algorithms.md
@@ -0,0 +1,27 @@
+
+
+``` r
+library(stats)
+pca <- princomp(train, cor = TRUE)
+```
+
+```
+## Error in princomp(train, cor = TRUE): object 'train' not found
+```
+
+``` r
+train_reduced  <- predict(pca,train)
+```
+
+```
+## Error in predict(pca, train): object 'pca' not found
+```
+
+``` r
+test_reduced  <- predict(pca,test)
+```
+
+```
+## Error in predict(pca, test): object 'pca' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/figure/unnamed-chunk-1-1.png b/Desktop/open-source/R/documentation/figure/unnamed-chunk-1-1.png
new file mode 100644
index 00000000..f6226f50
Binary files /dev/null and b/Desktop/open-source/R/documentation/figure/unnamed-chunk-1-1.png differ
diff --git a/Desktop/open-source/R/documentation/gmm.html b/Desktop/open-source/R/documentation/gmm.html
new file mode 100644
index 00000000..188c9cd9
--- /dev/null
+++ b/Desktop/open-source/R/documentation/gmm.html
@@ -0,0 +1,136 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(mclust) # Gaussian mixture model (GMM)
+</code></pre>
+<pre><code>## Error in library(mclust): there is no package called 'mclust'
+</code></pre>
+<pre><code class="language-r">gmm_fit &lt;- Mclust(iris[, 1:4]) # Fit a GMM model
+</code></pre>
+<pre><code>## Error in Mclust(iris[, 1:4]): could not find function &quot;Mclust&quot;
+</code></pre>
+<pre><code class="language-r">summary(gmm_fit) # Summary table 
+</code></pre>
+<pre><code>## Error in summary(gmm_fit): object 'gmm_fit' not found
+</code></pre>
+<pre><code class="language-r">plot(gmm_fit, 'BIC') # Select model based on BIC
+</code></pre>
+<pre><code>## Error in plot(gmm_fit, &quot;BIC&quot;): object 'gmm_fit' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/gmm.md b/Desktop/open-source/R/documentation/gmm.md
new file mode 100644
index 00000000..bde46be3
--- /dev/null
+++ b/Desktop/open-source/R/documentation/gmm.md
@@ -0,0 +1,34 @@
+
+
+``` r
+library(mclust) # Gaussian mixture model (GMM)
+```
+
+```
+## Error in library(mclust): there is no package called 'mclust'
+```
+
+``` r
+gmm_fit <- Mclust(iris[, 1:4]) # Fit a GMM model
+```
+
+```
+## Error in Mclust(iris[, 1:4]): could not find function "Mclust"
+```
+
+``` r
+summary(gmm_fit) # Summary table 
+```
+
+```
+## Error in summary(gmm_fit): object 'gmm_fit' not found
+```
+
+``` r
+plot(gmm_fit, 'BIC') # Select model based on BIC
+```
+
+```
+## Error in plot(gmm_fit, "BIC"): object 'gmm_fit' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/gradient_boosting_algorithms.html b/Desktop/open-source/R/documentation/gradient_boosting_algorithms.html
new file mode 100644
index 00000000..2847253c
--- /dev/null
+++ b/Desktop/open-source/R/documentation/gradient_boosting_algorithms.html
@@ -0,0 +1,197 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># GBM
+library(caret)
+x &lt;- cbind(x_train,y_train)
+# Fitting model
+fitControl &lt;- trainControl( method = &quot;repeatedcv&quot;, number = 4, repeats = 4)
+fit &lt;- train(y ~ ., data = x, method = &quot;gbm&quot;, trControl = fitControl,verbose = FALSE)
+predicted= predict(fit,x_test,type= &quot;prob&quot;)[,2] 
+
+
+
+# XGBoost
+require(caret)
+x &lt;- cbind(x_train,y_train)
+# Fitting model
+TrainControl &lt;- trainControl( method = &quot;repeatedcv&quot;, number = 10, repeats = 4)
+model&lt;- train(y ~ ., data = x, method = &quot;xgbLinear&quot;, trControl = TrainControl,verbose = FALSE)
+# OR 
+model&lt;- train(y ~ ., data = x, method = &quot;xgbTree&quot;, trControl = TrainControl,verbose = FALSE)
+predicted &lt;- predict(model, x_test)
+
+
+
+# LightGBM
+library(RLightGBM)
+data(example.binary)
+# Parameters
+num_iterations &lt;- 100
+config &lt;- list(objective = &quot;binary&quot;,  metric=&quot;binary_logloss,auc&quot;, learning_rate = 0.1, num_leaves = 63, tree_learner = &quot;serial&quot;, feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)
+# Create data handle and booster
+handle.data &lt;- lgbm.data.create(x)
+lgbm.data.setField(handle.data, &quot;label&quot;, y)
+handle.booster &lt;- lgbm.booster.create(handle.data, lapply(config, as.character))
+# Train for num_iterations iterations and eval every 5 steps
+lgbm.booster.train(handle.booster, num_iterations, 5)
+# Predict
+pred &lt;- lgbm.booster.predict(handle.booster, x.test)
+# Test accuracy
+sum(y.test == (y.pred &gt; 0.5)) / length(y.test)
+# Save model (can be loaded again via lgbm.booster.load(filename))
+lgbm.booster.save(handle.booster, filename = &quot;/tmp/model.txt&quot;)
+
+
+
+# Catboost
+set.seed(1)
+
+require(titanic)
+
+require(caret)
+
+require(catboost)
+
+tt &lt;- titanic::titanic_train[complete.cases(titanic::titanic_train),]
+
+data &lt;- as.data.frame(as.matrix(tt), stringsAsFactors = TRUE)
+
+drop_columns = c(&quot;PassengerId&quot;, &quot;Survived&quot;, &quot;Name&quot;, &quot;Ticket&quot;, &quot;Cabin&quot;)
+
+x &lt;- data[,!(names(data) %in% drop_columns)]y &lt;- data[,c(&quot;Survived&quot;)]
+
+fit_control &lt;- trainControl(method = &quot;cv&quot;, number = 4,classProbs = TRUE)
+
+grid &lt;- expand.grid(depth = c(4, 6, 8),learning_rate = 0.1,iterations = 100, l2_leaf_reg = 1e-3,            rsm = 0.95, border_count = 64)
+
+report &lt;- train(x, as.factor(make.names(y)),method = catboost.caret,verbose = TRUE, preProc = NULL,tuneGrid = grid, trControl = fit_control)
+
+print(report)
+
+importance &lt;- varImp(report, scale = FALSE)
+
+print(importance)
+</code></pre>
+<pre><code>## Error in parse(text = input): &lt;text&gt;:59:45: unexpected symbol
+## 58: 
+## 59: x &lt;- data[,!(names(data) %in% drop_columns)]y
+##                                                 ^
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/gradient_boosting_algorithms.md b/Desktop/open-source/R/documentation/gradient_boosting_algorithms.md
new file mode 100644
index 00000000..577b4b6d
--- /dev/null
+++ b/Desktop/open-source/R/documentation/gradient_boosting_algorithms.md
@@ -0,0 +1,83 @@
+
+
+``` r
+# GBM
+library(caret)
+x <- cbind(x_train,y_train)
+# Fitting model
+fitControl <- trainControl( method = "repeatedcv", number = 4, repeats = 4)
+fit <- train(y ~ ., data = x, method = "gbm", trControl = fitControl,verbose = FALSE)
+predicted= predict(fit,x_test,type= "prob")[,2] 
+
+
+
+# XGBoost
+require(caret)
+x <- cbind(x_train,y_train)
+# Fitting model
+TrainControl <- trainControl( method = "repeatedcv", number = 10, repeats = 4)
+model<- train(y ~ ., data = x, method = "xgbLinear", trControl = TrainControl,verbose = FALSE)
+# OR 
+model<- train(y ~ ., data = x, method = "xgbTree", trControl = TrainControl,verbose = FALSE)
+predicted <- predict(model, x_test)
+
+
+
+# LightGBM
+library(RLightGBM)
+data(example.binary)
+# Parameters
+num_iterations <- 100
+config <- list(objective = "binary",  metric="binary_logloss,auc", learning_rate = 0.1, num_leaves = 63, tree_learner = "serial", feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)
+# Create data handle and booster
+handle.data <- lgbm.data.create(x)
+lgbm.data.setField(handle.data, "label", y)
+handle.booster <- lgbm.booster.create(handle.data, lapply(config, as.character))
+# Train for num_iterations iterations and eval every 5 steps
+lgbm.booster.train(handle.booster, num_iterations, 5)
+# Predict
+pred <- lgbm.booster.predict(handle.booster, x.test)
+# Test accuracy
+sum(y.test == (y.pred > 0.5)) / length(y.test)
+# Save model (can be loaded again via lgbm.booster.load(filename))
+lgbm.booster.save(handle.booster, filename = "/tmp/model.txt")
+
+
+
+# Catboost
+set.seed(1)
+
+require(titanic)
+
+require(caret)
+
+require(catboost)
+
+tt <- titanic::titanic_train[complete.cases(titanic::titanic_train),]
+
+data <- as.data.frame(as.matrix(tt), stringsAsFactors = TRUE)
+
+drop_columns = c("PassengerId", "Survived", "Name", "Ticket", "Cabin")
+
+x <- data[,!(names(data) %in% drop_columns)]y <- data[,c("Survived")]
+
+fit_control <- trainControl(method = "cv", number = 4,classProbs = TRUE)
+
+grid <- expand.grid(depth = c(4, 6, 8),learning_rate = 0.1,iterations = 100, l2_leaf_reg = 1e-3,            rsm = 0.95, border_count = 64)
+
+report <- train(x, as.factor(make.names(y)),method = catboost.caret,verbose = TRUE, preProc = NULL,tuneGrid = grid, trControl = fit_control)
+
+print(report)
+
+importance <- varImp(report, scale = FALSE)
+
+print(importance)
+```
+
+```
+## Error in parse(text = input): <text>:59:45: unexpected symbol
+## 58: 
+## 59: x <- data[,!(names(data) %in% drop_columns)]y
+##                                                 ^
+```
+
diff --git a/Desktop/open-source/R/documentation/heirarchical_clustering.html b/Desktop/open-source/R/documentation/heirarchical_clustering.html
new file mode 100644
index 00000000..053841a4
--- /dev/null
+++ b/Desktop/open-source/R/documentation/heirarchical_clustering.html
@@ -0,0 +1,125 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">set.seed(42)
+clusters &lt;- hclust(dist(iris[, -5]))
+plot(clusters)
+</code></pre>
+<p><img src="data:image/png;base64,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" alt="plot of chunk unnamed-chunk-1" /></p>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/heirarchical_clustering.md b/Desktop/open-source/R/documentation/heirarchical_clustering.md
new file mode 100644
index 00000000..f57831aa
--- /dev/null
+++ b/Desktop/open-source/R/documentation/heirarchical_clustering.md
@@ -0,0 +1,10 @@
+
+
+``` r
+set.seed(42)
+clusters <- hclust(dist(iris[, -5]))
+plot(clusters)
+```
+
+![plot of chunk unnamed-chunk-1](figure/unnamed-chunk-1-1.png)
+
diff --git a/Desktop/open-source/R/documentation/k_folds.html b/Desktop/open-source/R/documentation/k_folds.html
new file mode 100644
index 00000000..6169b9b2
--- /dev/null
+++ b/Desktop/open-source/R/documentation/k_folds.html
@@ -0,0 +1,150 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># K folds cross validation is essential for machine learning
+# createFolds function in package caret is easy to use
+# here we write our own function
+
+get_k_folds&lt;-function(y = c(),k = 10, isList = TRUE, seed = 123){
+  set.seed(seed)
+  folds&lt;-sample(1:length(y), length(y))
+  every_n&lt;-ceiling(length(y)/k)
+  matFolds&lt;-suppressWarnings(matrix(folds, ncol=every_n, byrow = T))
+  
+  if(isList){
+    value&lt;-NULL
+    rownames(matFolds)&lt;-paste(&quot;Folds&quot;,1:k,sep=&quot;&quot;)
+    value&lt;-lapply(1:k, function(x){
+      if(x == k){
+        return(matFolds[x,][1:(length(y)-every_n*(k-1))])
+      }else{
+        return(matFolds[x,])
+      }
+    })
+  }else{
+    value&lt;-c()
+    for(i in 1:length(y)){
+      value[i]&lt;-ceiling(i/every_n)
+    }
+  }
+  
+  return(value)
+}
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/k_folds.md b/Desktop/open-source/R/documentation/k_folds.md
new file mode 100644
index 00000000..f57786d9
--- /dev/null
+++ b/Desktop/open-source/R/documentation/k_folds.md
@@ -0,0 +1,34 @@
+
+
+``` r
+# K folds cross validation is essential for machine learning
+# createFolds function in package caret is easy to use
+# here we write our own function
+
+get_k_folds<-function(y = c(),k = 10, isList = TRUE, seed = 123){
+  set.seed(seed)
+  folds<-sample(1:length(y), length(y))
+  every_n<-ceiling(length(y)/k)
+  matFolds<-suppressWarnings(matrix(folds, ncol=every_n, byrow = T))
+  
+  if(isList){
+    value<-NULL
+    rownames(matFolds)<-paste("Folds",1:k,sep="")
+    value<-lapply(1:k, function(x){
+      if(x == k){
+        return(matFolds[x,][1:(length(y)-every_n*(k-1))])
+      }else{
+        return(matFolds[x,])
+      }
+    })
+  }else{
+    value<-c()
+    for(i in 1:length(y)){
+      value[i]<-ceiling(i/every_n)
+    }
+  }
+  
+  return(value)
+}
+```
+
diff --git a/Desktop/open-source/R/documentation/k_means.html b/Desktop/open-source/R/documentation/k_means.html
new file mode 100644
index 00000000..ff4b4477
--- /dev/null
+++ b/Desktop/open-source/R/documentation/k_means.html
@@ -0,0 +1,126 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(cluster)
+set.seed(42)
+fit &lt;- kmeans(X, 3) # 3 cluster solution
+</code></pre>
+<pre><code>## Error in as.matrix(x): object 'X' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/k_means.md b/Desktop/open-source/R/documentation/k_means.md
new file mode 100644
index 00000000..81d99ce2
--- /dev/null
+++ b/Desktop/open-source/R/documentation/k_means.md
@@ -0,0 +1,12 @@
+
+
+``` r
+library(cluster)
+set.seed(42)
+fit <- kmeans(X, 3) # 3 cluster solution
+```
+
+```
+## Error in as.matrix(x): object 'X' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/kmeans_clustering.html b/Desktop/open-source/R/documentation/kmeans_clustering.html
new file mode 100644
index 00000000..c0641210
--- /dev/null
+++ b/Desktop/open-source/R/documentation/kmeans_clustering.html
@@ -0,0 +1,126 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">set.seed(42)
+cl &lt;- kmeans(iris[,-5], 3)
+plot(iris[,-5], col = cl$cluster)
+points(cl$centers, col = 1:3, pch = 8)
+</code></pre>
+<p><img src="data:image/png;base64,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" alt="plot of chunk unnamed-chunk-1" /></p>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/kmeans_clustering.md b/Desktop/open-source/R/documentation/kmeans_clustering.md
new file mode 100644
index 00000000..ef47eb01
--- /dev/null
+++ b/Desktop/open-source/R/documentation/kmeans_clustering.md
@@ -0,0 +1,11 @@
+
+
+``` r
+set.seed(42)
+cl <- kmeans(iris[,-5], 3)
+plot(iris[,-5], col = cl$cluster)
+points(cl$centers, col = 1:3, pch = 8)
+```
+
+![plot of chunk unnamed-chunk-1](figure/unnamed-chunk-1-1.png)
+
diff --git a/Desktop/open-source/R/documentation/kmeans_raw_r.html b/Desktop/open-source/R/documentation/kmeans_raw_r.html
new file mode 100644
index 00000000..a7a4bc14
--- /dev/null
+++ b/Desktop/open-source/R/documentation/kmeans_raw_r.html
@@ -0,0 +1,174 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">custonKmeans&lt;-function(dataset=NA,k=NA){
+  if(is.na(dataset) || is.na(k)){
+    stop(&quot;You must input valid parameters!&quot;)
+  }
+  Eudist&lt;-function(x,y){
+    distance&lt;-sqrt(sum((x-y)^2))
+    return (distance)
+  }
+  
+  rows.dataset&lt;-nrow(dataset)
+  continue.change=TRUE
+  initPoint&lt;-dataset[sample.int(rows.dataset,size = k),]
+  formerPoint&lt;-initPoint
+  iterPoint&lt;-matrix(0,nrow = k,ncol = ncol(dataset))
+  
+  #记录每一个点到每一个类的距离
+  error.matrix&lt;-matrix(0,nrow=rows.dataset,ncol=k)
+  while(continue.change){
+    #记录每个点所属的类是哪一个
+    cluster.matrix&lt;-matrix(0,nrow=rows.dataset,ncol=k)
+    for(i in 1:rows.dataset){#计算每个点到三个初始中心点的距离
+      for(j in 1:k){
+        error.matrix[i,j]&lt;-Eudist(dataset[i,],formerPoint[j,])
+      }
+    }
+    #将每一个点所属的类计算出来
+    for(i in 1:rows.dataset){
+      cluster.matrix[i,which.min(error.matrix[i,])]&lt;-1
+    }
+    
+    #更新新的质心位置
+    for(i in 1:k){
+      iterPoint[i,]&lt;-apply(dataset[which(cluster.matrix[,i] == 1),],2,&quot;mean&quot;)
+    }
+    all.true&lt;-c()
+    for(i in 1:k){
+      if(all(formerPoint[i,] == iterPoint[i,]) == T){
+        all.true[i]&lt;-TRUE
+      }
+    }
+    formerPoint = iterPoint
+    continue.change=ifelse(all(all.true) == T,F,T)
+  }
+  colnames(iterPoint)&lt;-colnames(dataset)
+  out=list()
+  out[[&quot;centers&quot;]]&lt;-iterPoint
+  out[[&quot;distance&quot;]]&lt;-error.matrix
+  out[[&quot;cluster&quot;]]&lt;-rep(1,rows.dataset)
+  for(i in 1:rows.dataset){
+    out[[&quot;cluster&quot;]][i]&lt;-which(cluster.matrix[i,] == 1)
+  }
+  return(out)
+}
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/kmeans_raw_r.md b/Desktop/open-source/R/documentation/kmeans_raw_r.md
new file mode 100644
index 00000000..19db849b
--- /dev/null
+++ b/Desktop/open-source/R/documentation/kmeans_raw_r.md
@@ -0,0 +1,58 @@
+
+
+``` r
+custonKmeans<-function(dataset=NA,k=NA){
+  if(is.na(dataset) || is.na(k)){
+    stop("You must input valid parameters!")
+  }
+  Eudist<-function(x,y){
+    distance<-sqrt(sum((x-y)^2))
+    return (distance)
+  }
+  
+  rows.dataset<-nrow(dataset)
+  continue.change=TRUE
+  initPoint<-dataset[sample.int(rows.dataset,size = k),]
+  formerPoint<-initPoint
+  iterPoint<-matrix(0,nrow = k,ncol = ncol(dataset))
+  
+  #记录每一个点到每一个类的距离
+  error.matrix<-matrix(0,nrow=rows.dataset,ncol=k)
+  while(continue.change){
+    #记录每个点所属的类是哪一个
+    cluster.matrix<-matrix(0,nrow=rows.dataset,ncol=k)
+    for(i in 1:rows.dataset){#计算每个点到三个初始中心点的距离
+      for(j in 1:k){
+        error.matrix[i,j]<-Eudist(dataset[i,],formerPoint[j,])
+      }
+    }
+    #将每一个点所属的类计算出来
+    for(i in 1:rows.dataset){
+      cluster.matrix[i,which.min(error.matrix[i,])]<-1
+    }
+    
+    #更新新的质心位置
+    for(i in 1:k){
+      iterPoint[i,]<-apply(dataset[which(cluster.matrix[,i] == 1),],2,"mean")
+    }
+    all.true<-c()
+    for(i in 1:k){
+      if(all(formerPoint[i,] == iterPoint[i,]) == T){
+        all.true[i]<-TRUE
+      }
+    }
+    formerPoint = iterPoint
+    continue.change=ifelse(all(all.true) == T,F,T)
+  }
+  colnames(iterPoint)<-colnames(dataset)
+  out=list()
+  out[["centers"]]<-iterPoint
+  out[["distance"]]<-error.matrix
+  out[["cluster"]]<-rep(1,rows.dataset)
+  for(i in 1:rows.dataset){
+    out[["cluster"]][i]<-which(cluster.matrix[i,] == 1)
+  }
+  return(out)
+}
+```
+
diff --git a/Desktop/open-source/R/documentation/knn.html b/Desktop/open-source/R/documentation/knn.html
new file mode 100644
index 00000000..bc8725be
--- /dev/null
+++ b/Desktop/open-source/R/documentation/knn.html
@@ -0,0 +1,142 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(knn)
+</code></pre>
+<pre><code>## Error in library(knn): there is no package called 'knn'
+</code></pre>
+<pre><code class="language-r">x &lt;- cbind(x_train,y_train)
+</code></pre>
+<pre><code>## Error in cbind(x_train, y_train): object 'x_train' not found
+</code></pre>
+<pre><code class="language-r"># Fitting model
+fit &lt;-knn(y_train ~ ., data = x,k=5)
+</code></pre>
+<pre><code>## Error in knn(y_train ~ ., data = x, k = 5): could not find function &quot;knn&quot;
+</code></pre>
+<pre><code class="language-r">summary(fit)
+</code></pre>
+<pre><code>## Error in summary(fit): object 'fit' not found
+</code></pre>
+<pre><code class="language-r"># Predict Output 
+predicted= predict(fit,x_test)
+</code></pre>
+<pre><code>## Error in predict(fit, x_test): object 'fit' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/knn.md b/Desktop/open-source/R/documentation/knn.md
new file mode 100644
index 00000000..b9954008
--- /dev/null
+++ b/Desktop/open-source/R/documentation/knn.md
@@ -0,0 +1,44 @@
+
+
+``` r
+library(knn)
+```
+
+```
+## Error in library(knn): there is no package called 'knn'
+```
+
+``` r
+x <- cbind(x_train,y_train)
+```
+
+```
+## Error in cbind(x_train, y_train): object 'x_train' not found
+```
+
+``` r
+# Fitting model
+fit <-knn(y_train ~ ., data = x,k=5)
+```
+
+```
+## Error in knn(y_train ~ ., data = x, k = 5): could not find function "knn"
+```
+
+``` r
+summary(fit)
+```
+
+```
+## Error in summary(fit): object 'fit' not found
+```
+
+``` r
+# Predict Output 
+predicted= predict(fit,x_test)
+```
+
+```
+## Error in predict(fit, x_test): object 'fit' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/lasso.html b/Desktop/open-source/R/documentation/lasso.html
new file mode 100644
index 00000000..60cd2d50
--- /dev/null
+++ b/Desktop/open-source/R/documentation/lasso.html
@@ -0,0 +1,164 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">data(ggplot2::diamonds)
+</code></pre>
+<pre><code>## Warning in data(ggplot2::diamonds): data set 'ggplot2::diamonds' not found
+</code></pre>
+<pre><code class="language-r">library(caret)
+</code></pre>
+<pre><code>## Error in library(caret): there is no package called 'caret'
+</code></pre>
+<pre><code class="language-r">library(dplyr)
+</code></pre>
+<pre><code>## Error in library(dplyr): there is no package called 'dplyr'
+</code></pre>
+<pre><code class="language-r">dia.trans&lt;-bind_cols(diamonds %&gt;% select_if(is.numeric),
+                     model.matrix(~cut-1,diamonds) %&gt;% as_tibble(),
+                     model.matrix(~color-1,diamonds) %&gt;% as_tibble(),
+                     model.matrix(~clarity-1,diamonds) %&gt;% as_tibble())
+</code></pre>
+<pre><code>## Error in bind_cols(diamonds %&gt;% select_if(is.numeric), model.matrix(~cut - : could not find function &quot;bind_cols&quot;
+</code></pre>
+<pre><code class="language-r">#setting parameters alpha and lambda
+lasso_expand&lt;-expand.grid(alpha = 1, lambda = seq(0.001,0.1,by = 0.0005))
+lasso_mod &lt;- train(x=dia.trans %&gt;% select(-price), y=dia.trans$price, method='glmnet', 
+                   tuneGrid=lasso_expand)
+</code></pre>
+<pre><code>## Error in train(x = dia.trans %&gt;% select(-price), y = dia.trans$price, : could not find function &quot;train&quot;
+</code></pre>
+<pre><code class="language-r">#best tune
+lasso_mod$bestTune
+</code></pre>
+<pre><code>## Error: object 'lasso_mod' not found
+</code></pre>
+<pre><code class="language-r">lasso_mod$results$RMSE
+</code></pre>
+<pre><code>## Error: object 'lasso_mod' not found
+</code></pre>
+<pre><code class="language-r">lasso_imp&lt;-varImp(lasso_mod)
+</code></pre>
+<pre><code>## Error in varImp(lasso_mod): could not find function &quot;varImp&quot;
+</code></pre>
+<pre><code class="language-r">#get the importance of each feature and eliminate some of them
+lasso_imp$importance
+</code></pre>
+<pre><code>## Error: object 'lasso_imp' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/lasso.md b/Desktop/open-source/R/documentation/lasso.md
new file mode 100644
index 00000000..ce892790
--- /dev/null
+++ b/Desktop/open-source/R/documentation/lasso.md
@@ -0,0 +1,82 @@
+
+
+``` r
+data(ggplot2::diamonds)
+```
+
+```
+## Warning in data(ggplot2::diamonds): data set 'ggplot2::diamonds' not found
+```
+
+``` r
+library(caret)
+```
+
+```
+## Error in library(caret): there is no package called 'caret'
+```
+
+``` r
+library(dplyr)
+```
+
+```
+## Error in library(dplyr): there is no package called 'dplyr'
+```
+
+``` r
+dia.trans<-bind_cols(diamonds %>% select_if(is.numeric),
+                     model.matrix(~cut-1,diamonds) %>% as_tibble(),
+                     model.matrix(~color-1,diamonds) %>% as_tibble(),
+                     model.matrix(~clarity-1,diamonds) %>% as_tibble())
+```
+
+```
+## Error in bind_cols(diamonds %>% select_if(is.numeric), model.matrix(~cut - : could not find function "bind_cols"
+```
+
+``` r
+#setting parameters alpha and lambda
+lasso_expand<-expand.grid(alpha = 1, lambda = seq(0.001,0.1,by = 0.0005))
+lasso_mod <- train(x=dia.trans %>% select(-price), y=dia.trans$price, method='glmnet', 
+                   tuneGrid=lasso_expand)
+```
+
+```
+## Error in train(x = dia.trans %>% select(-price), y = dia.trans$price, : could not find function "train"
+```
+
+``` r
+#best tune
+lasso_mod$bestTune
+```
+
+```
+## Error: object 'lasso_mod' not found
+```
+
+``` r
+lasso_mod$results$RMSE
+```
+
+```
+## Error: object 'lasso_mod' not found
+```
+
+``` r
+lasso_imp<-varImp(lasso_mod)
+```
+
+```
+## Error in varImp(lasso_mod): could not find function "varImp"
+```
+
+``` r
+#get the importance of each feature and eliminate some of them
+lasso_imp$importance
+```
+
+```
+## Error: object 'lasso_imp' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/light_gbm.html b/Desktop/open-source/R/documentation/light_gbm.html
new file mode 100644
index 00000000..cb9105a1
--- /dev/null
+++ b/Desktop/open-source/R/documentation/light_gbm.html
@@ -0,0 +1,167 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(RLightGBM)
+</code></pre>
+<pre><code>## Error in library(RLightGBM): there is no package called 'RLightGBM'
+</code></pre>
+<pre><code class="language-r">data(example.binary)
+</code></pre>
+<pre><code>## Warning in data(example.binary): data set 'example.binary' not found
+</code></pre>
+<pre><code class="language-r">#Parameters
+
+num_iterations &lt;- 100
+config &lt;- list(objective = &quot;binary&quot;,  metric=&quot;binary_logloss,auc&quot;, learning_rate = 0.1, num_leaves = 63, tree_learner = &quot;serial&quot;, feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)
+
+#Create data handle and booster
+handle.data &lt;- lgbm.data.create(x)
+</code></pre>
+<pre><code>## Error in lgbm.data.create(x): could not find function &quot;lgbm.data.create&quot;
+</code></pre>
+<pre><code class="language-r">lgbm.data.setField(handle.data, &quot;label&quot;, y)
+</code></pre>
+<pre><code>## Error in lgbm.data.setField(handle.data, &quot;label&quot;, y): could not find function &quot;lgbm.data.setField&quot;
+</code></pre>
+<pre><code class="language-r">handle.booster &lt;- lgbm.booster.create(handle.data, lapply(config, as.character))
+</code></pre>
+<pre><code>## Error in lgbm.booster.create(handle.data, lapply(config, as.character)): could not find function &quot;lgbm.booster.create&quot;
+</code></pre>
+<pre><code class="language-r">#Train for num_iterations iterations and eval every 5 steps
+
+lgbm.booster.train(handle.booster, num_iterations, 5)
+</code></pre>
+<pre><code>## Error in lgbm.booster.train(handle.booster, num_iterations, 5): could not find function &quot;lgbm.booster.train&quot;
+</code></pre>
+<pre><code class="language-r">#Predict
+pred &lt;- lgbm.booster.predict(handle.booster, x.test)
+</code></pre>
+<pre><code>## Error in lgbm.booster.predict(handle.booster, x.test): could not find function &quot;lgbm.booster.predict&quot;
+</code></pre>
+<pre><code class="language-r">#Test accuracy
+sum(y.test == (y.pred &gt; 0.5)) / length(y.test)
+</code></pre>
+<pre><code>## Error: object 'y.test' not found
+</code></pre>
+<pre><code class="language-r">#Save model (can be loaded again via lgbm.booster.load(filename))
+lgbm.booster.save(handle.booster, filename = &quot;/tmp/model.txt&quot;)
+</code></pre>
+<pre><code>## Error in lgbm.booster.save(handle.booster, filename = &quot;/tmp/model.txt&quot;): could not find function &quot;lgbm.booster.save&quot;
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/light_gbm.md b/Desktop/open-source/R/documentation/light_gbm.md
new file mode 100644
index 00000000..7e77313c
--- /dev/null
+++ b/Desktop/open-source/R/documentation/light_gbm.md
@@ -0,0 +1,85 @@
+
+
+``` r
+library(RLightGBM)
+```
+
+```
+## Error in library(RLightGBM): there is no package called 'RLightGBM'
+```
+
+``` r
+data(example.binary)
+```
+
+```
+## Warning in data(example.binary): data set 'example.binary' not found
+```
+
+``` r
+#Parameters
+
+num_iterations <- 100
+config <- list(objective = "binary",  metric="binary_logloss,auc", learning_rate = 0.1, num_leaves = 63, tree_learner = "serial", feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)
+
+#Create data handle and booster
+handle.data <- lgbm.data.create(x)
+```
+
+```
+## Error in lgbm.data.create(x): could not find function "lgbm.data.create"
+```
+
+``` r
+lgbm.data.setField(handle.data, "label", y)
+```
+
+```
+## Error in lgbm.data.setField(handle.data, "label", y): could not find function "lgbm.data.setField"
+```
+
+``` r
+handle.booster <- lgbm.booster.create(handle.data, lapply(config, as.character))
+```
+
+```
+## Error in lgbm.booster.create(handle.data, lapply(config, as.character)): could not find function "lgbm.booster.create"
+```
+
+``` r
+#Train for num_iterations iterations and eval every 5 steps
+
+lgbm.booster.train(handle.booster, num_iterations, 5)
+```
+
+```
+## Error in lgbm.booster.train(handle.booster, num_iterations, 5): could not find function "lgbm.booster.train"
+```
+
+``` r
+#Predict
+pred <- lgbm.booster.predict(handle.booster, x.test)
+```
+
+```
+## Error in lgbm.booster.predict(handle.booster, x.test): could not find function "lgbm.booster.predict"
+```
+
+``` r
+#Test accuracy
+sum(y.test == (y.pred > 0.5)) / length(y.test)
+```
+
+```
+## Error: object 'y.test' not found
+```
+
+``` r
+#Save model (can be loaded again via lgbm.booster.load(filename))
+lgbm.booster.save(handle.booster, filename = "/tmp/model.txt")
+```
+
+```
+## Error in lgbm.booster.save(handle.booster, filename = "/tmp/model.txt"): could not find function "lgbm.booster.save"
+```
+
diff --git a/Desktop/open-source/R/documentation/linear_regression.html b/Desktop/open-source/R/documentation/linear_regression.html
new file mode 100644
index 00000000..ad04ea91
--- /dev/null
+++ b/Desktop/open-source/R/documentation/linear_regression.html
@@ -0,0 +1,152 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Load Train and Test datasets
+# Identify feature and response variable(s) and values must be numeric and numpy arrays
+x_train &lt;- input_variables_values_training_datasets
+</code></pre>
+<pre><code>## Error: object 'input_variables_values_training_datasets' not found
+</code></pre>
+<pre><code class="language-r">y_train &lt;- target_variables_values_training_datasets
+</code></pre>
+<pre><code>## Error: object 'target_variables_values_training_datasets' not found
+</code></pre>
+<pre><code class="language-r">x_test &lt;- input_variables_values_test_datasets
+</code></pre>
+<pre><code>## Error: object 'input_variables_values_test_datasets' not found
+</code></pre>
+<pre><code class="language-r">x &lt;- cbind(x_train,y_train)
+</code></pre>
+<pre><code>## Error in cbind(x_train, y_train): object 'x_train' not found
+</code></pre>
+<pre><code class="language-r"># Train the model using the training sets and check score
+linear &lt;- lm(y_train ~ ., data = x)
+</code></pre>
+<pre><code>## Error in model.frame.default(formula = y_train ~ ., data = x, drop.unused.levels = TRUE): 'data' must be a data.frame, environment, or list
+</code></pre>
+<pre><code class="language-r">summary(linear)
+</code></pre>
+<pre><code>## Error in summary(linear): object 'linear' not found
+</code></pre>
+<pre><code class="language-r"># Predict Output
+predicted= predict(linear,x_test) 
+</code></pre>
+<pre><code>## Error in predict(linear, x_test): object 'linear' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/linear_regression.md b/Desktop/open-source/R/documentation/linear_regression.md
new file mode 100644
index 00000000..600054e3
--- /dev/null
+++ b/Desktop/open-source/R/documentation/linear_regression.md
@@ -0,0 +1,62 @@
+
+
+``` r
+# Load Train and Test datasets
+# Identify feature and response variable(s) and values must be numeric and numpy arrays
+x_train <- input_variables_values_training_datasets
+```
+
+```
+## Error: object 'input_variables_values_training_datasets' not found
+```
+
+``` r
+y_train <- target_variables_values_training_datasets
+```
+
+```
+## Error: object 'target_variables_values_training_datasets' not found
+```
+
+``` r
+x_test <- input_variables_values_test_datasets
+```
+
+```
+## Error: object 'input_variables_values_test_datasets' not found
+```
+
+``` r
+x <- cbind(x_train,y_train)
+```
+
+```
+## Error in cbind(x_train, y_train): object 'x_train' not found
+```
+
+``` r
+# Train the model using the training sets and check score
+linear <- lm(y_train ~ ., data = x)
+```
+
+```
+## Error in model.frame.default(formula = y_train ~ ., data = x, drop.unused.levels = TRUE): 'data' must be a data.frame, environment, or list
+```
+
+``` r
+summary(linear)
+```
+
+```
+## Error in summary(linear): object 'linear' not found
+```
+
+``` r
+# Predict Output
+predicted= predict(linear,x_test) 
+```
+
+```
+## Error in predict(linear, x_test): object 'linear' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/linear_search.html b/Desktop/open-source/R/documentation/linear_search.html
new file mode 100644
index 00000000..7eb9157e
--- /dev/null
+++ b/Desktop/open-source/R/documentation/linear_search.html
@@ -0,0 +1,142 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">linear_search&lt;-function(vector, search_value){ #made a function named linear_search having two parameters that are an array and a value to be searched
+  for(i in 1:length(vector)){ 
+    if(vector[i]==search_value){ #comparing each value of array with the value to be searched
+      return (i)
+    }
+  }
+  return (-1)
+}
+
+user_vec&lt;- c(10,20,30,40,50,60) #input array (hard code)
+user_val&lt;-30 #input value to be searched (hard code)
+
+result&lt;-linear_search(user_vec,user_val) #linear_seach function calling
+
+if(result!=-1){
+  cat(&quot;Searched value&quot;, user_val, &quot;found at index&quot;, result-1) #displaying the index at which value is found (if any)
+}else{
+  cat(&quot;Searched value does not exist in array&quot;)
+}
+</code></pre>
+<pre><code>## Searched value 30 found at index 2
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/linear_search.md b/Desktop/open-source/R/documentation/linear_search.md
new file mode 100644
index 00000000..7ce26245
--- /dev/null
+++ b/Desktop/open-source/R/documentation/linear_search.md
@@ -0,0 +1,28 @@
+
+
+``` r
+linear_search<-function(vector, search_value){ #made a function named linear_search having two parameters that are an array and a value to be searched
+  for(i in 1:length(vector)){ 
+    if(vector[i]==search_value){ #comparing each value of array with the value to be searched
+      return (i)
+    }
+  }
+  return (-1)
+}
+
+user_vec<- c(10,20,30,40,50,60) #input array (hard code)
+user_val<-30 #input value to be searched (hard code)
+
+result<-linear_search(user_vec,user_val) #linear_seach function calling
+
+if(result!=-1){
+  cat("Searched value", user_val, "found at index", result-1) #displaying the index at which value is found (if any)
+}else{
+  cat("Searched value does not exist in array")
+}
+```
+
+```
+## Searched value 30 found at index 2
+```
+
diff --git a/Desktop/open-source/R/documentation/linearregressionrawr.html b/Desktop/open-source/R/documentation/linearregressionrawr.html
new file mode 100644
index 00000000..11895f9c
--- /dev/null
+++ b/Desktop/open-source/R/documentation/linearregressionrawr.html
@@ -0,0 +1,133 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">ols&lt;-function(y,x){
+    data&lt;-model.matrix(y ~ ., data = x)
+    decomp &lt;- svd(data)
+    return(decomp$v %*% diag(1 / decomp$d) %*% t(decomp$u) %*% y)
+  }
+
+set.seed(1)
+x &lt;- rnorm(1000)
+y &lt;- 4 * x + rnorm(1000, sd = .5)
+ols(y=y,x=matrix(x, ncol = 1))
+</code></pre>
+<pre><code>## Error in terms.formula(object, data = data): '.' in formula and no 'data' argument
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/linearregressionrawr.md b/Desktop/open-source/R/documentation/linearregressionrawr.md
new file mode 100644
index 00000000..8a3180a5
--- /dev/null
+++ b/Desktop/open-source/R/documentation/linearregressionrawr.md
@@ -0,0 +1,19 @@
+
+
+``` r
+ols<-function(y,x){
+    data<-model.matrix(y ~ ., data = x)
+    decomp <- svd(data)
+    return(decomp$v %*% diag(1 / decomp$d) %*% t(decomp$u) %*% y)
+  }
+
+set.seed(1)
+x <- rnorm(1000)
+y <- 4 * x + rnorm(1000, sd = .5)
+ols(y=y,x=matrix(x, ncol = 1))
+```
+
+```
+## Error in terms.formula(object, data = data): '.' in formula and no 'data' argument
+```
+
diff --git a/Desktop/open-source/R/documentation/logistic_regression.html b/Desktop/open-source/R/documentation/logistic_regression.html
new file mode 100644
index 00000000..36256448
--- /dev/null
+++ b/Desktop/open-source/R/documentation/logistic_regression.html
@@ -0,0 +1,138 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">x &lt;- cbind(x_train,y_train)
+</code></pre>
+<pre><code>## Error in cbind(x_train, y_train): object 'x_train' not found
+</code></pre>
+<pre><code class="language-r"># Train the model using the training sets and check score
+logistic &lt;- glm(y_train ~ ., data = x,family='binomial')
+</code></pre>
+<pre><code>## Error in model.frame.default(formula = y_train ~ ., data = x, drop.unused.levels = TRUE): 'data' must be a data.frame, environment, or list
+</code></pre>
+<pre><code class="language-r">summary(logistic)
+</code></pre>
+<pre><code>## Error in summary(logistic): object 'logistic' not found
+</code></pre>
+<pre><code class="language-r"># Predict Output
+predicted= predict(logistic,x_test)
+</code></pre>
+<pre><code>## Error in predict(logistic, x_test): object 'logistic' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/logistic_regression.md b/Desktop/open-source/R/documentation/logistic_regression.md
new file mode 100644
index 00000000..5a938752
--- /dev/null
+++ b/Desktop/open-source/R/documentation/logistic_regression.md
@@ -0,0 +1,36 @@
+
+
+``` r
+x <- cbind(x_train,y_train)
+```
+
+```
+## Error in cbind(x_train, y_train): object 'x_train' not found
+```
+
+``` r
+# Train the model using the training sets and check score
+logistic <- glm(y_train ~ ., data = x,family='binomial')
+```
+
+```
+## Error in model.frame.default(formula = y_train ~ ., data = x, drop.unused.levels = TRUE): 'data' must be a data.frame, environment, or list
+```
+
+``` r
+summary(logistic)
+```
+
+```
+## Error in summary(logistic): object 'logistic' not found
+```
+
+``` r
+# Predict Output
+predicted= predict(logistic,x_test)
+```
+
+```
+## Error in predict(logistic, x_test): object 'logistic' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/logistic_regression_2.html b/Desktop/open-source/R/documentation/logistic_regression_2.html
new file mode 100644
index 00000000..e1d88cb4
--- /dev/null
+++ b/Desktop/open-source/R/documentation/logistic_regression_2.html
@@ -0,0 +1,137 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Introduction to logistic regression
+
+# glm stands for Generalized Linear Model
+mod1 &lt;- glm(y_data~x_data, data=name_of_the_dataframe, family=&quot;binomial&quot;)
+</code></pre>
+<pre><code>## Error in is.data.frame(data): object 'name_of_the_dataframe' not found
+</code></pre>
+<pre><code class="language-r"># displays the output of the model computed by the previous line
+summary(mod1)
+</code></pre>
+<pre><code>## Error in summary(mod1): object 'mod1' not found
+</code></pre>
+<pre><code class="language-r"># modeled data : it predicts the output for x_test_data as input information for the model
+predicted &lt;- predict(mod1, x_test_data)
+</code></pre>
+<pre><code>## Error in predict(mod1, x_test_data): object 'mod1' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/logistic_regression_2.md b/Desktop/open-source/R/documentation/logistic_regression_2.md
new file mode 100644
index 00000000..6418465c
--- /dev/null
+++ b/Desktop/open-source/R/documentation/logistic_regression_2.md
@@ -0,0 +1,31 @@
+
+
+``` r
+# Introduction to logistic regression
+
+# glm stands for Generalized Linear Model
+mod1 <- glm(y_data~x_data, data=name_of_the_dataframe, family="binomial")
+```
+
+```
+## Error in is.data.frame(data): object 'name_of_the_dataframe' not found
+```
+
+``` r
+# displays the output of the model computed by the previous line
+summary(mod1)
+```
+
+```
+## Error in summary(mod1): object 'mod1' not found
+```
+
+``` r
+# modeled data : it predicts the output for x_test_data as input information for the model
+predicted <- predict(mod1, x_test_data)
+```
+
+```
+## Error in predict(mod1, x_test_data): object 'mod1' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/longest_common_subsequence.html b/Desktop/open-source/R/documentation/longest_common_subsequence.html
new file mode 100644
index 00000000..cb059c0a
--- /dev/null
+++ b/Desktop/open-source/R/documentation/longest_common_subsequence.html
@@ -0,0 +1,647 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Longest Common Subsequence (LCS) Algorithm
+#
+# The LCS problem finds the longest subsequence common to two sequences.
+# A subsequence is a sequence derived from another sequence by deleting some 
+# or no elements without changing the order of the remaining elements.
+#
+# Time Complexity: O(m * n) where m, n are lengths of the sequences
+# Space Complexity: O(m * n) for the DP table, O(min(m, n)) optimized version
+#
+# Applications:
+# - DNA sequence analysis in bioinformatics
+# - File difference utilities (diff command)  
+# - Version control systems (git diff)
+# - Plagiarism detection
+# - Data compression algorithms
+# - Edit distance calculations
+
+# Basic LCS algorithm with full DP table
+lcs_length &lt;- function(str1, str2) {
+  #' Find the length of longest common subsequence
+  #' @param str1: First string
+  #' @param str2: Second string  
+  #' @return: Length of LCS
+  
+  m &lt;- nchar(str1)
+  n &lt;- nchar(str2)
+  
+  # Create DP table
+  dp &lt;- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] &lt;- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        dp[i, j] &lt;- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] &lt;- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  return(dp[m + 1, n + 1])
+}
+
+# LCS algorithm that returns the actual subsequence
+lcs_string &lt;- function(str1, str2) {
+  #' Find the longest common subsequence string
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @return: List containing LCS string and its length
+  
+  m &lt;- nchar(str1)
+  n &lt;- nchar(str2)
+  
+  # Create DP table
+  dp &lt;- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] &lt;- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        dp[i, j] &lt;- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] &lt;- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  # Backtrack to find the actual LCS string
+  lcs &lt;- &quot;&quot;
+  i &lt;- m + 1
+  j &lt;- n + 1
+  
+  while (i &gt; 1 &amp;&amp; j &gt; 1) {
+    if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+      lcs &lt;- paste0(substr(str1, i - 1, i - 1), lcs)
+      i &lt;- i - 1
+      j &lt;- j - 1
+    } else if (dp[i - 1, j] &gt; dp[i, j - 1]) {
+      i &lt;- i - 1
+    } else {
+      j &lt;- j - 1
+    }
+  }
+  
+  return(list(
+    lcs = lcs,
+    length = dp[m + 1, n + 1],
+    dp_table = dp
+  ))
+}
+
+# Space-optimized LCS (only returns length)
+lcs_length_optimized &lt;- function(str1, str2) {
+  #' Space-optimized LCS length calculation
+  #' Uses only O(min(m, n)) space instead of O(m * n)
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @return: Length of LCS
+  
+  m &lt;- nchar(str1)
+  n &lt;- nchar(str2)
+  
+  # Make str1 the shorter string for space optimization
+  if (m &gt; n) {
+    temp &lt;- str1
+    str1 &lt;- str2
+    str2 &lt;- temp
+    temp &lt;- m
+    m &lt;- n
+    n &lt;- temp
+  }
+  
+  # Use two arrays instead of full matrix
+  prev &lt;- rep(0, m + 1)
+  curr &lt;- rep(0, m + 1)
+  
+  for (j in 1:(n + 1)) {
+    for (i in 1:(m + 1)) {
+      if (i == 1 || j == 1) {
+        curr[i] &lt;- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        curr[i] &lt;- prev[i - 1] + 1
+      } else {
+        curr[i] &lt;- max(prev[i], curr[i - 1])
+      }
+    }
+    # Swap arrays
+    temp &lt;- prev
+    prev &lt;- curr
+    curr &lt;- temp
+  }
+  
+  return(prev[m + 1])
+}
+
+# Find all possible LCS strings (there can be multiple)
+find_all_lcs &lt;- function(str1, str2) {
+  #' Find all possible longest common subsequences
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @return: List of all LCS strings
+  
+  m &lt;- nchar(str1)
+  n &lt;- nchar(str2)
+  
+  # Create DP table
+  dp &lt;- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] &lt;- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        dp[i, j] &lt;- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] &lt;- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  # Recursive function to find all LCS
+  find_all_lcs_recursive &lt;- function(i, j) {
+    if (i == 1 || j == 1) {
+      return(&quot;&quot;)
+    }
+    
+    if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+      char &lt;- substr(str1, i - 1, i - 1)
+      prev_lcs &lt;- find_all_lcs_recursive(i - 1, j - 1)
+      return(paste0(prev_lcs, char))
+    } else {
+      results &lt;- c()
+      
+      if (dp[i - 1, j] == dp[i, j]) {
+        results &lt;- c(results, find_all_lcs_recursive(i - 1, j))
+      }
+      
+      if (dp[i, j - 1] == dp[i, j]) {
+        results &lt;- c(results, find_all_lcs_recursive(i, j - 1))
+      }
+      
+      return(unique(results))
+    }
+  }
+  
+  all_lcs &lt;- find_all_lcs_recursive(m + 1, n + 1)
+  return(unique(all_lcs))
+}
+
+# LCS for arrays/vectors instead of strings
+lcs_array &lt;- function(arr1, arr2) {
+  #' Find LCS of two arrays/vectors
+  #' @param arr1: First array
+  #' @param arr2: Second array
+  #' @return: List with LCS array and length
+  
+  m &lt;- length(arr1)
+  n &lt;- length(arr2)
+  
+  # Create DP table
+  dp &lt;- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] &lt;- 0
+      } else if (arr1[i - 1] == arr2[j - 1]) {
+        dp[i, j] &lt;- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] &lt;- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  # Backtrack to find the actual LCS
+  lcs &lt;- c()
+  i &lt;- m + 1
+  j &lt;- n + 1
+  
+  while (i &gt; 1 &amp;&amp; j &gt; 1) {
+    if (arr1[i - 1] == arr2[j - 1]) {
+      lcs &lt;- c(arr1[i - 1], lcs)
+      i &lt;- i - 1
+      j &lt;- j - 1
+    } else if (dp[i - 1, j] &gt; dp[i, j - 1]) {
+      i &lt;- i - 1
+    } else {
+      j &lt;- j - 1
+    }
+  }
+  
+  return(list(
+    lcs = lcs,
+    length = dp[m + 1, n + 1]
+  ))
+}
+
+# Function to print the DP table (for educational purposes)
+print_dp_table &lt;- function(str1, str2, dp_table) {
+  #' Print the DP table in a readable format
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @param dp_table: DP table from lcs_string function
+  
+  m &lt;- nchar(str1)
+  n &lt;- nchar(str2)
+  
+  cat(&quot;DP Table for LCS calculation:\n&quot;)
+  cat(&quot;String 1:&quot;, str1, &quot;\n&quot;)
+  cat(&quot;String 2:&quot;, str2, &quot;\n\n&quot;)
+  
+  # Print column headers
+  cat(&quot;     ε &quot;)
+  for (j in 1:n) {
+    cat(sprintf(&quot;%2s &quot;, substr(str2, j, j)))
+  }
+  cat(&quot;\n&quot;)
+  
+  # Print table rows
+  for (i in 1:(m + 1)) {
+    if (i == 1) {
+      cat(&quot;  ε  &quot;)
+    } else {
+      cat(sprintf(&quot;%2s   &quot;, substr(str1, i - 1, i - 1)))
+    }
+    
+    for (j in 1:(n + 1)) {
+      cat(sprintf(&quot;%2d &quot;, dp_table[i, j]))
+    }
+    cat(&quot;\n&quot;)
+  }
+  cat(&quot;\n&quot;)
+}
+
+# Example usage and testing
+cat(&quot;=== Longest Common Subsequence (LCS) Algorithm ===\n\n&quot;)
+</code></pre>
+<pre><code>## === Longest Common Subsequence (LCS) Algorithm ===
+</code></pre>
+<pre><code class="language-r"># Test 1: Basic LCS example
+cat(&quot;1. Basic LCS Example\n&quot;)
+</code></pre>
+<pre><code>## 1. Basic LCS Example
+</code></pre>
+<pre><code class="language-r">str1 &lt;- &quot;ABCDGH&quot;
+str2 &lt;- &quot;AEDFHR&quot;
+
+cat(&quot;String 1:&quot;, str1, &quot;\n&quot;)
+</code></pre>
+<pre><code>## String 1: ABCDGH
+</code></pre>
+<pre><code class="language-r">cat(&quot;String 2:&quot;, str2, &quot;\n&quot;)
+</code></pre>
+<pre><code>## String 2: AEDFHR
+</code></pre>
+<pre><code class="language-r">result1 &lt;- lcs_string(str1, str2)
+cat(&quot;LCS:&quot;, result1$lcs, &quot;\n&quot;)
+</code></pre>
+<pre><code>## LCS: ADH
+</code></pre>
+<pre><code class="language-r">cat(&quot;Length:&quot;, result1$length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Length: 3
+</code></pre>
+<pre><code class="language-r">print_dp_table(str1, str2, result1$dp_table)
+</code></pre>
+<pre><code>## DP Table for LCS calculation:
+## String 1: ABCDGH 
+## String 2: AEDFHR 
+## 
+##      ε  A  E  D  F  H  R 
+##   ε   0  0  0  0  0  0  0 
+##  A    0  1  1  1  1  1  1 
+##  B    0  1  1  1  1  1  1 
+##  C    0  1  1  1  1  1  1 
+##  D    0  1  1  2  2  2  2 
+##  G    0  1  1  2  2  2  2 
+##  H    0  1  1  2  2  3  3
+</code></pre>
+<pre><code class="language-r"># Test 2: DNA sequence analysis
+cat(&quot;2. DNA Sequence Analysis\n&quot;)
+</code></pre>
+<pre><code>## 2. DNA Sequence Analysis
+</code></pre>
+<pre><code class="language-r">dna1 &lt;- &quot;ATCGATCGATCG&quot;
+dna2 &lt;- &quot;ATGCGATGCATG&quot;
+
+cat(&quot;DNA Sequence 1:&quot;, dna1, &quot;\n&quot;)
+</code></pre>
+<pre><code>## DNA Sequence 1: ATCGATCGATCG
+</code></pre>
+<pre><code class="language-r">cat(&quot;DNA Sequence 2:&quot;, dna2, &quot;\n&quot;)
+</code></pre>
+<pre><code>## DNA Sequence 2: ATGCGATGCATG
+</code></pre>
+<pre><code class="language-r">dna_result &lt;- lcs_string(dna1, dna2)
+cat(&quot;Common subsequence:&quot;, dna_result$lcs, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Common subsequence: ATCGATGATG
+</code></pre>
+<pre><code class="language-r">cat(&quot;Length:&quot;, dna_result$length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Length: 10
+</code></pre>
+<pre><code class="language-r">cat(&quot;Similarity:&quot;, sprintf(&quot;%.2f%%&quot;, dna_result$length / max(nchar(dna1), nchar(dna2)) * 100), &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Similarity: 83.33%
+</code></pre>
+<pre><code class="language-r"># Test 3: Finding all possible LCS
+cat(&quot;3. Multiple LCS Solutions\n&quot;)
+</code></pre>
+<pre><code>## 3. Multiple LCS Solutions
+</code></pre>
+<pre><code class="language-r">str3 &lt;- &quot;ABCDEF&quot;
+str4 &lt;- &quot;ACBDEF&quot;
+
+cat(&quot;String 1:&quot;, str3, &quot;\n&quot;)
+</code></pre>
+<pre><code>## String 1: ABCDEF
+</code></pre>
+<pre><code class="language-r">cat(&quot;String 2:&quot;, str4, &quot;\n&quot;)
+</code></pre>
+<pre><code>## String 2: ACBDEF
+</code></pre>
+<pre><code class="language-r">all_lcs &lt;- find_all_lcs(str3, str4)
+cat(&quot;All possible LCS:\n&quot;)
+</code></pre>
+<pre><code>## All possible LCS:
+</code></pre>
+<pre><code class="language-r">for (i in seq_along(all_lcs)) {
+  cat(&quot;  &quot;, i, &quot;:&quot;, all_lcs[i], &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>##    1 : ABDEF 
+##    2 : ACDEF
+</code></pre>
+<pre><code class="language-r">cat(&quot;\n&quot;)
+</code></pre>
+<pre><code class="language-r"># Test 4: Array LCS example
+cat(&quot;4. Array LCS Example\n&quot;)
+</code></pre>
+<pre><code>## 4. Array LCS Example
+</code></pre>
+<pre><code class="language-r">arr1 &lt;- c(1, 2, 3, 4, 5)
+arr2 &lt;- c(2, 3, 5, 7, 8)
+
+cat(&quot;Array 1:&quot;, paste(arr1, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Array 1: 1, 2, 3, 4, 5
+</code></pre>
+<pre><code class="language-r">cat(&quot;Array 2:&quot;, paste(arr2, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Array 2: 2, 3, 5, 7, 8
+</code></pre>
+<pre><code class="language-r">arr_result &lt;- lcs_array(arr1, arr2)
+cat(&quot;LCS Array:&quot;, paste(arr_result$lcs, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## LCS Array: 2, 3, 5
+</code></pre>
+<pre><code class="language-r">cat(&quot;Length:&quot;, arr_result$length, &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Length: 3
+</code></pre>
+<pre><code class="language-r"># Test 5: Performance comparison
+cat(&quot;5. Performance Comparison\n&quot;)
+</code></pre>
+<pre><code>## 5. Performance Comparison
+</code></pre>
+<pre><code class="language-r">long_str1 &lt;- paste(sample(LETTERS[1:5], 100, replace = TRUE), collapse = &quot;&quot;)
+long_str2 &lt;- paste(sample(LETTERS[1:5], 100, replace = TRUE), collapse = &quot;&quot;)
+
+cat(&quot;Testing with strings of length 100...\n&quot;)
+</code></pre>
+<pre><code>## Testing with strings of length 100...
+</code></pre>
+<pre><code class="language-r"># Standard algorithm
+start_time &lt;- Sys.time()
+standard_result &lt;- lcs_length(long_str1, long_str2)
+standard_time &lt;- as.numeric(Sys.time() - start_time, units = &quot;secs&quot;)
+
+# Optimized algorithm  
+start_time &lt;- Sys.time()
+optimized_result &lt;- lcs_length_optimized(long_str1, long_str2)
+optimized_time &lt;- as.numeric(Sys.time() - start_time, units = &quot;secs&quot;)
+
+cat(&quot;Standard algorithm: LCS length =&quot;, standard_result, 
+    &quot;Time:&quot;, sprintf(&quot;%.6f&quot;, standard_time), &quot;seconds\n&quot;)
+</code></pre>
+<pre><code>## Standard algorithm: LCS length = 59 Time: 0.052980 seconds
+</code></pre>
+<pre><code class="language-r">cat(&quot;Optimized algorithm: LCS length =&quot;, optimized_result, 
+    &quot;Time:&quot;, sprintf(&quot;%.6f&quot;, optimized_time), &quot;seconds\n&quot;)
+</code></pre>
+<pre><code>## Optimized algorithm: LCS length = 59 Time: 0.049993 seconds
+</code></pre>
+<pre><code class="language-r">cat(&quot;Results match:&quot;, standard_result == optimized_result, &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Results match: TRUE
+</code></pre>
+<pre><code class="language-r"># Test 6: Edge cases
+cat(&quot;6. Edge Cases\n&quot;)
+</code></pre>
+<pre><code>## 6. Edge Cases
+</code></pre>
+<pre><code class="language-r">cat(&quot;Empty strings:&quot;, lcs_length(&quot;&quot;, &quot;ABC&quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Empty strings: 0
+</code></pre>
+<pre><code class="language-r">cat(&quot;One empty string:&quot;, lcs_length(&quot;ABC&quot;, &quot;&quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## One empty string: 0
+</code></pre>
+<pre><code class="language-r">cat(&quot;Identical strings:&quot;, lcs_length(&quot;HELLO&quot;, &quot;HELLO&quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Identical strings: 5
+</code></pre>
+<pre><code class="language-r">cat(&quot;No common characters:&quot;, lcs_length(&quot;ABC&quot;, &quot;DEF&quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## No common characters: 0
+</code></pre>
+<pre><code class="language-r">cat(&quot;Single character:&quot;, lcs_length(&quot;A&quot;, &quot;A&quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Single character: 1
+</code></pre>
+<pre><code class="language-r">cat(&quot;Single vs multiple:&quot;, lcs_length(&quot;A&quot;, &quot;ABCDEF&quot;), &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Single vs multiple: 1
+</code></pre>
+<pre><code class="language-r"># Test 7: Real-world example - File diff simulation
+cat(&quot;7. File Diff Simulation\n&quot;)
+</code></pre>
+<pre><code>## 7. File Diff Simulation
+</code></pre>
+<pre><code class="language-r">file1_lines &lt;- c(&quot;Hello World&quot;, &quot;This is line 2&quot;, &quot;Line 3 here&quot;, &quot;Final line&quot;)
+file2_lines &lt;- c(&quot;Hello World&quot;, &quot;This is modified line 2&quot;, &quot;Line 3 here&quot;, &quot;New line&quot;, &quot;Final line&quot;)
+
+cat(&quot;File 1 lines:\n&quot;)
+</code></pre>
+<pre><code>## File 1 lines:
+</code></pre>
+<pre><code class="language-r">for (i in seq_along(file1_lines)) {
+  cat(&quot; &quot;, i, &quot;:&quot;, file1_lines[i], &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>##   1 : Hello World 
+##   2 : This is line 2 
+##   3 : Line 3 here 
+##   4 : Final line
+</code></pre>
+<pre><code class="language-r">cat(&quot;File 2 lines:\n&quot;)
+</code></pre>
+<pre><code>## File 2 lines:
+</code></pre>
+<pre><code class="language-r">for (i in seq_along(file2_lines)) {
+  cat(&quot; &quot;, i, &quot;:&quot;, file2_lines[i], &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>##   1 : Hello World 
+##   2 : This is modified line 2 
+##   3 : Line 3 here 
+##   4 : New line 
+##   5 : Final line
+</code></pre>
+<pre><code class="language-r">file_lcs &lt;- lcs_array(file1_lines, file2_lines)
+cat(&quot;Common lines (unchanged):\n&quot;)
+</code></pre>
+<pre><code>## Common lines (unchanged):
+</code></pre>
+<pre><code class="language-r">for (i in seq_along(file_lcs$lcs)) {
+  cat(&quot; &quot;, file_lcs$lcs[i], &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>##   Hello World 
+##   Line 3 here 
+##   Final line
+</code></pre>
+<pre><code class="language-r">cat(&quot;Similarity:&quot;, sprintf(&quot;%.1f%%&quot;, file_lcs$length / max(length(file1_lines), length(file2_lines)) * 100), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Similarity: 60.0%
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/longest_common_subsequence.md b/Desktop/open-source/R/documentation/longest_common_subsequence.md
new file mode 100644
index 00000000..b0eb4b87
--- /dev/null
+++ b/Desktop/open-source/R/documentation/longest_common_subsequence.md
@@ -0,0 +1,703 @@
+
+
+``` r
+# Longest Common Subsequence (LCS) Algorithm
+#
+# The LCS problem finds the longest subsequence common to two sequences.
+# A subsequence is a sequence derived from another sequence by deleting some 
+# or no elements without changing the order of the remaining elements.
+#
+# Time Complexity: O(m * n) where m, n are lengths of the sequences
+# Space Complexity: O(m * n) for the DP table, O(min(m, n)) optimized version
+#
+# Applications:
+# - DNA sequence analysis in bioinformatics
+# - File difference utilities (diff command)  
+# - Version control systems (git diff)
+# - Plagiarism detection
+# - Data compression algorithms
+# - Edit distance calculations
+
+# Basic LCS algorithm with full DP table
+lcs_length <- function(str1, str2) {
+  #' Find the length of longest common subsequence
+  #' @param str1: First string
+  #' @param str2: Second string  
+  #' @return: Length of LCS
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  # Create DP table
+  dp <- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] <- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        dp[i, j] <- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] <- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  return(dp[m + 1, n + 1])
+}
+
+# LCS algorithm that returns the actual subsequence
+lcs_string <- function(str1, str2) {
+  #' Find the longest common subsequence string
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @return: List containing LCS string and its length
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  # Create DP table
+  dp <- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] <- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        dp[i, j] <- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] <- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  # Backtrack to find the actual LCS string
+  lcs <- ""
+  i <- m + 1
+  j <- n + 1
+  
+  while (i > 1 && j > 1) {
+    if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+      lcs <- paste0(substr(str1, i - 1, i - 1), lcs)
+      i <- i - 1
+      j <- j - 1
+    } else if (dp[i - 1, j] > dp[i, j - 1]) {
+      i <- i - 1
+    } else {
+      j <- j - 1
+    }
+  }
+  
+  return(list(
+    lcs = lcs,
+    length = dp[m + 1, n + 1],
+    dp_table = dp
+  ))
+}
+
+# Space-optimized LCS (only returns length)
+lcs_length_optimized <- function(str1, str2) {
+  #' Space-optimized LCS length calculation
+  #' Uses only O(min(m, n)) space instead of O(m * n)
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @return: Length of LCS
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  # Make str1 the shorter string for space optimization
+  if (m > n) {
+    temp <- str1
+    str1 <- str2
+    str2 <- temp
+    temp <- m
+    m <- n
+    n <- temp
+  }
+  
+  # Use two arrays instead of full matrix
+  prev <- rep(0, m + 1)
+  curr <- rep(0, m + 1)
+  
+  for (j in 1:(n + 1)) {
+    for (i in 1:(m + 1)) {
+      if (i == 1 || j == 1) {
+        curr[i] <- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        curr[i] <- prev[i - 1] + 1
+      } else {
+        curr[i] <- max(prev[i], curr[i - 1])
+      }
+    }
+    # Swap arrays
+    temp <- prev
+    prev <- curr
+    curr <- temp
+  }
+  
+  return(prev[m + 1])
+}
+
+# Find all possible LCS strings (there can be multiple)
+find_all_lcs <- function(str1, str2) {
+  #' Find all possible longest common subsequences
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @return: List of all LCS strings
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  # Create DP table
+  dp <- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] <- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        dp[i, j] <- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] <- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  # Recursive function to find all LCS
+  find_all_lcs_recursive <- function(i, j) {
+    if (i == 1 || j == 1) {
+      return("")
+    }
+    
+    if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+      char <- substr(str1, i - 1, i - 1)
+      prev_lcs <- find_all_lcs_recursive(i - 1, j - 1)
+      return(paste0(prev_lcs, char))
+    } else {
+      results <- c()
+      
+      if (dp[i - 1, j] == dp[i, j]) {
+        results <- c(results, find_all_lcs_recursive(i - 1, j))
+      }
+      
+      if (dp[i, j - 1] == dp[i, j]) {
+        results <- c(results, find_all_lcs_recursive(i, j - 1))
+      }
+      
+      return(unique(results))
+    }
+  }
+  
+  all_lcs <- find_all_lcs_recursive(m + 1, n + 1)
+  return(unique(all_lcs))
+}
+
+# LCS for arrays/vectors instead of strings
+lcs_array <- function(arr1, arr2) {
+  #' Find LCS of two arrays/vectors
+  #' @param arr1: First array
+  #' @param arr2: Second array
+  #' @return: List with LCS array and length
+  
+  m <- length(arr1)
+  n <- length(arr2)
+  
+  # Create DP table
+  dp <- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] <- 0
+      } else if (arr1[i - 1] == arr2[j - 1]) {
+        dp[i, j] <- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] <- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  # Backtrack to find the actual LCS
+  lcs <- c()
+  i <- m + 1
+  j <- n + 1
+  
+  while (i > 1 && j > 1) {
+    if (arr1[i - 1] == arr2[j - 1]) {
+      lcs <- c(arr1[i - 1], lcs)
+      i <- i - 1
+      j <- j - 1
+    } else if (dp[i - 1, j] > dp[i, j - 1]) {
+      i <- i - 1
+    } else {
+      j <- j - 1
+    }
+  }
+  
+  return(list(
+    lcs = lcs,
+    length = dp[m + 1, n + 1]
+  ))
+}
+
+# Function to print the DP table (for educational purposes)
+print_dp_table <- function(str1, str2, dp_table) {
+  #' Print the DP table in a readable format
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @param dp_table: DP table from lcs_string function
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  cat("DP Table for LCS calculation:\n")
+  cat("String 1:", str1, "\n")
+  cat("String 2:", str2, "\n\n")
+  
+  # Print column headers
+  cat("     ε ")
+  for (j in 1:n) {
+    cat(sprintf("%2s ", substr(str2, j, j)))
+  }
+  cat("\n")
+  
+  # Print table rows
+  for (i in 1:(m + 1)) {
+    if (i == 1) {
+      cat("  ε  ")
+    } else {
+      cat(sprintf("%2s   ", substr(str1, i - 1, i - 1)))
+    }
+    
+    for (j in 1:(n + 1)) {
+      cat(sprintf("%2d ", dp_table[i, j]))
+    }
+    cat("\n")
+  }
+  cat("\n")
+}
+
+# Example usage and testing
+cat("=== Longest Common Subsequence (LCS) Algorithm ===\n\n")
+```
+
+```
+## === Longest Common Subsequence (LCS) Algorithm ===
+```
+
+``` r
+# Test 1: Basic LCS example
+cat("1. Basic LCS Example\n")
+```
+
+```
+## 1. Basic LCS Example
+```
+
+``` r
+str1 <- "ABCDGH"
+str2 <- "AEDFHR"
+
+cat("String 1:", str1, "\n")
+```
+
+```
+## String 1: ABCDGH
+```
+
+``` r
+cat("String 2:", str2, "\n")
+```
+
+```
+## String 2: AEDFHR
+```
+
+``` r
+result1 <- lcs_string(str1, str2)
+cat("LCS:", result1$lcs, "\n")
+```
+
+```
+## LCS: ADH
+```
+
+``` r
+cat("Length:", result1$length, "\n")
+```
+
+```
+## Length: 3
+```
+
+``` r
+print_dp_table(str1, str2, result1$dp_table)
+```
+
+```
+## DP Table for LCS calculation:
+## String 1: ABCDGH 
+## String 2: AEDFHR 
+## 
+##      ε  A  E  D  F  H  R 
+##   ε   0  0  0  0  0  0  0 
+##  A    0  1  1  1  1  1  1 
+##  B    0  1  1  1  1  1  1 
+##  C    0  1  1  1  1  1  1 
+##  D    0  1  1  2  2  2  2 
+##  G    0  1  1  2  2  2  2 
+##  H    0  1  1  2  2  3  3
+```
+
+``` r
+# Test 2: DNA sequence analysis
+cat("2. DNA Sequence Analysis\n")
+```
+
+```
+## 2. DNA Sequence Analysis
+```
+
+``` r
+dna1 <- "ATCGATCGATCG"
+dna2 <- "ATGCGATGCATG"
+
+cat("DNA Sequence 1:", dna1, "\n")
+```
+
+```
+## DNA Sequence 1: ATCGATCGATCG
+```
+
+``` r
+cat("DNA Sequence 2:", dna2, "\n")
+```
+
+```
+## DNA Sequence 2: ATGCGATGCATG
+```
+
+``` r
+dna_result <- lcs_string(dna1, dna2)
+cat("Common subsequence:", dna_result$lcs, "\n")
+```
+
+```
+## Common subsequence: ATCGATGATG
+```
+
+``` r
+cat("Length:", dna_result$length, "\n")
+```
+
+```
+## Length: 10
+```
+
+``` r
+cat("Similarity:", sprintf("%.2f%%", dna_result$length / max(nchar(dna1), nchar(dna2)) * 100), "\n\n")
+```
+
+```
+## Similarity: 83.33%
+```
+
+``` r
+# Test 3: Finding all possible LCS
+cat("3. Multiple LCS Solutions\n")
+```
+
+```
+## 3. Multiple LCS Solutions
+```
+
+``` r
+str3 <- "ABCDEF"
+str4 <- "ACBDEF"
+
+cat("String 1:", str3, "\n")
+```
+
+```
+## String 1: ABCDEF
+```
+
+``` r
+cat("String 2:", str4, "\n")
+```
+
+```
+## String 2: ACBDEF
+```
+
+``` r
+all_lcs <- find_all_lcs(str3, str4)
+cat("All possible LCS:\n")
+```
+
+```
+## All possible LCS:
+```
+
+``` r
+for (i in seq_along(all_lcs)) {
+  cat("  ", i, ":", all_lcs[i], "\n")
+}
+```
+
+```
+##    1 : ABDEF 
+##    2 : ACDEF
+```
+
+``` r
+cat("\n")
+```
+
+``` r
+# Test 4: Array LCS example
+cat("4. Array LCS Example\n")
+```
+
+```
+## 4. Array LCS Example
+```
+
+``` r
+arr1 <- c(1, 2, 3, 4, 5)
+arr2 <- c(2, 3, 5, 7, 8)
+
+cat("Array 1:", paste(arr1, collapse = ", "), "\n")
+```
+
+```
+## Array 1: 1, 2, 3, 4, 5
+```
+
+``` r
+cat("Array 2:", paste(arr2, collapse = ", "), "\n")
+```
+
+```
+## Array 2: 2, 3, 5, 7, 8
+```
+
+``` r
+arr_result <- lcs_array(arr1, arr2)
+cat("LCS Array:", paste(arr_result$lcs, collapse = ", "), "\n")
+```
+
+```
+## LCS Array: 2, 3, 5
+```
+
+``` r
+cat("Length:", arr_result$length, "\n\n")
+```
+
+```
+## Length: 3
+```
+
+``` r
+# Test 5: Performance comparison
+cat("5. Performance Comparison\n")
+```
+
+```
+## 5. Performance Comparison
+```
+
+``` r
+long_str1 <- paste(sample(LETTERS[1:5], 100, replace = TRUE), collapse = "")
+long_str2 <- paste(sample(LETTERS[1:5], 100, replace = TRUE), collapse = "")
+
+cat("Testing with strings of length 100...\n")
+```
+
+```
+## Testing with strings of length 100...
+```
+
+``` r
+# Standard algorithm
+start_time <- Sys.time()
+standard_result <- lcs_length(long_str1, long_str2)
+standard_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+# Optimized algorithm  
+start_time <- Sys.time()
+optimized_result <- lcs_length_optimized(long_str1, long_str2)
+optimized_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Standard algorithm: LCS length =", standard_result, 
+    "Time:", sprintf("%.6f", standard_time), "seconds\n")
+```
+
+```
+## Standard algorithm: LCS length = 59 Time: 0.052980 seconds
+```
+
+``` r
+cat("Optimized algorithm: LCS length =", optimized_result, 
+    "Time:", sprintf("%.6f", optimized_time), "seconds\n")
+```
+
+```
+## Optimized algorithm: LCS length = 59 Time: 0.049993 seconds
+```
+
+``` r
+cat("Results match:", standard_result == optimized_result, "\n\n")
+```
+
+```
+## Results match: TRUE
+```
+
+``` r
+# Test 6: Edge cases
+cat("6. Edge Cases\n")
+```
+
+```
+## 6. Edge Cases
+```
+
+``` r
+cat("Empty strings:", lcs_length("", "ABC"), "\n")
+```
+
+```
+## Empty strings: 0
+```
+
+``` r
+cat("One empty string:", lcs_length("ABC", ""), "\n")
+```
+
+```
+## One empty string: 0
+```
+
+``` r
+cat("Identical strings:", lcs_length("HELLO", "HELLO"), "\n")
+```
+
+```
+## Identical strings: 5
+```
+
+``` r
+cat("No common characters:", lcs_length("ABC", "DEF"), "\n")
+```
+
+```
+## No common characters: 0
+```
+
+``` r
+cat("Single character:", lcs_length("A", "A"), "\n")
+```
+
+```
+## Single character: 1
+```
+
+``` r
+cat("Single vs multiple:", lcs_length("A", "ABCDEF"), "\n\n")
+```
+
+```
+## Single vs multiple: 1
+```
+
+``` r
+# Test 7: Real-world example - File diff simulation
+cat("7. File Diff Simulation\n")
+```
+
+```
+## 7. File Diff Simulation
+```
+
+``` r
+file1_lines <- c("Hello World", "This is line 2", "Line 3 here", "Final line")
+file2_lines <- c("Hello World", "This is modified line 2", "Line 3 here", "New line", "Final line")
+
+cat("File 1 lines:\n")
+```
+
+```
+## File 1 lines:
+```
+
+``` r
+for (i in seq_along(file1_lines)) {
+  cat(" ", i, ":", file1_lines[i], "\n")
+}
+```
+
+```
+##   1 : Hello World 
+##   2 : This is line 2 
+##   3 : Line 3 here 
+##   4 : Final line
+```
+
+``` r
+cat("File 2 lines:\n")
+```
+
+```
+## File 2 lines:
+```
+
+``` r
+for (i in seq_along(file2_lines)) {
+  cat(" ", i, ":", file2_lines[i], "\n")
+}
+```
+
+```
+##   1 : Hello World 
+##   2 : This is modified line 2 
+##   3 : Line 3 here 
+##   4 : New line 
+##   5 : Final line
+```
+
+``` r
+file_lcs <- lcs_array(file1_lines, file2_lines)
+cat("Common lines (unchanged):\n")
+```
+
+```
+## Common lines (unchanged):
+```
+
+``` r
+for (i in seq_along(file_lcs$lcs)) {
+  cat(" ", file_lcs$lcs[i], "\n")
+}
+```
+
+```
+##   Hello World 
+##   Line 3 here 
+##   Final line
+```
+
+``` r
+cat("Similarity:", sprintf("%.1f%%", file_lcs$length / max(length(file1_lines), length(file2_lines)) * 100), "\n")
+```
+
+```
+## Similarity: 60.0%
+```
+
diff --git a/Desktop/open-source/R/documentation/longest_increasing_subsequence.html b/Desktop/open-source/R/documentation/longest_increasing_subsequence.html
new file mode 100644
index 00000000..100ae952
--- /dev/null
+++ b/Desktop/open-source/R/documentation/longest_increasing_subsequence.html
@@ -0,0 +1,458 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Longest Increasing Subsequence (Dynamic Programming)
+#
+# The Longest Increasing Subsequence (LIS) problem is a classic dynamic programming problem.
+# Given an array of integers, find the length of the longest subsequence that is strictly
+# increasing. A subsequence is derived from the array by deleting some or no elements
+# without changing the order of the remaining elements.
+#
+# Time Complexity: O(n²) for basic DP, O(n log n) for optimized binary search version
+# Space Complexity: O(n) for both approaches
+#
+# Applications:
+# - Bioinformatics (DNA sequence analysis)
+# - Stock market analysis (longest upward trend)
+# - Scheduling problems
+# - Game theory (optimal play sequences)
+# - Data compression and pattern recognition
+
+# Basic DP solution for Longest Increasing Subsequence
+longest_increasing_subsequence &lt;- function(nums) {
+  #' Find the length of the longest increasing subsequence using Dynamic Programming
+  #' @param nums: Numeric vector of integers
+  #' @return: List containing max length, DP array, and one possible LIS
+  
+  n &lt;- length(nums)
+  
+  # Handle edge cases
+  if (n == 0) {
+    return(list(
+      max_length = 0,
+      dp_array = c(),
+      lis_sequence = c(),
+      dp_table = c()
+    ))
+  }
+  
+  if (n == 1) {
+    return(list(
+      max_length = 1,
+      dp_array = c(1),
+      lis_sequence = nums,
+      dp_table = c(1)
+    ))
+  }
+  
+  # Initialize DP array: dp[i] = length of LIS ending at index i
+  dp &lt;- rep(1, n)
+  
+  # Fill DP array
+  for (i in 2:n) {
+    for (j in 1:(i - 1)) {
+      if (nums[j] &lt; nums[i]) {
+        dp[i] &lt;- max(dp[i], dp[j] + 1)
+      }
+    }
+  }
+  
+  # Find maximum length
+  max_length &lt;- max(dp)
+  
+  # Backtrack to find one possible LIS
+  lis_sequence &lt;- c()
+  current_length &lt;- max_length
+  
+  for (i in n:1) {
+    if (dp[i] == current_length) {
+      lis_sequence &lt;- c(nums[i], lis_sequence)
+      current_length &lt;- current_length - 1
+      if (current_length == 0) break
+    }
+  }
+  
+  return(list(
+    max_length = max_length,
+    dp_array = dp,
+    lis_sequence = lis_sequence,
+    dp_table = dp
+  ))
+}
+
+# Optimized O(n log n) solution using binary search
+longest_increasing_subsequence_optimized &lt;- function(nums) {
+  #' Find the length of the longest increasing subsequence using binary search
+  #' @param nums: Numeric vector of integers
+  #' @return: Length of the longest increasing subsequence
+  
+  n &lt;- length(nums)
+  
+  if (n == 0) return(0)
+  if (n == 1) return(1)
+  
+  # tails[i] stores the smallest tail of all increasing subsequences of length i+1
+  tails &lt;- c()
+  
+  for (num in nums) {
+    # Binary search for the position to replace or extend
+    pos &lt;- binary_search_insert_position(tails, num)
+    
+    if (pos &gt; length(tails)) {
+      # Extend the sequence
+      tails &lt;- c(tails, num)
+    } else {
+      # Replace the element at position pos
+      tails[pos] &lt;- num
+    }
+  }
+  
+  return(length(tails))
+}
+
+# Helper function for binary search
+binary_search_insert_position &lt;- function(arr, target) {
+  #' Binary search to find the position where target should be inserted
+  #' @param arr: Sorted numeric vector
+  #' @param target: Value to insert
+  #' @return: Position (1-indexed) where target should be inserted
+  
+  if (length(arr) == 0) return(1)
+  
+  left &lt;- 1
+  right &lt;- length(arr)
+  
+  while (left &lt;= right) {
+    mid &lt;- left + (right - left) %/% 2
+    
+    if (arr[mid] &lt; target) {
+      left &lt;- mid + 1
+    } else {
+      right &lt;- mid - 1
+    }
+  }
+  
+  return(left)
+}
+
+# Function to find all possible LIS sequences (simplified version)
+find_all_lis &lt;- function(nums) {
+  #' Find all possible longest increasing subsequences
+  #' @param nums: Numeric vector of integers
+  #' @return: List of all possible LIS sequences
+  
+  n &lt;- length(nums)
+  if (n == 0) return(list())
+  
+  # Calculate DP array
+  dp &lt;- rep(1, n)
+  for (i in 2:n) {
+    for (j in 1:(i - 1)) {
+      if (nums[j] &lt; nums[i]) {
+        dp[i] &lt;- max(dp[i], dp[j] + 1)
+      }
+    }
+  }
+  
+  max_length &lt;- max(dp)
+  
+  # For simplicity, return just one LIS (same as the main function)
+  # Finding all possible LIS is complex and not essential for the algorithm demonstration
+  result &lt;- longest_increasing_subsequence(nums)
+  return(list(result$lis_sequence))
+}
+
+# Helper function to print DP table
+print_lis_dp &lt;- function(dp_array, nums) {
+  cat(&quot;DP Array for Longest Increasing Subsequence:\n&quot;)
+  cat(&quot;Input Array:&quot;, paste(nums, collapse = &quot;, &quot;), &quot;\n&quot;)
+  cat(&quot;DP Array   :&quot;, paste(dp_array, collapse = &quot;, &quot;), &quot;\n&quot;)
+  cat(&quot;Max Length :&quot;, max(dp_array), &quot;\n\n&quot;)
+}
+
+# ===========================
+# Example Usage &amp; Testing
+# ===========================
+cat(&quot;=== Longest Increasing Subsequence (Dynamic Programming) ===\n\n&quot;)
+</code></pre>
+<pre><code>## === Longest Increasing Subsequence (Dynamic Programming) ===
+</code></pre>
+<pre><code class="language-r"># Test 1: Basic Example
+nums1 &lt;- c(10, 9, 2, 5, 3, 7, 101, 18)
+cat(&quot;Test 1: Basic Example\n&quot;)
+</code></pre>
+<pre><code>## Test 1: Basic Example
+</code></pre>
+<pre><code class="language-r">cat(&quot;Input Array:&quot;, paste(nums1, collapse = &quot;, &quot;), &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Input Array: 10, 9, 2, 5, 3, 7, 101, 18
+</code></pre>
+<pre><code class="language-r">result1 &lt;- longest_increasing_subsequence(nums1)
+print_lis_dp(result1$dp_array, nums1)
+</code></pre>
+<pre><code>## DP Array for Longest Increasing Subsequence:
+## Input Array: 10, 9, 2, 5, 3, 7, 101, 18 
+## DP Array   : 1, 1, 1, 2, 2, 3, 4, 4 
+## Max Length : 4
+</code></pre>
+<pre><code class="language-r">cat(&quot;Maximum Length:&quot;, result1$max_length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Maximum Length: 4
+</code></pre>
+<pre><code class="language-r">cat(&quot;One LIS Sequence:&quot;, paste(result1$lis_sequence, collapse = &quot;, &quot;), &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## One LIS Sequence: 2, 3, 7, 18
+</code></pre>
+<pre><code class="language-r"># Test 2: Optimized Version
+cat(&quot;Test 2: Optimized O(n log n) Version\n&quot;)
+</code></pre>
+<pre><code>## Test 2: Optimized O(n log n) Version
+</code></pre>
+<pre><code class="language-r">max_len_opt &lt;- longest_increasing_subsequence_optimized(nums1)
+cat(&quot;Maximum Length (Optimized):&quot;, max_len_opt, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Maximum Length (Optimized): 4
+</code></pre>
+<pre><code class="language-r">cat(&quot;Verification: Both methods match:&quot;, result1$max_length == max_len_opt, &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Verification: Both methods match: TRUE
+</code></pre>
+<pre><code class="language-r"># Test 3: All Possible LIS
+cat(&quot;Test 3: All Possible LIS Sequences\n&quot;)
+</code></pre>
+<pre><code>## Test 3: All Possible LIS Sequences
+</code></pre>
+<pre><code class="language-r">all_lis &lt;- find_all_lis(nums1)
+cat(&quot;Total number of LIS sequences:&quot;, length(all_lis), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Total number of LIS sequences: 1
+</code></pre>
+<pre><code class="language-r">for (i in seq_along(all_lis)) {
+  cat(&quot;LIS&quot;, i, &quot;:&quot;, paste(all_lis[[i]], collapse = &quot;, &quot;), &quot;\n&quot;)
+}
+</code></pre>
+<pre><code>## LIS 1 : 2, 3, 7, 18
+</code></pre>
+<pre><code class="language-r">cat(&quot;\n&quot;)
+</code></pre>
+<pre><code class="language-r"># Test 4: Edge Cases
+cat(&quot;Test 4: Edge Cases\n&quot;)
+</code></pre>
+<pre><code>## Test 4: Edge Cases
+</code></pre>
+<pre><code class="language-r">cat(&quot;Empty array:&quot;, longest_increasing_subsequence(c())$max_length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Empty array: 0
+</code></pre>
+<pre><code class="language-r">cat(&quot;Single element:&quot;, longest_increasing_subsequence(c(5))$max_length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Single element: 1
+</code></pre>
+<pre><code class="language-r">cat(&quot;All same elements:&quot;, longest_increasing_subsequence(c(3, 3, 3, 3))$max_length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## All same elements: 1
+</code></pre>
+<pre><code class="language-r">cat(&quot;Strictly decreasing:&quot;, longest_increasing_subsequence(c(5, 4, 3, 2, 1))$max_length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Strictly decreasing: 1
+</code></pre>
+<pre><code class="language-r">cat(&quot;Strictly increasing:&quot;, longest_increasing_subsequence(c(1, 2, 3, 4, 5))$max_length, &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Strictly increasing: 5
+</code></pre>
+<pre><code class="language-r"># Test 5: Larger Dataset
+cat(&quot;Test 5: Larger Dataset (n=20)\n&quot;)
+</code></pre>
+<pre><code>## Test 5: Larger Dataset (n=20)
+</code></pre>
+<pre><code class="language-r">set.seed(42)
+nums_large &lt;- sample(1:100, 20)
+cat(&quot;Input Array:&quot;, paste(nums_large, collapse = &quot;, &quot;), &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## Input Array: 49, 65, 25, 74, 18, 100, 47, 24, 71, 89, 37, 20, 26, 3, 41, 27, 36, 5, 34, 87
+</code></pre>
+<pre><code class="language-r">result_large &lt;- longest_increasing_subsequence(nums_large)
+cat(&quot;Maximum Length:&quot;, result_large$max_length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Maximum Length: 6
+</code></pre>
+<pre><code class="language-r">cat(&quot;One LIS Sequence:&quot;, paste(result_large$lis_sequence, collapse = &quot;, &quot;), &quot;\n\n&quot;)
+</code></pre>
+<pre><code>## One LIS Sequence: 18, 20, 26, 27, 34, 87
+</code></pre>
+<pre><code class="language-r"># Test 6: Performance Comparison
+cat(&quot;Test 6: Performance Comparison (n=1000)\n&quot;)
+</code></pre>
+<pre><code>## Test 6: Performance Comparison (n=1000)
+</code></pre>
+<pre><code class="language-r">n &lt;- 1000
+nums_perf &lt;- sample(1:1000, n)
+
+start_time &lt;- Sys.time()
+res_opt &lt;- longest_increasing_subsequence_optimized(nums_perf)
+opt_time &lt;- as.numeric(Sys.time() - start_time, units = &quot;secs&quot;)
+
+cat(&quot;Optimized O(n log n) result:&quot;, res_opt, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Optimized O(n log n) result: 61
+</code></pre>
+<pre><code class="language-r">cat(&quot;Time taken:&quot;, sprintf(&quot;%.4f sec&quot;, opt_time), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Time taken: 0.0189 sec
+</code></pre>
+<pre><code class="language-r"># Verify correctness with basic DP (smaller sample for time comparison)
+nums_small &lt;- nums_perf[1:100]
+start_time &lt;- Sys.time()
+res_basic &lt;- longest_increasing_subsequence(nums_small)
+basic_time &lt;- as.numeric(Sys.time() - start_time, units = &quot;secs&quot;)
+
+cat(&quot;Basic O(n²) result (n=100):&quot;, res_basic$max_length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Basic O(n²) result (n=100): 18
+</code></pre>
+<pre><code class="language-r">cat(&quot;Time taken:&quot;, sprintf(&quot;%.4f sec&quot;, basic_time), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Time taken: 0.0020 sec
+</code></pre>
+<pre><code class="language-r"># Test 7: Real-world Example - Stock Prices
+cat(&quot;Test 7: Real-world Example - Stock Price Trend\n&quot;)
+</code></pre>
+<pre><code>## Test 7: Real-world Example - Stock Price Trend
+</code></pre>
+<pre><code class="language-r">stock_prices &lt;- c(100, 102, 98, 105, 103, 107, 110, 108, 112, 115, 113, 118, 120, 117, 125)
+cat(&quot;Stock Prices:&quot;, paste(stock_prices, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Stock Prices: 100, 102, 98, 105, 103, 107, 110, 108, 112, 115, 113, 118, 120, 117, 125
+</code></pre>
+<pre><code class="language-r">stock_result &lt;- longest_increasing_subsequence(stock_prices)
+cat(&quot;Longest upward trend length:&quot;, stock_result$max_length, &quot;\n&quot;)
+</code></pre>
+<pre><code>## Longest upward trend length: 10
+</code></pre>
+<pre><code class="language-r">cat(&quot;Longest upward trend:&quot;, paste(stock_result$lis_sequence, collapse = &quot;, &quot;), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Longest upward trend: 100, 102, 103, 107, 108, 112, 113, 118, 120, 125
+</code></pre>
+<pre><code class="language-r">cat(&quot;Percentage increase:&quot;, 
+    sprintf(&quot;%.2f%%&quot;, (stock_result$lis_sequence[length(stock_result$lis_sequence)] / 
+                      stock_result$lis_sequence[1] - 1) * 100), &quot;\n&quot;)
+</code></pre>
+<pre><code>## Percentage increase: 25.00%
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/longest_increasing_subsequence.md b/Desktop/open-source/R/documentation/longest_increasing_subsequence.md
new file mode 100644
index 00000000..671f6663
--- /dev/null
+++ b/Desktop/open-source/R/documentation/longest_increasing_subsequence.md
@@ -0,0 +1,470 @@
+
+
+``` r
+# Longest Increasing Subsequence (Dynamic Programming)
+#
+# The Longest Increasing Subsequence (LIS) problem is a classic dynamic programming problem.
+# Given an array of integers, find the length of the longest subsequence that is strictly
+# increasing. A subsequence is derived from the array by deleting some or no elements
+# without changing the order of the remaining elements.
+#
+# Time Complexity: O(n²) for basic DP, O(n log n) for optimized binary search version
+# Space Complexity: O(n) for both approaches
+#
+# Applications:
+# - Bioinformatics (DNA sequence analysis)
+# - Stock market analysis (longest upward trend)
+# - Scheduling problems
+# - Game theory (optimal play sequences)
+# - Data compression and pattern recognition
+
+# Basic DP solution for Longest Increasing Subsequence
+longest_increasing_subsequence <- function(nums) {
+  #' Find the length of the longest increasing subsequence using Dynamic Programming
+  #' @param nums: Numeric vector of integers
+  #' @return: List containing max length, DP array, and one possible LIS
+  
+  n <- length(nums)
+  
+  # Handle edge cases
+  if (n == 0) {
+    return(list(
+      max_length = 0,
+      dp_array = c(),
+      lis_sequence = c(),
+      dp_table = c()
+    ))
+  }
+  
+  if (n == 1) {
+    return(list(
+      max_length = 1,
+      dp_array = c(1),
+      lis_sequence = nums,
+      dp_table = c(1)
+    ))
+  }
+  
+  # Initialize DP array: dp[i] = length of LIS ending at index i
+  dp <- rep(1, n)
+  
+  # Fill DP array
+  for (i in 2:n) {
+    for (j in 1:(i - 1)) {
+      if (nums[j] < nums[i]) {
+        dp[i] <- max(dp[i], dp[j] + 1)
+      }
+    }
+  }
+  
+  # Find maximum length
+  max_length <- max(dp)
+  
+  # Backtrack to find one possible LIS
+  lis_sequence <- c()
+  current_length <- max_length
+  
+  for (i in n:1) {
+    if (dp[i] == current_length) {
+      lis_sequence <- c(nums[i], lis_sequence)
+      current_length <- current_length - 1
+      if (current_length == 0) break
+    }
+  }
+  
+  return(list(
+    max_length = max_length,
+    dp_array = dp,
+    lis_sequence = lis_sequence,
+    dp_table = dp
+  ))
+}
+
+# Optimized O(n log n) solution using binary search
+longest_increasing_subsequence_optimized <- function(nums) {
+  #' Find the length of the longest increasing subsequence using binary search
+  #' @param nums: Numeric vector of integers
+  #' @return: Length of the longest increasing subsequence
+  
+  n <- length(nums)
+  
+  if (n == 0) return(0)
+  if (n == 1) return(1)
+  
+  # tails[i] stores the smallest tail of all increasing subsequences of length i+1
+  tails <- c()
+  
+  for (num in nums) {
+    # Binary search for the position to replace or extend
+    pos <- binary_search_insert_position(tails, num)
+    
+    if (pos > length(tails)) {
+      # Extend the sequence
+      tails <- c(tails, num)
+    } else {
+      # Replace the element at position pos
+      tails[pos] <- num
+    }
+  }
+  
+  return(length(tails))
+}
+
+# Helper function for binary search
+binary_search_insert_position <- function(arr, target) {
+  #' Binary search to find the position where target should be inserted
+  #' @param arr: Sorted numeric vector
+  #' @param target: Value to insert
+  #' @return: Position (1-indexed) where target should be inserted
+  
+  if (length(arr) == 0) return(1)
+  
+  left <- 1
+  right <- length(arr)
+  
+  while (left <= right) {
+    mid <- left + (right - left) %/% 2
+    
+    if (arr[mid] < target) {
+      left <- mid + 1
+    } else {
+      right <- mid - 1
+    }
+  }
+  
+  return(left)
+}
+
+# Function to find all possible LIS sequences (simplified version)
+find_all_lis <- function(nums) {
+  #' Find all possible longest increasing subsequences
+  #' @param nums: Numeric vector of integers
+  #' @return: List of all possible LIS sequences
+  
+  n <- length(nums)
+  if (n == 0) return(list())
+  
+  # Calculate DP array
+  dp <- rep(1, n)
+  for (i in 2:n) {
+    for (j in 1:(i - 1)) {
+      if (nums[j] < nums[i]) {
+        dp[i] <- max(dp[i], dp[j] + 1)
+      }
+    }
+  }
+  
+  max_length <- max(dp)
+  
+  # For simplicity, return just one LIS (same as the main function)
+  # Finding all possible LIS is complex and not essential for the algorithm demonstration
+  result <- longest_increasing_subsequence(nums)
+  return(list(result$lis_sequence))
+}
+
+# Helper function to print DP table
+print_lis_dp <- function(dp_array, nums) {
+  cat("DP Array for Longest Increasing Subsequence:\n")
+  cat("Input Array:", paste(nums, collapse = ", "), "\n")
+  cat("DP Array   :", paste(dp_array, collapse = ", "), "\n")
+  cat("Max Length :", max(dp_array), "\n\n")
+}
+
+# ===========================
+# Example Usage & Testing
+# ===========================
+cat("=== Longest Increasing Subsequence (Dynamic Programming) ===\n\n")
+```
+
+```
+## === Longest Increasing Subsequence (Dynamic Programming) ===
+```
+
+``` r
+# Test 1: Basic Example
+nums1 <- c(10, 9, 2, 5, 3, 7, 101, 18)
+cat("Test 1: Basic Example\n")
+```
+
+```
+## Test 1: Basic Example
+```
+
+``` r
+cat("Input Array:", paste(nums1, collapse = ", "), "\n\n")
+```
+
+```
+## Input Array: 10, 9, 2, 5, 3, 7, 101, 18
+```
+
+``` r
+result1 <- longest_increasing_subsequence(nums1)
+print_lis_dp(result1$dp_array, nums1)
+```
+
+```
+## DP Array for Longest Increasing Subsequence:
+## Input Array: 10, 9, 2, 5, 3, 7, 101, 18 
+## DP Array   : 1, 1, 1, 2, 2, 3, 4, 4 
+## Max Length : 4
+```
+
+``` r
+cat("Maximum Length:", result1$max_length, "\n")
+```
+
+```
+## Maximum Length: 4
+```
+
+``` r
+cat("One LIS Sequence:", paste(result1$lis_sequence, collapse = ", "), "\n\n")
+```
+
+```
+## One LIS Sequence: 2, 3, 7, 18
+```
+
+``` r
+# Test 2: Optimized Version
+cat("Test 2: Optimized O(n log n) Version\n")
+```
+
+```
+## Test 2: Optimized O(n log n) Version
+```
+
+``` r
+max_len_opt <- longest_increasing_subsequence_optimized(nums1)
+cat("Maximum Length (Optimized):", max_len_opt, "\n")
+```
+
+```
+## Maximum Length (Optimized): 4
+```
+
+``` r
+cat("Verification: Both methods match:", result1$max_length == max_len_opt, "\n\n")
+```
+
+```
+## Verification: Both methods match: TRUE
+```
+
+``` r
+# Test 3: All Possible LIS
+cat("Test 3: All Possible LIS Sequences\n")
+```
+
+```
+## Test 3: All Possible LIS Sequences
+```
+
+``` r
+all_lis <- find_all_lis(nums1)
+cat("Total number of LIS sequences:", length(all_lis), "\n")
+```
+
+```
+## Total number of LIS sequences: 1
+```
+
+``` r
+for (i in seq_along(all_lis)) {
+  cat("LIS", i, ":", paste(all_lis[[i]], collapse = ", "), "\n")
+}
+```
+
+```
+## LIS 1 : 2, 3, 7, 18
+```
+
+``` r
+cat("\n")
+```
+
+``` r
+# Test 4: Edge Cases
+cat("Test 4: Edge Cases\n")
+```
+
+```
+## Test 4: Edge Cases
+```
+
+``` r
+cat("Empty array:", longest_increasing_subsequence(c())$max_length, "\n")
+```
+
+```
+## Empty array: 0
+```
+
+``` r
+cat("Single element:", longest_increasing_subsequence(c(5))$max_length, "\n")
+```
+
+```
+## Single element: 1
+```
+
+``` r
+cat("All same elements:", longest_increasing_subsequence(c(3, 3, 3, 3))$max_length, "\n")
+```
+
+```
+## All same elements: 1
+```
+
+``` r
+cat("Strictly decreasing:", longest_increasing_subsequence(c(5, 4, 3, 2, 1))$max_length, "\n")
+```
+
+```
+## Strictly decreasing: 1
+```
+
+``` r
+cat("Strictly increasing:", longest_increasing_subsequence(c(1, 2, 3, 4, 5))$max_length, "\n\n")
+```
+
+```
+## Strictly increasing: 5
+```
+
+``` r
+# Test 5: Larger Dataset
+cat("Test 5: Larger Dataset (n=20)\n")
+```
+
+```
+## Test 5: Larger Dataset (n=20)
+```
+
+``` r
+set.seed(42)
+nums_large <- sample(1:100, 20)
+cat("Input Array:", paste(nums_large, collapse = ", "), "\n\n")
+```
+
+```
+## Input Array: 49, 65, 25, 74, 18, 100, 47, 24, 71, 89, 37, 20, 26, 3, 41, 27, 36, 5, 34, 87
+```
+
+``` r
+result_large <- longest_increasing_subsequence(nums_large)
+cat("Maximum Length:", result_large$max_length, "\n")
+```
+
+```
+## Maximum Length: 6
+```
+
+``` r
+cat("One LIS Sequence:", paste(result_large$lis_sequence, collapse = ", "), "\n\n")
+```
+
+```
+## One LIS Sequence: 18, 20, 26, 27, 34, 87
+```
+
+``` r
+# Test 6: Performance Comparison
+cat("Test 6: Performance Comparison (n=1000)\n")
+```
+
+```
+## Test 6: Performance Comparison (n=1000)
+```
+
+``` r
+n <- 1000
+nums_perf <- sample(1:1000, n)
+
+start_time <- Sys.time()
+res_opt <- longest_increasing_subsequence_optimized(nums_perf)
+opt_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Optimized O(n log n) result:", res_opt, "\n")
+```
+
+```
+## Optimized O(n log n) result: 61
+```
+
+``` r
+cat("Time taken:", sprintf("%.4f sec", opt_time), "\n")
+```
+
+```
+## Time taken: 0.0189 sec
+```
+
+``` r
+# Verify correctness with basic DP (smaller sample for time comparison)
+nums_small <- nums_perf[1:100]
+start_time <- Sys.time()
+res_basic <- longest_increasing_subsequence(nums_small)
+basic_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Basic O(n²) result (n=100):", res_basic$max_length, "\n")
+```
+
+```
+## Basic O(n²) result (n=100): 18
+```
+
+``` r
+cat("Time taken:", sprintf("%.4f sec", basic_time), "\n")
+```
+
+```
+## Time taken: 0.0020 sec
+```
+
+``` r
+# Test 7: Real-world Example - Stock Prices
+cat("Test 7: Real-world Example - Stock Price Trend\n")
+```
+
+```
+## Test 7: Real-world Example - Stock Price Trend
+```
+
+``` r
+stock_prices <- c(100, 102, 98, 105, 103, 107, 110, 108, 112, 115, 113, 118, 120, 117, 125)
+cat("Stock Prices:", paste(stock_prices, collapse = ", "), "\n")
+```
+
+```
+## Stock Prices: 100, 102, 98, 105, 103, 107, 110, 108, 112, 115, 113, 118, 120, 117, 125
+```
+
+``` r
+stock_result <- longest_increasing_subsequence(stock_prices)
+cat("Longest upward trend length:", stock_result$max_length, "\n")
+```
+
+```
+## Longest upward trend length: 10
+```
+
+``` r
+cat("Longest upward trend:", paste(stock_result$lis_sequence, collapse = ", "), "\n")
+```
+
+```
+## Longest upward trend: 100, 102, 103, 107, 108, 112, 113, 118, 120, 125
+```
+
+``` r
+cat("Percentage increase:", 
+    sprintf("%.2f%%", (stock_result$lis_sequence[length(stock_result$lis_sequence)] / 
+                      stock_result$lis_sequence[1] - 1) * 100), "\n")
+```
+
+```
+## Percentage increase: 25.00%
+```
+
diff --git a/Desktop/open-source/R/documentation/multiple_linear_regression.html b/Desktop/open-source/R/documentation/multiple_linear_regression.html
new file mode 100644
index 00000000..c6b7a89d
--- /dev/null
+++ b/Desktop/open-source/R/documentation/multiple_linear_regression.html
@@ -0,0 +1,138 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r"># Introduction to multiple linear regression
+
+# lm stands for Linear Model
+# y_data are modeled as a.x1 + b.x2 + c.x3 + d.x4 + e
+mod3 &lt;- lm(y_data~x1_data+x2_data+x3_data+x4_data, data=name_of_the_dataframe)
+</code></pre>
+<pre><code>## Error in is.data.frame(data): object 'name_of_the_dataframe' not found
+</code></pre>
+<pre><code class="language-r"># displays the output of the model computed by the previous line
+summary(mod3)
+</code></pre>
+<pre><code>## Error in summary(mod3): object 'mod3' not found
+</code></pre>
+<pre><code class="language-r"># modeled data : it predicts the output for x_test_data as input information for the model
+predicted &lt;- predict(mod3, x1_test_data, x2_test_data, x3_test_data, x4_test_data)
+</code></pre>
+<pre><code>## Error in predict(mod3, x1_test_data, x2_test_data, x3_test_data, x4_test_data): object 'mod3' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/multiple_linear_regression.md b/Desktop/open-source/R/documentation/multiple_linear_regression.md
new file mode 100644
index 00000000..fbfbfdbf
--- /dev/null
+++ b/Desktop/open-source/R/documentation/multiple_linear_regression.md
@@ -0,0 +1,32 @@
+
+
+``` r
+# Introduction to multiple linear regression
+
+# lm stands for Linear Model
+# y_data are modeled as a.x1 + b.x2 + c.x3 + d.x4 + e
+mod3 <- lm(y_data~x1_data+x2_data+x3_data+x4_data, data=name_of_the_dataframe)
+```
+
+```
+## Error in is.data.frame(data): object 'name_of_the_dataframe' not found
+```
+
+``` r
+# displays the output of the model computed by the previous line
+summary(mod3)
+```
+
+```
+## Error in summary(mod3): object 'mod3' not found
+```
+
+``` r
+# modeled data : it predicts the output for x_test_data as input information for the model
+predicted <- predict(mod3, x1_test_data, x2_test_data, x3_test_data, x4_test_data)
+```
+
+```
+## Error in predict(mod3, x1_test_data, x2_test_data, x3_test_data, x4_test_data): object 'mod3' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/naive_bayes.html b/Desktop/open-source/R/documentation/naive_bayes.html
new file mode 100644
index 00000000..bfc05e38
--- /dev/null
+++ b/Desktop/open-source/R/documentation/naive_bayes.html
@@ -0,0 +1,142 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(e1071)
+</code></pre>
+<pre><code>## Error in library(e1071): there is no package called 'e1071'
+</code></pre>
+<pre><code class="language-r">x &lt;- cbind(x_train,y_train)
+</code></pre>
+<pre><code>## Error in cbind(x_train, y_train): object 'x_train' not found
+</code></pre>
+<pre><code class="language-r"># Fitting model
+fit &lt;-naiveBayes(y_train ~ ., data = x)
+</code></pre>
+<pre><code>## Error in naiveBayes(y_train ~ ., data = x): could not find function &quot;naiveBayes&quot;
+</code></pre>
+<pre><code class="language-r">summary(fit)
+</code></pre>
+<pre><code>## Error in summary(fit): object 'fit' not found
+</code></pre>
+<pre><code class="language-r"># Predict Output 
+predicted= predict(fit,x_test)
+</code></pre>
+<pre><code>## Error in predict(fit, x_test): object 'fit' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/naive_bayes.md b/Desktop/open-source/R/documentation/naive_bayes.md
new file mode 100644
index 00000000..ebbc79a9
--- /dev/null
+++ b/Desktop/open-source/R/documentation/naive_bayes.md
@@ -0,0 +1,44 @@
+
+
+``` r
+library(e1071)
+```
+
+```
+## Error in library(e1071): there is no package called 'e1071'
+```
+
+``` r
+x <- cbind(x_train,y_train)
+```
+
+```
+## Error in cbind(x_train, y_train): object 'x_train' not found
+```
+
+``` r
+# Fitting model
+fit <-naiveBayes(y_train ~ ., data = x)
+```
+
+```
+## Error in naiveBayes(y_train ~ ., data = x): could not find function "naiveBayes"
+```
+
+``` r
+summary(fit)
+```
+
+```
+## Error in summary(fit): object 'fit' not found
+```
+
+``` r
+# Predict Output 
+predicted= predict(fit,x_test)
+```
+
+```
+## Error in predict(fit, x_test): object 'fit' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/pam.html b/Desktop/open-source/R/documentation/pam.html
new file mode 100644
index 00000000..7c4d3ed0
--- /dev/null
+++ b/Desktop/open-source/R/documentation/pam.html
@@ -0,0 +1,314 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(cluster) 
+pam_fit &lt;- pam(iris[, 1:4], 5) # Partition Around Medoids
+summary(pam_fit) # Get summary
+</code></pre>
+<pre><code>## Medoids:
+##       ID Sepal.Length Sepal.Width Petal.Length Petal.Width
+## [1,]   8          5.0         3.4          1.5         0.2
+## [2,]  64          6.1         2.9          4.7         1.4
+## [3,]  70          5.6         2.5          3.9         1.1
+## [4,] 113          6.8         3.0          5.5         2.1
+## [5,] 106          7.6         3.0          6.6         2.1
+## Clustering vector:
+##   [1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
+##  [38] 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 3 2 2 2 3 2 3 3 2 3 2 3 2 2 3 2 3 2 3 2 2
+##  [75] 2 2 2 4 2 3 3 3 3 2 2 2 2 2 3 3 3 2 3 3 3 3 3 2 3 3 4 2 4 4 4 5 3 5 4 5 4
+## [112] 4 4 2 2 4 4 5 5 2 4 2 5 2 4 4 2 2 4 4 5 5 4 2 2 5 4 4 2 4 4 4 2 4 4 4 2 4
+## [149] 4 2
+## Objective function:
+##     build      swap 
+## 0.5520959 0.5272835 
+## 
+## Numerical information per cluster:
+##      size  max_diss   av_diss diameter separation
+## [1,]   50 1.2369317 0.4846000 2.428992  1.6401219
+## [2,]   40 1.1224972 0.5874690 1.661325  0.3000000
+## [3,]   24 1.1000000 0.5205001 1.627882  0.3000000
+## [4,]   27 0.8660254 0.5077127 1.374773  0.3162278
+## [5,]    9 0.9643651 0.5737248 1.389244  0.4358899
+## 
+## Isolated clusters:
+##  L-clusters: character(0)
+##  L*-clusters: character(0)
+## 
+## Silhouette plot information:
+##     cluster neighbor    sil_width
+## 1         1        3  0.823782713
+## 8         1        3  0.822979939
+## 18        1        3  0.821191829
+## 50        1        3  0.820946901
+## 5         1        3  0.819989654
+## 41        1        3  0.819878967
+## 40        1        3  0.818905711
+## 29        1        3  0.812116253
+## 38        1        3  0.811246460
+## 28        1        3  0.810123090
+## 12        1        3  0.799834938
+## 36        1        3  0.798299736
+## 27        1        3  0.796367017
+## 3         1        3  0.793333297
+## 22        1        3  0.791981289
+## 35        1        3  0.789669653
+## 20        1        3  0.786689337
+## 10        1        3  0.785945881
+## 7         1        3  0.784292003
+## 49        1        3  0.784257843
+## 48        1        3  0.779752099
+## 47        1        3  0.777942371
+## 30        1        3  0.775746314
+## 2         1        3  0.773966636
+## 31        1        3  0.771500461
+## 13        1        3  0.768378249
+## 11        1        3  0.766919198
+## 46        1        3  0.766389968
+## 4         1        3  0.760528648
+## 32        1        3  0.757686027
+## 37        1        3  0.756698504
+## 44        1        3  0.756592820
+## 23        1        3  0.756110206
+## 26        1        3  0.750347697
+## 24        1        3  0.745215991
+## 43        1        3  0.741959676
+## 17        1        3  0.738559175
+## 21        1        3  0.737981532
+## 33        1        3  0.724060094
+## 25        1        3  0.721037402
+## 39        1        3  0.718527842
+## 6         1        3  0.702644402
+## 9         1        3  0.696132723
+## 14        1        3  0.695119096
+## 45        1        3  0.694338305
+## 34        1        3  0.681434226
+## 15        1        3  0.660358295
+## 19        1        3  0.655738366
+## 16        1        3  0.597147161
+## 42        1        3  0.555054870
+## 64        2        3  0.471339064
+## 55        2        4  0.458317613
+## 52        2        4  0.443534424
+## 92        2        3  0.433142280
+## 59        2        4  0.431621613
+## 139       2        4  0.417405565
+## 76        2        3  0.415948453
+## 127       2        4  0.402579655
+## 73        2        4  0.399050400
+## 66        2        4  0.388387404
+## 74        2        3  0.372099711
+## 71        2        4  0.366704189
+## 57        2        4  0.363901411
+## 84        2        4  0.349237676
+## 79        2        3  0.347927387
+## 128       2        4  0.344414971
+## 86        2        3  0.342879650
+## 120       2        3  0.339139851
+## 122       2        4  0.324164232
+## 124       2        4  0.310947933
+## 87        2        4  0.296111811
+## 75        2        3  0.294712248
+## 114       2        4  0.287220191
+## 102       2        4  0.276114979
+## 143       2        4  0.276114979
+## 134       2        4  0.274416839
+## 77        2        4  0.262524104
+## 150       2        4  0.250702974
+## 98        2        3  0.207008254
+## 69        2        3  0.206965943
+## 147       2        4  0.186361678
+## 51        2        4  0.158584073
+## 88        2        3  0.154974194
+## 67        2        3  0.080197066
+## 53        2        4  0.068704364
+## 135       2        4  0.009859737
+## 115       2        4  0.007411473
+## 62        2        3 -0.010322685
+## 56        2        3 -0.018480568
+## 85        2        3 -0.056548190
+## 81        3        2  0.593063391
+## 82        3        2  0.588486416
+## 70        3        2  0.577829255
+## 90        3        2  0.541572577
+## 80        3        2  0.540075551
+## 94        3        2  0.527900827
+## 58        3        2  0.518504963
+## 54        3        2  0.510585771
+## 60        3        2  0.509830210
+## 61        3        2  0.497940985
+## 65        3        2  0.497569203
+## 83        3        2  0.489146497
+## 93        3        2  0.469694889
+## 99        3        1  0.458807124
+## 68        3        2  0.409714352
+## 100       3        2  0.400450702
+## 95        3        2  0.396521625
+## 89        3        2  0.348880615
+## 63        3        2  0.336954121
+## 91        3        2  0.295905041
+## 97        3        2  0.281018209
+## 96        3        2  0.262894448
+## 107       3        2  0.186381085
+## 72        3        2  0.161825540
+## 113       4        2  0.577935875
+## 105       4        5  0.577360661
+## 141       4        5  0.575917221
+## 125       4        5  0.550165260
+## 140       4        2  0.541953152
+## 133       4        2  0.496625982
+## 145       4        5  0.487427796
+## 137       4        2  0.486932219
+## 129       4        2  0.484485212
+## 121       4        5  0.461832625
+## 146       4        2  0.455480506
+## 116       4        2  0.450650676
+## 117       4        2  0.425816992
+## 101       4        5  0.425555783
+## 142       4        2  0.407031174
+## 144       4        5  0.401369810
+## 138       4        2  0.394312582
+## 149       4        2  0.388080059
+## 109       4        2  0.374157348
+## 104       4        2  0.351135503
+## 148       4        2  0.328372054
+## 111       4        2  0.256998908
+## 112       4        2  0.192307087
+## 103       4        5  0.154141472
+## 130       4        5  0.105352310
+## 78        4        2 -0.016348526
+## 126       4        5 -0.082878191
+## 106       5        4  0.565971497
+## 123       5        4  0.546749956
+## 119       5        4  0.477509712
+## 118       5        4  0.459700515
+## 132       5        4  0.439388428
+## 136       5        4  0.409060616
+## 108       5        4  0.312571293
+## 131       5        4  0.253594219
+## 110       5        4  0.082867697
+## Average silhouette width per cluster:
+## [1] 0.7575140 0.2733844 0.4333981 0.3797101 0.3941571
+## Average silhouette width of total data set:
+## [1] 0.4867481
+## 
+## Available components:
+##  [1] &quot;medoids&quot;    &quot;id.med&quot;     &quot;clustering&quot; &quot;objective&quot;  &quot;isolation&quot; 
+##  [6] &quot;clusinfo&quot;   &quot;silinfo&quot;    &quot;diss&quot;       &quot;call&quot;       &quot;data&quot;
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/pam.md b/Desktop/open-source/R/documentation/pam.md
new file mode 100644
index 00000000..9428c3f1
--- /dev/null
+++ b/Desktop/open-source/R/documentation/pam.md
@@ -0,0 +1,200 @@
+
+
+``` r
+library(cluster) 
+pam_fit <- pam(iris[, 1:4], 5) # Partition Around Medoids
+summary(pam_fit) # Get summary
+```
+
+```
+## Medoids:
+##       ID Sepal.Length Sepal.Width Petal.Length Petal.Width
+## [1,]   8          5.0         3.4          1.5         0.2
+## [2,]  64          6.1         2.9          4.7         1.4
+## [3,]  70          5.6         2.5          3.9         1.1
+## [4,] 113          6.8         3.0          5.5         2.1
+## [5,] 106          7.6         3.0          6.6         2.1
+## Clustering vector:
+##   [1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
+##  [38] 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 3 2 2 2 3 2 3 3 2 3 2 3 2 2 3 2 3 2 3 2 2
+##  [75] 2 2 2 4 2 3 3 3 3 2 2 2 2 2 3 3 3 2 3 3 3 3 3 2 3 3 4 2 4 4 4 5 3 5 4 5 4
+## [112] 4 4 2 2 4 4 5 5 2 4 2 5 2 4 4 2 2 4 4 5 5 4 2 2 5 4 4 2 4 4 4 2 4 4 4 2 4
+## [149] 4 2
+## Objective function:
+##     build      swap 
+## 0.5520959 0.5272835 
+## 
+## Numerical information per cluster:
+##      size  max_diss   av_diss diameter separation
+## [1,]   50 1.2369317 0.4846000 2.428992  1.6401219
+## [2,]   40 1.1224972 0.5874690 1.661325  0.3000000
+## [3,]   24 1.1000000 0.5205001 1.627882  0.3000000
+## [4,]   27 0.8660254 0.5077127 1.374773  0.3162278
+## [5,]    9 0.9643651 0.5737248 1.389244  0.4358899
+## 
+## Isolated clusters:
+##  L-clusters: character(0)
+##  L*-clusters: character(0)
+## 
+## Silhouette plot information:
+##     cluster neighbor    sil_width
+## 1         1        3  0.823782713
+## 8         1        3  0.822979939
+## 18        1        3  0.821191829
+## 50        1        3  0.820946901
+## 5         1        3  0.819989654
+## 41        1        3  0.819878967
+## 40        1        3  0.818905711
+## 29        1        3  0.812116253
+## 38        1        3  0.811246460
+## 28        1        3  0.810123090
+## 12        1        3  0.799834938
+## 36        1        3  0.798299736
+## 27        1        3  0.796367017
+## 3         1        3  0.793333297
+## 22        1        3  0.791981289
+## 35        1        3  0.789669653
+## 20        1        3  0.786689337
+## 10        1        3  0.785945881
+## 7         1        3  0.784292003
+## 49        1        3  0.784257843
+## 48        1        3  0.779752099
+## 47        1        3  0.777942371
+## 30        1        3  0.775746314
+## 2         1        3  0.773966636
+## 31        1        3  0.771500461
+## 13        1        3  0.768378249
+## 11        1        3  0.766919198
+## 46        1        3  0.766389968
+## 4         1        3  0.760528648
+## 32        1        3  0.757686027
+## 37        1        3  0.756698504
+## 44        1        3  0.756592820
+## 23        1        3  0.756110206
+## 26        1        3  0.750347697
+## 24        1        3  0.745215991
+## 43        1        3  0.741959676
+## 17        1        3  0.738559175
+## 21        1        3  0.737981532
+## 33        1        3  0.724060094
+## 25        1        3  0.721037402
+## 39        1        3  0.718527842
+## 6         1        3  0.702644402
+## 9         1        3  0.696132723
+## 14        1        3  0.695119096
+## 45        1        3  0.694338305
+## 34        1        3  0.681434226
+## 15        1        3  0.660358295
+## 19        1        3  0.655738366
+## 16        1        3  0.597147161
+## 42        1        3  0.555054870
+## 64        2        3  0.471339064
+## 55        2        4  0.458317613
+## 52        2        4  0.443534424
+## 92        2        3  0.433142280
+## 59        2        4  0.431621613
+## 139       2        4  0.417405565
+## 76        2        3  0.415948453
+## 127       2        4  0.402579655
+## 73        2        4  0.399050400
+## 66        2        4  0.388387404
+## 74        2        3  0.372099711
+## 71        2        4  0.366704189
+## 57        2        4  0.363901411
+## 84        2        4  0.349237676
+## 79        2        3  0.347927387
+## 128       2        4  0.344414971
+## 86        2        3  0.342879650
+## 120       2        3  0.339139851
+## 122       2        4  0.324164232
+## 124       2        4  0.310947933
+## 87        2        4  0.296111811
+## 75        2        3  0.294712248
+## 114       2        4  0.287220191
+## 102       2        4  0.276114979
+## 143       2        4  0.276114979
+## 134       2        4  0.274416839
+## 77        2        4  0.262524104
+## 150       2        4  0.250702974
+## 98        2        3  0.207008254
+## 69        2        3  0.206965943
+## 147       2        4  0.186361678
+## 51        2        4  0.158584073
+## 88        2        3  0.154974194
+## 67        2        3  0.080197066
+## 53        2        4  0.068704364
+## 135       2        4  0.009859737
+## 115       2        4  0.007411473
+## 62        2        3 -0.010322685
+## 56        2        3 -0.018480568
+## 85        2        3 -0.056548190
+## 81        3        2  0.593063391
+## 82        3        2  0.588486416
+## 70        3        2  0.577829255
+## 90        3        2  0.541572577
+## 80        3        2  0.540075551
+## 94        3        2  0.527900827
+## 58        3        2  0.518504963
+## 54        3        2  0.510585771
+## 60        3        2  0.509830210
+## 61        3        2  0.497940985
+## 65        3        2  0.497569203
+## 83        3        2  0.489146497
+## 93        3        2  0.469694889
+## 99        3        1  0.458807124
+## 68        3        2  0.409714352
+## 100       3        2  0.400450702
+## 95        3        2  0.396521625
+## 89        3        2  0.348880615
+## 63        3        2  0.336954121
+## 91        3        2  0.295905041
+## 97        3        2  0.281018209
+## 96        3        2  0.262894448
+## 107       3        2  0.186381085
+## 72        3        2  0.161825540
+## 113       4        2  0.577935875
+## 105       4        5  0.577360661
+## 141       4        5  0.575917221
+## 125       4        5  0.550165260
+## 140       4        2  0.541953152
+## 133       4        2  0.496625982
+## 145       4        5  0.487427796
+## 137       4        2  0.486932219
+## 129       4        2  0.484485212
+## 121       4        5  0.461832625
+## 146       4        2  0.455480506
+## 116       4        2  0.450650676
+## 117       4        2  0.425816992
+## 101       4        5  0.425555783
+## 142       4        2  0.407031174
+## 144       4        5  0.401369810
+## 138       4        2  0.394312582
+## 149       4        2  0.388080059
+## 109       4        2  0.374157348
+## 104       4        2  0.351135503
+## 148       4        2  0.328372054
+## 111       4        2  0.256998908
+## 112       4        2  0.192307087
+## 103       4        5  0.154141472
+## 130       4        5  0.105352310
+## 78        4        2 -0.016348526
+## 126       4        5 -0.082878191
+## 106       5        4  0.565971497
+## 123       5        4  0.546749956
+## 119       5        4  0.477509712
+## 118       5        4  0.459700515
+## 132       5        4  0.439388428
+## 136       5        4  0.409060616
+## 108       5        4  0.312571293
+## 131       5        4  0.253594219
+## 110       5        4  0.082867697
+## Average silhouette width per cluster:
+## [1] 0.7575140 0.2733844 0.4333981 0.3797101 0.3941571
+## Average silhouette width of total data set:
+## [1] 0.4867481
+## 
+## Available components:
+##  [1] "medoids"    "id.med"     "clustering" "objective"  "isolation" 
+##  [6] "clusinfo"   "silinfo"    "diss"       "call"       "data"
+```
+
diff --git a/Desktop/open-source/R/documentation/random_forest.html b/Desktop/open-source/R/documentation/random_forest.html
new file mode 100644
index 00000000..046c94c5
--- /dev/null
+++ b/Desktop/open-source/R/documentation/random_forest.html
@@ -0,0 +1,142 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(randomForest)
+</code></pre>
+<pre><code>## Error in library(randomForest): there is no package called 'randomForest'
+</code></pre>
+<pre><code class="language-r">x &lt;- cbind(x_train,y_train)
+</code></pre>
+<pre><code>## Error in cbind(x_train, y_train): object 'x_train' not found
+</code></pre>
+<pre><code class="language-r"># Fitting model
+fit &lt;- randomForest(Species ~ ., x,ntree=500)
+</code></pre>
+<pre><code>## Error in randomForest(Species ~ ., x, ntree = 500): could not find function &quot;randomForest&quot;
+</code></pre>
+<pre><code class="language-r">summary(fit)
+</code></pre>
+<pre><code>## Error in summary(fit): object 'fit' not found
+</code></pre>
+<pre><code class="language-r"># Predict Output 
+predicted= predict(fit,x_test)
+</code></pre>
+<pre><code>## Error in predict(fit, x_test): object 'fit' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/random_forest.md b/Desktop/open-source/R/documentation/random_forest.md
new file mode 100644
index 00000000..63714ea2
--- /dev/null
+++ b/Desktop/open-source/R/documentation/random_forest.md
@@ -0,0 +1,44 @@
+
+
+``` r
+library(randomForest)
+```
+
+```
+## Error in library(randomForest): there is no package called 'randomForest'
+```
+
+``` r
+x <- cbind(x_train,y_train)
+```
+
+```
+## Error in cbind(x_train, y_train): object 'x_train' not found
+```
+
+``` r
+# Fitting model
+fit <- randomForest(Species ~ ., x,ntree=500)
+```
+
+```
+## Error in randomForest(Species ~ ., x, ntree = 500): could not find function "randomForest"
+```
+
+``` r
+summary(fit)
+```
+
+```
+## Error in summary(fit): object 'fit' not found
+```
+
+``` r
+# Predict Output 
+predicted= predict(fit,x_test)
+```
+
+```
+## Error in predict(fit, x_test): object 'fit' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/svm.html b/Desktop/open-source/R/documentation/svm.html
new file mode 100644
index 00000000..f4a95615
--- /dev/null
+++ b/Desktop/open-source/R/documentation/svm.html
@@ -0,0 +1,142 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(e1071)
+</code></pre>
+<pre><code>## Error in library(e1071): there is no package called 'e1071'
+</code></pre>
+<pre><code class="language-r">x &lt;- cbind(x_train,y_train)
+</code></pre>
+<pre><code>## Error in cbind(x_train, y_train): object 'x_train' not found
+</code></pre>
+<pre><code class="language-r"># Fitting model
+fit &lt;-svm(y_train ~ ., data = x)
+</code></pre>
+<pre><code>## Error in svm(y_train ~ ., data = x): could not find function &quot;svm&quot;
+</code></pre>
+<pre><code class="language-r">summary(fit)
+</code></pre>
+<pre><code>## Error in summary(fit): object 'fit' not found
+</code></pre>
+<pre><code class="language-r"># Predict Output 
+predicted= predict(fit,x_test)
+</code></pre>
+<pre><code>## Error in predict(fit, x_test): object 'fit' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/svm.md b/Desktop/open-source/R/documentation/svm.md
new file mode 100644
index 00000000..cb984245
--- /dev/null
+++ b/Desktop/open-source/R/documentation/svm.md
@@ -0,0 +1,44 @@
+
+
+``` r
+library(e1071)
+```
+
+```
+## Error in library(e1071): there is no package called 'e1071'
+```
+
+``` r
+x <- cbind(x_train,y_train)
+```
+
+```
+## Error in cbind(x_train, y_train): object 'x_train' not found
+```
+
+``` r
+# Fitting model
+fit <-svm(y_train ~ ., data = x)
+```
+
+```
+## Error in svm(y_train ~ ., data = x): could not find function "svm"
+```
+
+``` r
+summary(fit)
+```
+
+```
+## Error in summary(fit): object 'fit' not found
+```
+
+``` r
+# Predict Output 
+predicted= predict(fit,x_test)
+```
+
+```
+## Error in predict(fit, x_test): object 'fit' not found
+```
+
diff --git a/Desktop/open-source/R/documentation/xgboost.html b/Desktop/open-source/R/documentation/xgboost.html
new file mode 100644
index 00000000..c3407142
--- /dev/null
+++ b/Desktop/open-source/R/documentation/xgboost.html
@@ -0,0 +1,174 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
+<meta name="generator" content="litedown 0.7">
+<title></title>
+<style type="text/css">
+body {
+  font-family: sans-serif;
+  max-width: 800px;
+  margin: auto;
+  padding: 1em;
+  line-height: 1.5;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+body, .abstract, code, .footnotes, footer, #refs, .caption { font-size: .9em; }
+li li { font-size: .95em; }
+ul:has(li > input[type="checkbox"]) { list-style: none; padding-left: 1em; }
+*, :before, :after { box-sizing: border-box; }
+a { color: steelblue; }
+pre, img { max-width: 100%; }
+pre { white-space: pre-wrap; word-break: break-word; }
+pre code { display: block; padding: 1em; overflow-x: auto; }
+code { font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace; }
+:not(pre, th) > code, code[class], div > .caption { background: #f8f8f8; }
+pre > code:is(:not([class]), .language-plain, .language-none, .plain), .box, .figure, .table { background: inherit; border: 1px solid #eee; }
+pre > code {
+  &.message { border-color: #9eeaf9; }
+  &.warning { background: #fff3cd; border-color: #fff3cd; }
+  &.error { background: #f8d7da; border-color: #f8d7da; }
+}
+.fenced-chunk { border-left: 1px solid #666; }
+.code-fence {
+  opacity: .4;
+  border: 1px dashed #666;
+  border-left: 2px solid;
+  &:hover { opacity: inherit; }
+}
+.box, .figure, .table, table { margin: 1em auto; }
+div > .caption { padding: 1px 1em; }
+.figure { p:has(img, svg), pre:has(svg) { text-align: center; } }
+.flex-col { display: flex; justify-content: space-between; }
+table {
+  &:only-child:not(.table > *) { margin: auto; }
+  th, td { padding: 5px; font-variant-numeric: tabular-nums; }
+  thead, tfoot, tr:nth-child(even) { background: whitesmoke; }
+  thead th { border-bottom: 1px solid #ddd; }
+  &:not(.datatable-table) {
+    border-top: 1px solid #666;
+    border-bottom: 1px solid #666;
+  }
+}
+blockquote {
+  color: #666;
+  margin: 0;
+  padding: 1px 1em;
+  border-left: .5em solid #eee;
+}
+hr, .footnotes::before { border: 1px dashed #ddd; }
+.frontmatter { text-align: center; }
+#TOC {
+  a { text-decoration: none; }
+  ul { list-style: none; padding-left: 1em; }
+  & > ul { padding: 0; }
+  ul ul { border-left: 1px solid lightsteelblue; }
+}
+.body h2 { border-bottom: 1px solid #666; }
+.body .appendix, .appendix ~ h2 { border-bottom-style: dashed; }
+.main-number::after { content: "."; }
+span[class^="ref-number-"] { font-weight: bold; }
+.ref-number-fig::after, .ref-number-tab::after { content: ":"; }
+.cross-ref-chp::before { content: "Chapter "; }
+.cross-ref-sec::before { content: "Section "; }
+.cross-ref-fig::before, .ref-number-fig::before { content: "Figure "; }
+.cross-ref-tab::before, .ref-number-tab::before { content: "Table "; }
+.cross-ref-eqn::before, .MathJax_ref:has(mjx-mtext > mjx-c + mjx-c)::before { content: "Equation "; }
+.abstract, #refs {
+  &::before { display: block; margin: 1em auto; font-weight: bold; }
+}
+.abstract::before { content: "Abstract"; text-align: center; }
+#refs::before { content: "Bibliography"; font-size: 1.5em; }
+.ref-paren-open::before { content: "("; }
+.ref-paren-close::after { content: ")"; }
+.ref-semicolon::after { content: "; "; }
+.ref-and::after { content: " and "; }
+.ref-et-al::after { content: " et al."; font-style: italic; }
+.footnote-ref a {
+  &::before { content: "["; }
+  &::after { content: "]"; }
+}
+section.footnotes {
+  margin-top: 2em;
+  &::before { content: ""; display: block; max-width: 20em; }
+}
+.fade {
+  background: repeating-linear-gradient(135deg, white, white 30px, #ddd 32px, #ddd 32px);
+  opacity: 0.6;
+}
+
+@media print {
+  body { max-width: 100%; }
+  tr, img { break-inside: avoid; }
+}
+@media only screen and (min-width: 992px) {
+  body:not(.pagesjs) pre:has(.line-numbers):not(:hover) { white-space: pre; }
+}
+</style>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xiee/utils@1.14.14/css/prism-xcode.min.css">
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-core.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/prismjs@1.29.0/plugins/autoloader/prism-autoloader.min.js" defer></script>
+</head>
+<body>
+<div class="frontmatter">
+</div>
+<div class="body">
+<pre><code class="language-r">library(tidyverse)
+</code></pre>
+<pre><code>## Error in library(tidyverse): there is no package called 'tidyverse'
+</code></pre>
+<pre><code class="language-r">library(xgboost)
+</code></pre>
+<pre><code>## Error in library(xgboost): there is no package called 'xgboost'
+</code></pre>
+<pre><code class="language-r">ind&lt;-sample(2,nrow(diamonds),replace = T,prob = c(0.7,0.3))
+</code></pre>
+<pre><code>## Error in nrow(diamonds): object 'diamonds' not found
+</code></pre>
+<pre><code class="language-r">train.set&lt;-diamonds[ind==1,]
+</code></pre>
+<pre><code>## Error: object 'diamonds' not found
+</code></pre>
+<pre><code class="language-r">test.set&lt;-diamonds[ind==2,]
+</code></pre>
+<pre><code>## Error: object 'diamonds' not found
+</code></pre>
+<pre><code class="language-r">xgb.train&lt;-bind_cols(select_if(train.set,is.numeric),model.matrix(~cut-1,train.set) %&gt;% as.tibble(),model.matrix(~color-1,train.set) %&gt;% as.tibble(),model.matrix(~clarity-1,train.set) %&gt;% as.tibble())
+</code></pre>
+<pre><code>## Error in bind_cols(select_if(train.set, is.numeric), model.matrix(~cut - : could not find function &quot;bind_cols&quot;
+</code></pre>
+<pre><code class="language-r">xgboost.train&lt;-xgb.DMatrix(data = as.matrix(select(xgb.train,-price)),label=xgb.train$price)
+</code></pre>
+<pre><code>## Error in xgb.DMatrix(data = as.matrix(select(xgb.train, -price)), label = xgb.train$price): could not find function &quot;xgb.DMatrix&quot;
+</code></pre>
+<pre><code class="language-r">xgb.test&lt;-bind_cols(select_if(test.set,is.numeric),model.matrix(~cut-1,test.set) %&gt;% as.tibble(),model.matrix(~color-1,test.set) %&gt;% as.tibble(),model.matrix(~clarity-1,test.set) %&gt;% as.tibble())
+</code></pre>
+<pre><code>## Error in bind_cols(select_if(test.set, is.numeric), model.matrix(~cut - : could not find function &quot;bind_cols&quot;
+</code></pre>
+<pre><code class="language-r">xgboost.test&lt;-xgb.DMatrix(data = select(xgb.test,-price) %&gt;% as.matrix(),label=xgb.test$price)
+</code></pre>
+<pre><code>## Error in xgb.DMatrix(data = select(xgb.test, -price) %&gt;% as.matrix(), : could not find function &quot;xgb.DMatrix&quot;
+</code></pre>
+<pre><code class="language-r">param&lt;-list(eval_metric='rmse',gamma=1,max_depth=6,nthread = 3)
+xg.model&lt;-xgb.train(data = xgboost.train,params = param,watchlist = list(test=xgboost.test),nrounds = 500,early_stopping_rounds = 60,
+                      print_every_n = 30)
+</code></pre>
+<pre><code>## Error in xgb.train(data = xgboost.train, params = param, watchlist = list(test = xgboost.test), : could not find function &quot;xgb.train&quot;
+</code></pre>
+<pre><code class="language-r">xg.predict&lt;-predict(xg.model,xgboost.test)
+</code></pre>
+<pre><code>## Error in predict(xg.model, xgboost.test): object 'xg.model' not found
+</code></pre>
+<pre><code class="language-r">mse.xgb&lt;-sqrt(mean((test.set$price-xg.predict)^2))
+</code></pre>
+<pre><code>## Error in mean((test.set$price - xg.predict)^2): object 'test.set' not found
+</code></pre>
+<pre><code class="language-r">plot((test.set$price-xg.predict))
+</code></pre>
+<pre><code>## Error in plot((test.set$price - xg.predict)): object 'test.set' not found
+</code></pre>
+</div>
+</body>
+</html>
diff --git a/Desktop/open-source/R/documentation/xgboost.md b/Desktop/open-source/R/documentation/xgboost.md
new file mode 100644
index 00000000..1e598862
--- /dev/null
+++ b/Desktop/open-source/R/documentation/xgboost.md
@@ -0,0 +1,108 @@
+
+
+``` r
+library(tidyverse)
+```
+
+```
+## Error in library(tidyverse): there is no package called 'tidyverse'
+```
+
+``` r
+library(xgboost)
+```
+
+```
+## Error in library(xgboost): there is no package called 'xgboost'
+```
+
+``` r
+ind<-sample(2,nrow(diamonds),replace = T,prob = c(0.7,0.3))
+```
+
+```
+## Error in nrow(diamonds): object 'diamonds' not found
+```
+
+``` r
+train.set<-diamonds[ind==1,]
+```
+
+```
+## Error: object 'diamonds' not found
+```
+
+``` r
+test.set<-diamonds[ind==2,]
+```
+
+```
+## Error: object 'diamonds' not found
+```
+
+``` r
+xgb.train<-bind_cols(select_if(train.set,is.numeric),model.matrix(~cut-1,train.set) %>% as.tibble(),model.matrix(~color-1,train.set) %>% as.tibble(),model.matrix(~clarity-1,train.set) %>% as.tibble())
+```
+
+```
+## Error in bind_cols(select_if(train.set, is.numeric), model.matrix(~cut - : could not find function "bind_cols"
+```
+
+``` r
+xgboost.train<-xgb.DMatrix(data = as.matrix(select(xgb.train,-price)),label=xgb.train$price)
+```
+
+```
+## Error in xgb.DMatrix(data = as.matrix(select(xgb.train, -price)), label = xgb.train$price): could not find function "xgb.DMatrix"
+```
+
+``` r
+xgb.test<-bind_cols(select_if(test.set,is.numeric),model.matrix(~cut-1,test.set) %>% as.tibble(),model.matrix(~color-1,test.set) %>% as.tibble(),model.matrix(~clarity-1,test.set) %>% as.tibble())
+```
+
+```
+## Error in bind_cols(select_if(test.set, is.numeric), model.matrix(~cut - : could not find function "bind_cols"
+```
+
+``` r
+xgboost.test<-xgb.DMatrix(data = select(xgb.test,-price) %>% as.matrix(),label=xgb.test$price)
+```
+
+```
+## Error in xgb.DMatrix(data = select(xgb.test, -price) %>% as.matrix(), : could not find function "xgb.DMatrix"
+```
+
+``` r
+param<-list(eval_metric='rmse',gamma=1,max_depth=6,nthread = 3)
+xg.model<-xgb.train(data = xgboost.train,params = param,watchlist = list(test=xgboost.test),nrounds = 500,early_stopping_rounds = 60,
+                      print_every_n = 30)
+```
+
+```
+## Error in xgb.train(data = xgboost.train, params = param, watchlist = list(test = xgboost.test), : could not find function "xgb.train"
+```
+
+``` r
+xg.predict<-predict(xg.model,xgboost.test)
+```
+
+```
+## Error in predict(xg.model, xgboost.test): object 'xg.model' not found
+```
+
+``` r
+mse.xgb<-sqrt(mean((test.set$price-xg.predict)^2))
+```
+
+```
+## Error in mean((test.set$price - xg.predict)^2): object 'test.set' not found
+```
+
+``` r
+plot((test.set$price-xg.predict))
+```
+
+```
+## Error in plot((test.set$price - xg.predict)): object 'test.set' not found
+```
+
diff --git a/Desktop/open-source/R/dynamic_programming/0/0/1_knapsack_problem.r b/Desktop/open-source/R/dynamic_programming/0/0/1_knapsack_problem.r
new file mode 100644
index 00000000..4ff1cc3a
--- /dev/null
+++ b/Desktop/open-source/R/dynamic_programming/0/0/1_knapsack_problem.r
@@ -0,0 +1,194 @@
+# 0/1 Knapsack Problem (Dynamic Programming)
+#
+# The 0/1 Knapsack problem is one of the most classic problems in dynamic programming.
+# Given a set of items, each with a weight and a value, determine the maximum total value
+# you can obtain by putting items in a knapsack with a fixed capacity. Each item can
+# either be included (1) or excluded (0) — hence the name "0/1".
+#
+# Time Complexity: O(n * W)  where n = number of items, W = knapsack capacity
+# Space Complexity: O(n * W)  for full DP table, O(W) for optimized version
+#
+# Applications:
+# - Budget allocation problems
+# - Resource optimization (CPU scheduling, project selection)
+# - Portfolio selection in finance
+# - Cargo loading and packing
+# - Subset optimization in AI planning
+
+# Classic DP solution for 0/1 Knapsack
+knapsack_01 <- function(weights, values, capacity) {
+  #' Solve 0/1 Knapsack Problem using Dynamic Programming
+  #' @param weights: Numeric vector of item weights
+  #' @param values: Numeric vector of item values
+  #' @param capacity: Maximum weight capacity of the knapsack
+  #' @return: List containing max value, selected items, and DP table
+  
+  n <- length(values)
+  
+  # Handle edge case
+  if (n == 0 || capacity == 0) {
+    return(list(
+      max_value = 0,
+      selected_items = c(),
+      dp_table = matrix(0, nrow = n + 1, ncol = capacity + 1)
+    ))
+  }
+  
+  # Create DP table: dp[i, w] = max value using first i items with capacity w
+  dp <- matrix(0, nrow = n + 1, ncol = capacity + 1)
+  
+  # Fill DP table
+  for (i in 1:n) {
+    for (w in 0:capacity) {
+      # Don't include item i
+      dp[i + 1, w + 1] <- dp[i, w + 1]
+      
+      # Include item i (if it fits)
+      if (weights[i] <= w) {
+        include_value <- values[i] + dp[i, w - weights[i] + 1]
+        dp[i + 1, w + 1] <- max(dp[i + 1, w + 1], include_value)
+      }
+    }
+  }
+  
+  # Backtrack to find selected items
+  selected <- c()
+  i <- n
+  w <- capacity
+  
+  while (i > 0 && w > 0) {
+    # If value came from including item i
+    if (dp[i + 1, w + 1] != dp[i, w + 1]) {
+      selected <- c(i, selected)
+      w <- w - weights[i]
+    }
+    i <- i - 1
+  }
+  
+  return(list(
+    max_value = dp[n + 1, capacity + 1],
+    selected_items = selected,
+    dp_table = dp
+  ))
+}
+
+# Space-optimized version using only 1D array
+knapsack_01_optimized <- function(weights, values, capacity) {
+  #' Space optimized 0/1 Knapsack using 1D array
+  #' @return: Maximum total value
+  
+  n <- length(values)
+  
+  if (n == 0 || capacity == 0) {
+    return(0)
+  }
+  
+  dp <- rep(0, capacity + 1)
+  
+  # Process each item
+  for (i in 1:n) {
+    # Traverse from right to left to avoid overwriting needed values
+    for (w in capacity:weights[i]) {
+      if (weights[i] <= w) {
+        dp[w + 1] <- max(dp[w + 1], values[i] + dp[w - weights[i] + 1])
+      }
+    }
+  }
+  
+  return(dp[capacity + 1])
+}
+
+# Helper function to print DP table
+print_knapsack_dp <- function(dp_table, weights, values, capacity) {
+  cat("DP Table for 0/1 Knapsack:\n")
+  cat("Weights:", paste(weights, collapse = ", "), "\n")
+  cat("Values :", paste(values, collapse = ", "), "\n")
+  cat("Capacity:", capacity, "\n\n")
+  
+  # Print capacity headers
+  cat("        ")
+  cat(paste(sprintf("%3d", 0:capacity), collapse = " "))
+  cat("\n")
+  cat(paste(rep("-", 8 + 4 * (capacity + 1)), collapse = ""), "\n")
+  
+  for (i in 1:nrow(dp_table)) {
+    cat(sprintf("Item %2d | ", i - 1))
+    cat(paste(sprintf("%3d", dp_table[i, ]), collapse = " "))
+    cat("\n")
+  }
+  cat("\n")
+}
+
+# ===========================
+# Example Usage & Testing
+# ===========================
+cat("=== 0/1 Knapsack Problem (Dynamic Programming) ===\n\n")
+
+# Test 1: Basic Example
+weights <- c(1, 3, 4, 5)
+values <- c(1, 4, 5, 7)
+capacity <- 7
+
+cat("Test 1: Basic Example\n")
+cat("Weights:", paste(weights, collapse = ", "), "\n")
+cat("Values :", paste(values, collapse = ", "), "\n")
+cat("Capacity:", capacity, "\n\n")
+
+result <- knapsack_01(weights, values, capacity)
+print_knapsack_dp(result$dp_table, weights, values, capacity)
+cat("Maximum Value:", result$max_value, "\n")
+cat("Selected Item Indices:", paste(result$selected_items, collapse = ", "), "\n")
+cat("Total Weight:", sum(weights[result$selected_items]), "\n")
+cat("Total Value:", sum(values[result$selected_items]), "\n\n")
+
+# Test 2: Space Optimized Example
+cat("Test 2: Space Optimized Version\n")
+max_val_opt <- knapsack_01_optimized(weights, values, capacity)
+cat("Maximum Value (Optimized):", max_val_opt, "\n")
+cat("Verification: Both methods match:", result$max_value == max_val_opt, "\n\n")
+
+# Test 3: Larger Dataset
+cat("Test 3: Larger Dataset\n")
+set.seed(42)
+weights <- sample(1:15, 10)
+values <- sample(10:100, 10)
+capacity <- 35
+
+cat("Weights:", paste(weights, collapse = ", "), "\n")
+cat("Values :", paste(values, collapse = ", "), "\n")
+cat("Capacity:", capacity, "\n\n")
+
+large_result <- knapsack_01(weights, values, capacity)
+cat("Maximum Value:", large_result$max_value, "\n")
+cat("Selected Items:", paste(large_result$selected_items, collapse = ", "), "\n")
+cat("Total Weight:", sum(weights[large_result$selected_items]), "\n\n")
+
+# Test 4: Edge Cases
+cat("Test 4: Edge Cases\n")
+cat("Empty items:", knapsack_01(c(), c(), 10)$max_value, "\n")
+cat("Zero capacity:", knapsack_01(weights, values, 0)$max_value, "\n")
+cat("Single item fits:", knapsack_01(c(5), c(10), 10)$max_value, "\n")
+cat("Single item doesn't fit:", knapsack_01(c(10), c(10), 5)$max_value, "\n\n")
+
+# Test 5: Performance Check
+cat("Test 5: Performance Comparison (n=100)\n")
+n <- 100
+weights <- sample(1:15, n, replace = TRUE)
+values <- sample(10:100, n, replace = TRUE)
+capacity <- 200
+
+start_time <- Sys.time()
+res_std <- knapsack_01_optimized(weights, values, capacity)
+std_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Optimized DP result:", res_std, "\n")
+cat("Time taken:", sprintf("%.4f sec", std_time), "\n")
+
+# Verify correctness
+cat("\nVerifying correctness with full DP:\n")
+start_time <- Sys.time()
+res_full <- knapsack_01(weights, values, capacity)
+full_time <- as.numeric(Sys.time() - start_time, units = "secs")
+cat("Full DP result:", res_full$max_value, "\n")
+cat("Time taken:", sprintf("%.4f sec", full_time), "\n")
+cat("Results match:", res_std == res_full$max_value, "\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/dynamic_programming/0/1_knapsack_problem.r b/Desktop/open-source/R/dynamic_programming/0/1_knapsack_problem.r
new file mode 100644
index 00000000..c64dd730
--- /dev/null
+++ b/Desktop/open-source/R/dynamic_programming/0/1_knapsack_problem.r
@@ -0,0 +1,155 @@
+# 0/1 Knapsack Problem (Dynamic Programming)
+#
+# The 0/1 Knapsack problem is one of the most classic problems in dynamic programming.
+# Given a set of items, each with a weight and a value, determine the maximum total value
+# you can obtain by putting items in a knapsack with a fixed capacity. Each item can
+# either be included (1) or excluded (0) — hence the name "0/1".
+#
+# Time Complexity: O(n * W)  where n = number of items, W = knapsack capacity
+# Space Complexity: O(n * W)  for full DP table, O(W) for optimized version
+#
+# Applications:
+# - Budget allocation problems
+# - Resource optimization (CPU scheduling, project selection)
+# - Portfolio selection in finance
+# - Cargo loading and packing
+# - Subset optimization in AI planning
+
+# Classic DP solution for 0/1 Knapsack
+knapsack_01 <- function(weights, values, capacity) {
+  #' Solve 0/1 Knapsack Problem using Dynamic Programming
+  #' @param weights: Numeric vector of item weights
+  #' @param values: Numeric vector of item values
+  #' @param capacity: Maximum weight capacity of the knapsack
+  #' @return: List containing max value, selected items, and DP table
+  
+  n <- length(values)
+  dp <- matrix(0, nrow = n + 1, ncol = capacity + 1)
+  
+  # Fill DP table
+  for (i in 2:(n + 1)) {
+    for (w in 0:capacity) {
+      if (weights[i - 1] <= w) {
+        include <- values[i - 1] + dp[i - 1, w - weights[i - 1] + 1]
+        exclude <- dp[i - 1, w + 1]
+        dp[i, w + 1] <- max(include, exclude)
+      } else {
+        dp[i, w + 1] <- dp[i - 1, w + 1]
+      }
+    }
+  }
+  
+  # Backtrack to find selected items
+  res_value <- dp[n + 1, capacity + 1]
+  selected <- c()
+  w <- capacity
+  
+  for (i in n:1) {
+    if (res_value <= 0) break
+    if (res_value == dp[i, w + 1]) next
+    
+    # Item i is included
+    selected <- c(i, selected)
+    res_value <- res_value - values[i]
+    w <- w - weights[i]
+  }
+  
+  return(list(
+    max_value = dp[n + 1, capacity + 1],
+    selected_items = selected,
+    dp_table = dp
+  ))
+}
+
+# Space-optimized version using only 1D array
+knapsack_01_optimized <- function(weights, values, capacity) {
+  #' Space optimized 0/1 Knapsack using 1D array
+  #' @return: Maximum total value
+  
+  n <- length(values)
+  dp <- rep(0, capacity + 1)
+  
+  for (i in 1:n) {
+    for (w in capacity:weights[i]) {
+      dp[w + 1] <- max(dp[w + 1], values[i] + dp[w - weights[i] + 1])
+    }
+  }
+  
+  return(dp[capacity + 1])
+}
+
+# Helper function to print DP table
+print_knapsack_dp <- function(dp_table, weights, values, capacity) {
+  cat("DP Table for 0/1 Knapsack:\n")
+  cat("Weights:", paste(weights, collapse = ", "), "\n")
+  cat("Values :", paste(values, collapse = ", "), "\n")
+  cat("Capacity:", capacity, "\n\n")
+  
+  for (i in 1:nrow(dp_table)) {
+    cat(sprintf("Item %2d | ", i - 1))
+    cat(paste(sprintf("%3d", dp_table[i, ]), collapse = " "))
+    cat("\n")
+  }
+  cat("\n")
+}
+
+# ===========================
+# Example Usage & Testing
+# ===========================
+cat("=== 0/1 Knapsack Problem (Dynamic Programming) ===\n\n")
+
+# Test 1: Basic Example
+weights <- c(1, 3, 4, 5)
+values <- c(1, 4, 5, 7)
+capacity <- 7
+
+cat("Test 1: Basic Example\n")
+cat("Weights:", paste(weights, collapse = ", "), "\n")
+cat("Values :", paste(values, collapse = ", "), "\n")
+cat("Capacity:", capacity, "\n\n")
+
+result <- knapsack_01(weights, values, capacity)
+print_knapsack_dp(result$dp_table, weights, values, capacity)
+cat("Maximum Value:", result$max_value, "\n")
+cat("Selected Item Indices:", paste(result$selected_items, collapse = ", "), "\n\n")
+
+# Test 2: Space Optimized Example
+cat("Test 2: Space Optimized Version\n")
+max_val_opt <- knapsack_01_optimized(weights, values, capacity)
+cat("Maximum Value (Optimized):", max_val_opt, "\n\n")
+
+# Test 3: Larger Dataset
+cat("Test 3: Larger Dataset\n")
+set.seed(42)
+weights <- sample(1:15, 10)
+values <- sample(10:100, 10)
+capacity <- 35
+
+cat("Weights:", paste(weights, collapse = ", "), "\n")
+cat("Values :", paste(values, collapse = ", "), "\n")
+cat("Capacity:", capacity, "\n\n")
+
+large_result <- knapsack_01(weights, values, capacity)
+cat("Maximum Value:", large_result$max_value, "\n")
+cat("Selected Items:", paste(large_result$selected_items, collapse = ", "), "\n\n")
+
+# Test 4: Edge Cases
+cat("Test 4: Edge Cases\n")
+cat("Empty items:", knapsack_01(c(), c(), 10)$max_value, "\n")
+cat("Zero capacity:", knapsack_01(weights, values, 0)$max_value, "\n")
+cat("Single item fits:", knapsack_01(c(5), c(10), 10)$max_value, "\n")
+cat("Single item doesn't fit:", knapsack_01(c(10), c(10), 5)$max_value, "\n\n")
+
+# Test 5: Performance Check
+cat("Test 5: Performance Comparison (n=100)\n")
+n <- 100
+weights <- sample(1:15, n, replace = TRUE)
+values <- sample(10:100, n, replace = TRUE)
+capacity <- 200
+
+start_time <- Sys.time()
+res_std <- knapsack_01_optimized(weights, values, capacity)
+std_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Optimized DP result:", res_std, "\n")
+cat("Time taken:", sprintf("%.4f sec", std_time), "\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/dynamic_programming/coin_change.r b/Desktop/open-source/R/dynamic_programming/coin_change.r
new file mode 100644
index 00000000..444246bd
--- /dev/null
+++ b/Desktop/open-source/R/dynamic_programming/coin_change.r
@@ -0,0 +1,76 @@
+# Coin Change Problem
+#
+# The Coin Change problem finds the minimum number of coins needed to make a certain amount
+# using a given set of coin denominations.
+#
+# Time Complexity: O(amount * n) where n = number of coin denominations
+# Space Complexity: O(amount)
+#
+# Applications:
+# - Currency and cash management
+# - Making change in vending machines or payment systems
+# - Dynamic resource allocation
+# - Minimum cost problems in algorithms
+
+# Function to compute minimum coins required
+coin_change <- function(coins, amount) {
+  #' Compute minimum number of coins needed to make the given amount
+  #' @param coins: Numeric vector of coin denominations
+  #' @param amount: Total amount to make
+  #' @return: Minimum number of coins required, or -1 if not possible
+  
+  # Initialize DP array
+  dp <- rep(Inf, amount + 1)
+  dp[0 + 1] <- 0  # zero coins needed for amount 0
+  
+  for (i in 1:amount) {
+    for (coin in coins) {
+      if (coin <= i) {
+        dp[i + 1] <- min(dp[i + 1], 1 + dp[i - coin + 1])
+      }
+    }
+  }
+  
+  if (dp[amount + 1] == Inf) {
+    return(-1)
+  } else {
+    return(dp[amount + 1])
+  }
+}
+
+# Function to print the DP table (for educational purposes)
+print_coin_change_dp <- function(dp, amount) {
+  cat("DP Table for Coin Change:\n")
+  for (i in 0:amount) {
+    cat(sprintf("Amount %2d: %s\n", i, dp[i + 1]))
+  }
+  cat("\n")
+}
+
+
+# Example Usage & Testing
+cat("=== Coin Change Problem ===\n\n")
+
+# Test 1: Basic Example
+coins <- c(1, 2, 5)
+amount <- 11
+cat("Coins:", paste(coins, collapse = ", "), "\n")
+cat("Amount:", amount, "\n")
+min_coins <- coin_change(coins, amount)
+cat("Minimum Coins Needed:", min_coins, "\n\n")
+
+# Test 2: No solution case
+coins <- c(2, 4)
+amount <- 7
+cat("Coins:", paste(coins, collapse = ", "), "\n")
+cat("Amount:", amount, "\n")
+min_coins <- coin_change(coins, amount)
+cat("Minimum Coins Needed:", min_coins, "\n\n")
+
+# Test 3: Larger dataset
+coins <- c(1, 3, 4, 5)
+amount <- 7
+cat("Coins:", paste(coins, collapse = ", "), "\n")
+cat("Amount:", amount, "\n")
+min_coins <- coin_change(coins, amount)
+cat("Minimum Coins Needed:", min_coins, "\n\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/dynamic_programming/longest_common_subsequence.r b/Desktop/open-source/R/dynamic_programming/longest_common_subsequence.r
new file mode 100644
index 00000000..778282d9
--- /dev/null
+++ b/Desktop/open-source/R/dynamic_programming/longest_common_subsequence.r
@@ -0,0 +1,391 @@
+# Longest Common Subsequence (LCS) Algorithm
+#
+# The LCS problem finds the longest subsequence common to two sequences.
+# A subsequence is a sequence derived from another sequence by deleting some 
+# or no elements without changing the order of the remaining elements.
+#
+# Time Complexity: O(m * n) where m, n are lengths of the sequences
+# Space Complexity: O(m * n) for the DP table, O(min(m, n)) optimized version
+#
+# Applications:
+# - DNA sequence analysis in bioinformatics
+# - File difference utilities (diff command)  
+# - Version control systems (git diff)
+# - Plagiarism detection
+# - Data compression algorithms
+# - Edit distance calculations
+
+# Basic LCS algorithm with full DP table
+lcs_length <- function(str1, str2) {
+  #' Find the length of longest common subsequence
+  #' @param str1: First string
+  #' @param str2: Second string  
+  #' @return: Length of LCS
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  # Create DP table
+  dp <- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] <- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        dp[i, j] <- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] <- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  return(dp[m + 1, n + 1])
+}
+
+# LCS algorithm that returns the actual subsequence
+lcs_string <- function(str1, str2) {
+  #' Find the longest common subsequence string
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @return: List containing LCS string and its length
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  # Create DP table
+  dp <- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] <- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        dp[i, j] <- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] <- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  # Backtrack to find the actual LCS string
+  lcs <- ""
+  i <- m + 1
+  j <- n + 1
+  
+  while (i > 1 && j > 1) {
+    if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+      lcs <- paste0(substr(str1, i - 1, i - 1), lcs)
+      i <- i - 1
+      j <- j - 1
+    } else if (dp[i - 1, j] > dp[i, j - 1]) {
+      i <- i - 1
+    } else {
+      j <- j - 1
+    }
+  }
+  
+  return(list(
+    lcs = lcs,
+    length = dp[m + 1, n + 1],
+    dp_table = dp
+  ))
+}
+
+# Space-optimized LCS (only returns length)
+lcs_length_optimized <- function(str1, str2) {
+  #' Space-optimized LCS length calculation
+  #' Uses only O(min(m, n)) space instead of O(m * n)
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @return: Length of LCS
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  # Make str1 the shorter string for space optimization
+  if (m > n) {
+    temp <- str1
+    str1 <- str2
+    str2 <- temp
+    temp <- m
+    m <- n
+    n <- temp
+  }
+  
+  # Use two arrays instead of full matrix
+  prev <- rep(0, m + 1)
+  curr <- rep(0, m + 1)
+  
+  for (j in 1:(n + 1)) {
+    for (i in 1:(m + 1)) {
+      if (i == 1 || j == 1) {
+        curr[i] <- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        curr[i] <- prev[i - 1] + 1
+      } else {
+        curr[i] <- max(prev[i], curr[i - 1])
+      }
+    }
+    # Swap arrays
+    temp <- prev
+    prev <- curr
+    curr <- temp
+  }
+  
+  return(prev[m + 1])
+}
+
+# Find all possible LCS strings (there can be multiple)
+find_all_lcs <- function(str1, str2) {
+  #' Find all possible longest common subsequences
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @return: List of all LCS strings
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  # Create DP table
+  dp <- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] <- 0
+      } else if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+        dp[i, j] <- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] <- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  # Recursive function to find all LCS
+  find_all_lcs_recursive <- function(i, j) {
+    if (i == 1 || j == 1) {
+      return("")
+    }
+    
+    if (substr(str1, i - 1, i - 1) == substr(str2, j - 1, j - 1)) {
+      char <- substr(str1, i - 1, i - 1)
+      prev_lcs <- find_all_lcs_recursive(i - 1, j - 1)
+      return(paste0(prev_lcs, char))
+    } else {
+      results <- c()
+      
+      if (dp[i - 1, j] == dp[i, j]) {
+        results <- c(results, find_all_lcs_recursive(i - 1, j))
+      }
+      
+      if (dp[i, j - 1] == dp[i, j]) {
+        results <- c(results, find_all_lcs_recursive(i, j - 1))
+      }
+      
+      return(unique(results))
+    }
+  }
+  
+  all_lcs <- find_all_lcs_recursive(m + 1, n + 1)
+  return(unique(all_lcs))
+}
+
+# LCS for arrays/vectors instead of strings
+lcs_array <- function(arr1, arr2) {
+  #' Find LCS of two arrays/vectors
+  #' @param arr1: First array
+  #' @param arr2: Second array
+  #' @return: List with LCS array and length
+  
+  m <- length(arr1)
+  n <- length(arr2)
+  
+  # Create DP table
+  dp <- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  # Fill the DP table
+  for (i in 1:(m + 1)) {
+    for (j in 1:(n + 1)) {
+      if (i == 1 || j == 1) {
+        dp[i, j] <- 0
+      } else if (arr1[i - 1] == arr2[j - 1]) {
+        dp[i, j] <- dp[i - 1, j - 1] + 1
+      } else {
+        dp[i, j] <- max(dp[i - 1, j], dp[i, j - 1])
+      }
+    }
+  }
+  
+  # Backtrack to find the actual LCS
+  lcs <- c()
+  i <- m + 1
+  j <- n + 1
+  
+  while (i > 1 && j > 1) {
+    if (arr1[i - 1] == arr2[j - 1]) {
+      lcs <- c(arr1[i - 1], lcs)
+      i <- i - 1
+      j <- j - 1
+    } else if (dp[i - 1, j] > dp[i, j - 1]) {
+      i <- i - 1
+    } else {
+      j <- j - 1
+    }
+  }
+  
+  return(list(
+    lcs = lcs,
+    length = dp[m + 1, n + 1]
+  ))
+}
+
+# Function to print the DP table (for educational purposes)
+print_dp_table <- function(str1, str2, dp_table) {
+  #' Print the DP table in a readable format
+  #' @param str1: First string
+  #' @param str2: Second string
+  #' @param dp_table: DP table from lcs_string function
+  
+  m <- nchar(str1)
+  n <- nchar(str2)
+  
+  cat("DP Table for LCS calculation:\n")
+  cat("String 1:", str1, "\n")
+  cat("String 2:", str2, "\n\n")
+  
+  # Print column headers
+  cat("     ε ")
+  for (j in 1:n) {
+    cat(sprintf("%2s ", substr(str2, j, j)))
+  }
+  cat("\n")
+  
+  # Print table rows
+  for (i in 1:(m + 1)) {
+    if (i == 1) {
+      cat("  ε  ")
+    } else {
+      cat(sprintf("%2s   ", substr(str1, i - 1, i - 1)))
+    }
+    
+    for (j in 1:(n + 1)) {
+      cat(sprintf("%2d ", dp_table[i, j]))
+    }
+    cat("\n")
+  }
+  cat("\n")
+}
+
+# Example usage and testing
+cat("=== Longest Common Subsequence (LCS) Algorithm ===\n\n")
+
+# Test 1: Basic LCS example
+cat("1. Basic LCS Example\n")
+str1 <- "ABCDGH"
+str2 <- "AEDFHR"
+
+cat("String 1:", str1, "\n")
+cat("String 2:", str2, "\n")
+
+result1 <- lcs_string(str1, str2)
+cat("LCS:", result1$lcs, "\n")
+cat("Length:", result1$length, "\n")
+
+print_dp_table(str1, str2, result1$dp_table)
+
+# Test 2: DNA sequence analysis
+cat("2. DNA Sequence Analysis\n")
+dna1 <- "ATCGATCGATCG"
+dna2 <- "ATGCGATGCATG"
+
+cat("DNA Sequence 1:", dna1, "\n")
+cat("DNA Sequence 2:", dna2, "\n")
+
+dna_result <- lcs_string(dna1, dna2)
+cat("Common subsequence:", dna_result$lcs, "\n")
+cat("Length:", dna_result$length, "\n")
+cat("Similarity:", sprintf("%.2f%%", dna_result$length / max(nchar(dna1), nchar(dna2)) * 100), "\n\n")
+
+# Test 3: Finding all possible LCS
+cat("3. Multiple LCS Solutions\n")
+str3 <- "ABCDEF"
+str4 <- "ACBDEF"
+
+cat("String 1:", str3, "\n")
+cat("String 2:", str4, "\n")
+
+all_lcs <- find_all_lcs(str3, str4)
+cat("All possible LCS:\n")
+for (i in seq_along(all_lcs)) {
+  cat("  ", i, ":", all_lcs[i], "\n")
+}
+cat("\n")
+
+# Test 4: Array LCS example
+cat("4. Array LCS Example\n")
+arr1 <- c(1, 2, 3, 4, 5)
+arr2 <- c(2, 3, 5, 7, 8)
+
+cat("Array 1:", paste(arr1, collapse = ", "), "\n")
+cat("Array 2:", paste(arr2, collapse = ", "), "\n")
+
+arr_result <- lcs_array(arr1, arr2)
+cat("LCS Array:", paste(arr_result$lcs, collapse = ", "), "\n")
+cat("Length:", arr_result$length, "\n\n")
+
+# Test 5: Performance comparison
+cat("5. Performance Comparison\n")
+long_str1 <- paste(sample(LETTERS[1:5], 100, replace = TRUE), collapse = "")
+long_str2 <- paste(sample(LETTERS[1:5], 100, replace = TRUE), collapse = "")
+
+cat("Testing with strings of length 100...\n")
+
+# Standard algorithm
+start_time <- Sys.time()
+standard_result <- lcs_length(long_str1, long_str2)
+standard_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+# Optimized algorithm  
+start_time <- Sys.time()
+optimized_result <- lcs_length_optimized(long_str1, long_str2)
+optimized_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Standard algorithm: LCS length =", standard_result, 
+    "Time:", sprintf("%.6f", standard_time), "seconds\n")
+cat("Optimized algorithm: LCS length =", optimized_result, 
+    "Time:", sprintf("%.6f", optimized_time), "seconds\n")
+cat("Results match:", standard_result == optimized_result, "\n\n")
+
+# Test 6: Edge cases
+cat("6. Edge Cases\n")
+cat("Empty strings:", lcs_length("", "ABC"), "\n")
+cat("One empty string:", lcs_length("ABC", ""), "\n")
+cat("Identical strings:", lcs_length("HELLO", "HELLO"), "\n")
+cat("No common characters:", lcs_length("ABC", "DEF"), "\n")
+cat("Single character:", lcs_length("A", "A"), "\n")
+cat("Single vs multiple:", lcs_length("A", "ABCDEF"), "\n\n")
+
+# Test 7: Real-world example - File diff simulation
+cat("7. File Diff Simulation\n")
+file1_lines <- c("Hello World", "This is line 2", "Line 3 here", "Final line")
+file2_lines <- c("Hello World", "This is modified line 2", "Line 3 here", "New line", "Final line")
+
+cat("File 1 lines:\n")
+for (i in seq_along(file1_lines)) {
+  cat(" ", i, ":", file1_lines[i], "\n")
+}
+
+cat("File 2 lines:\n")
+for (i in seq_along(file2_lines)) {
+  cat(" ", i, ":", file2_lines[i], "\n")
+}
+
+file_lcs <- lcs_array(file1_lines, file2_lines)
+cat("Common lines (unchanged):\n")
+for (i in seq_along(file_lcs$lcs)) {
+  cat(" ", file_lcs$lcs[i], "\n")
+}
+cat("Similarity:", sprintf("%.1f%%", file_lcs$length / max(length(file1_lines), length(file2_lines)) * 100), "\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/dynamic_programming/longest_increasing_subsequence.r b/Desktop/open-source/R/dynamic_programming/longest_increasing_subsequence.r
new file mode 100644
index 00000000..242f94bb
--- /dev/null
+++ b/Desktop/open-source/R/dynamic_programming/longest_increasing_subsequence.r
@@ -0,0 +1,249 @@
+# Longest Increasing Subsequence (Dynamic Programming)
+#
+# The Longest Increasing Subsequence (LIS) problem is a classic dynamic programming problem.
+# Given an array of integers, find the length of the longest subsequence that is strictly
+# increasing. A subsequence is derived from the array by deleting some or no elements
+# without changing the order of the remaining elements.
+#
+# Time Complexity: O(n²) for basic DP, O(n log n) for optimized binary search version
+# Space Complexity: O(n) for both approaches
+#
+# Applications:
+# - Bioinformatics (DNA sequence analysis)
+# - Stock market analysis (longest upward trend)
+# - Scheduling problems
+# - Game theory (optimal play sequences)
+# - Data compression and pattern recognition
+
+# Basic DP solution for Longest Increasing Subsequence
+longest_increasing_subsequence <- function(nums) {
+  #' Find the length of the longest increasing subsequence using Dynamic Programming
+  #' @param nums: Numeric vector of integers
+  #' @return: List containing max length, DP array, and one possible LIS
+  
+  n <- length(nums)
+  
+  # Handle edge cases
+  if (n == 0) {
+    return(list(
+      max_length = 0,
+      dp_array = c(),
+      lis_sequence = c(),
+      dp_table = c()
+    ))
+  }
+  
+  if (n == 1) {
+    return(list(
+      max_length = 1,
+      dp_array = c(1),
+      lis_sequence = nums,
+      dp_table = c(1)
+    ))
+  }
+  
+  # Initialize DP array: dp[i] = length of LIS ending at index i
+  dp <- rep(1, n)
+  
+  # Fill DP array
+  for (i in 2:n) {
+    for (j in 1:(i - 1)) {
+      if (nums[j] < nums[i]) {
+        dp[i] <- max(dp[i], dp[j] + 1)
+      }
+    }
+  }
+  
+  # Find maximum length
+  max_length <- max(dp)
+  
+  # Backtrack to find one possible LIS
+  lis_sequence <- c()
+  current_length <- max_length
+  
+  for (i in n:1) {
+    if (dp[i] == current_length) {
+      lis_sequence <- c(nums[i], lis_sequence)
+      current_length <- current_length - 1
+      if (current_length == 0) break
+    }
+  }
+  
+  return(list(
+    max_length = max_length,
+    dp_array = dp,
+    lis_sequence = lis_sequence,
+    dp_table = dp
+  ))
+}
+
+# Optimized O(n log n) solution using binary search
+longest_increasing_subsequence_optimized <- function(nums) {
+  #' Find the length of the longest increasing subsequence using binary search
+  #' @param nums: Numeric vector of integers
+  #' @return: Length of the longest increasing subsequence
+  
+  n <- length(nums)
+  
+  if (n == 0) return(0)
+  if (n == 1) return(1)
+  
+  # tails[i] stores the smallest tail of all increasing subsequences of length i+1
+  tails <- c()
+  
+  for (num in nums) {
+    # Binary search for the position to replace or extend
+    pos <- binary_search_insert_position(tails, num)
+    
+    if (pos > length(tails)) {
+      # Extend the sequence
+      tails <- c(tails, num)
+    } else {
+      # Replace the element at position pos
+      tails[pos] <- num
+    }
+  }
+  
+  return(length(tails))
+}
+
+# Helper function for binary search
+binary_search_insert_position <- function(arr, target) {
+  #' Binary search to find the position where target should be inserted
+  #' @param arr: Sorted numeric vector
+  #' @param target: Value to insert
+  #' @return: Position (1-indexed) where target should be inserted
+  
+  if (length(arr) == 0) return(1)
+  
+  left <- 1
+  right <- length(arr)
+  
+  while (left <= right) {
+    mid <- left + (right - left) %/% 2
+    
+    if (arr[mid] < target) {
+      left <- mid + 1
+    } else {
+      right <- mid - 1
+    }
+  }
+  
+  return(left)
+}
+
+# Function to find all possible LIS sequences (simplified version)
+find_all_lis <- function(nums) {
+  #' Find all possible longest increasing subsequences
+  #' @param nums: Numeric vector of integers
+  #' @return: List of all possible LIS sequences
+  
+  n <- length(nums)
+  if (n == 0) return(list())
+  
+  # Calculate DP array
+  dp <- rep(1, n)
+  for (i in 2:n) {
+    for (j in 1:(i - 1)) {
+      if (nums[j] < nums[i]) {
+        dp[i] <- max(dp[i], dp[j] + 1)
+      }
+    }
+  }
+  
+  max_length <- max(dp)
+  
+  # For simplicity, return just one LIS (same as the main function)
+  # Finding all possible LIS is complex and not essential for the algorithm demonstration
+  result <- longest_increasing_subsequence(nums)
+  return(list(result$lis_sequence))
+}
+
+# Helper function to print DP table
+print_lis_dp <- function(dp_array, nums) {
+  cat("DP Array for Longest Increasing Subsequence:\n")
+  cat("Input Array:", paste(nums, collapse = ", "), "\n")
+  cat("DP Array   :", paste(dp_array, collapse = ", "), "\n")
+  cat("Max Length :", max(dp_array), "\n\n")
+}
+
+# ===========================
+# Example Usage & Testing
+# ===========================
+cat("=== Longest Increasing Subsequence (Dynamic Programming) ===\n\n")
+
+# Test 1: Basic Example
+nums1 <- c(10, 9, 2, 5, 3, 7, 101, 18)
+cat("Test 1: Basic Example\n")
+cat("Input Array:", paste(nums1, collapse = ", "), "\n\n")
+
+result1 <- longest_increasing_subsequence(nums1)
+print_lis_dp(result1$dp_array, nums1)
+cat("Maximum Length:", result1$max_length, "\n")
+cat("One LIS Sequence:", paste(result1$lis_sequence, collapse = ", "), "\n\n")
+
+# Test 2: Optimized Version
+cat("Test 2: Optimized O(n log n) Version\n")
+max_len_opt <- longest_increasing_subsequence_optimized(nums1)
+cat("Maximum Length (Optimized):", max_len_opt, "\n")
+cat("Verification: Both methods match:", result1$max_length == max_len_opt, "\n\n")
+
+# Test 3: All Possible LIS
+cat("Test 3: All Possible LIS Sequences\n")
+all_lis <- find_all_lis(nums1)
+cat("Total number of LIS sequences:", length(all_lis), "\n")
+for (i in seq_along(all_lis)) {
+  cat("LIS", i, ":", paste(all_lis[[i]], collapse = ", "), "\n")
+}
+cat("\n")
+
+# Test 4: Edge Cases
+cat("Test 4: Edge Cases\n")
+cat("Empty array:", longest_increasing_subsequence(c())$max_length, "\n")
+cat("Single element:", longest_increasing_subsequence(c(5))$max_length, "\n")
+cat("All same elements:", longest_increasing_subsequence(c(3, 3, 3, 3))$max_length, "\n")
+cat("Strictly decreasing:", longest_increasing_subsequence(c(5, 4, 3, 2, 1))$max_length, "\n")
+cat("Strictly increasing:", longest_increasing_subsequence(c(1, 2, 3, 4, 5))$max_length, "\n\n")
+
+# Test 5: Larger Dataset
+cat("Test 5: Larger Dataset (n=20)\n")
+set.seed(42)
+nums_large <- sample(1:100, 20)
+cat("Input Array:", paste(nums_large, collapse = ", "), "\n\n")
+
+result_large <- longest_increasing_subsequence(nums_large)
+cat("Maximum Length:", result_large$max_length, "\n")
+cat("One LIS Sequence:", paste(result_large$lis_sequence, collapse = ", "), "\n\n")
+
+# Test 6: Performance Comparison
+cat("Test 6: Performance Comparison (n=1000)\n")
+n <- 1000
+nums_perf <- sample(1:1000, n)
+
+start_time <- Sys.time()
+res_opt <- longest_increasing_subsequence_optimized(nums_perf)
+opt_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Optimized O(n log n) result:", res_opt, "\n")
+cat("Time taken:", sprintf("%.4f sec", opt_time), "\n")
+
+# Verify correctness with basic DP (smaller sample for time comparison)
+nums_small <- nums_perf[1:100]
+start_time <- Sys.time()
+res_basic <- longest_increasing_subsequence(nums_small)
+basic_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Basic O(n²) result (n=100):", res_basic$max_length, "\n")
+cat("Time taken:", sprintf("%.4f sec", basic_time), "\n")
+
+# Test 7: Real-world Example - Stock Prices
+cat("Test 7: Real-world Example - Stock Price Trend\n")
+stock_prices <- c(100, 102, 98, 105, 103, 107, 110, 108, 112, 115, 113, 118, 120, 117, 125)
+cat("Stock Prices:", paste(stock_prices, collapse = ", "), "\n")
+
+stock_result <- longest_increasing_subsequence(stock_prices)
+cat("Longest upward trend length:", stock_result$max_length, "\n")
+cat("Longest upward trend:", paste(stock_result$lis_sequence, collapse = ", "), "\n")
+cat("Percentage increase:", 
+    sprintf("%.2f%%", (stock_result$lis_sequence[length(stock_result$lis_sequence)] / 
+                      stock_result$lis_sequence[1] - 1) * 100), "\n")
diff --git a/Desktop/open-source/R/dynamic_programming/matrix_chain_multiplication.r b/Desktop/open-source/R/dynamic_programming/matrix_chain_multiplication.r
new file mode 100644
index 00000000..54c5ab0b
--- /dev/null
+++ b/Desktop/open-source/R/dynamic_programming/matrix_chain_multiplication.r
@@ -0,0 +1,481 @@
+# Matrix Chain Multiplication Problem
+#
+# The Matrix Chain Multiplication problem finds the most efficient way to multiply
+# a given sequence of matrices. The goal is to minimize the number of scalar
+# multiplications required by determining the optimal parenthesization.
+#
+# Time Complexity: O(n³) where n = number of matrices
+# Space Complexity: O(n²) for DP table
+#
+# Applications:
+# - Computer graphics and 3D transformations
+# - Scientific computing and numerical analysis
+# - Machine learning and neural networks
+# - Signal processing and image processing
+# - Optimization in linear algebra operations
+
+# Basic DP solution for Matrix Chain Multiplication
+matrix_chain_multiplication <- function(dimensions) {
+  #' Find the minimum number of scalar multiplications needed to multiply matrices
+  #' @param dimensions: Vector of matrix dimensions [d0, d1, d2, ..., dn] where
+  #'                   matrix i has dimensions dimensions[i] x dimensions[i+1]
+  #' @return: List containing minimum cost, DP table, and optimal parenthesization
+  
+  n <- length(dimensions) - 1  # Number of matrices
+  
+  # Handle edge cases
+  if (n <= 0) {
+    return(list(
+      min_cost = 0,
+      dp_table = matrix(0, nrow = 1, ncol = 1),
+      optimal_parentheses = "",
+      split_table = matrix(0, nrow = 1, ncol = 1)
+    ))
+  }
+  
+  if (n == 1) {
+    return(list(
+      min_cost = 0,
+      dp_table = matrix(0, nrow = 1, ncol = 1),
+      optimal_parentheses = "A1",
+      split_table = matrix(0, nrow = 1, ncol = 1)
+    ))
+  }
+  
+  # Create DP table: dp[i, j] = minimum cost to multiply matrices from i to j
+  dp <- matrix(0, nrow = n, ncol = n)
+  split_table <- matrix(0, nrow = n, ncol = n)  # To store optimal split points
+  
+  # Fill DP table using bottom-up approach
+  for (length in 2:n) {  # length of chain
+    for (i in 1:(n - length + 1)) {
+      j <- i + length - 1
+      dp[i, j] <- Inf
+      
+      # Try all possible split points
+      for (k in i:(j - 1)) {
+        # Cost = cost of left part + cost of right part + cost of multiplying them
+        cost <- dp[i, k] + dp[k + 1, j] + dimensions[i] * dimensions[k + 1] * dimensions[j + 1]
+        
+        if (cost < dp[i, j]) {
+          dp[i, j] <- cost
+          split_table[i, j] <- k  # Store optimal split point
+        }
+      }
+    }
+  }
+  
+  # Generate optimal parenthesization
+  optimal_parentheses <- generate_parentheses(split_table, 1, n)
+  
+  return(list(
+    min_cost = dp[1, n],
+    dp_table = dp,
+    optimal_parentheses = optimal_parentheses,
+    split_table = split_table
+  ))
+}
+
+# Recursive function to generate optimal parenthesization
+generate_parentheses <- function(split_table, i, j) {
+  if (i == j) {
+    return(paste0("A", i))
+  } else {
+    k <- split_table[i, j]
+    left <- generate_parentheses(split_table, i, k)
+    right <- generate_parentheses(split_table, k + 1, j)
+    return(paste0("(", left, " × ", right, ")"))
+  }
+}
+
+# Space-optimized version using only upper triangular matrix
+matrix_chain_optimized <- function(dimensions) {
+  #' Space optimized matrix chain multiplication
+  #' @param dimensions: Vector of matrix dimensions
+  #' @return: Minimum cost only
+  
+  n <- length(dimensions) - 1
+  
+  if (n <= 1) return(0)
+  
+  # Use only upper triangular part of DP table
+  dp <- matrix(0, nrow = n, ncol = n)
+  
+  for (length in 2:n) {
+    for (i in 1:(n - length + 1)) {
+      j <- i + length - 1
+      dp[i, j] <- Inf
+      
+      for (k in i:(j - 1)) {
+        cost <- dp[i, k] + dp[k + 1, j] + dimensions[i] * dimensions[k + 1] * dimensions[j + 1]
+        dp[i, j] <- min(dp[i, j], cost)
+      }
+    }
+  }
+  
+  return(dp[1, n])
+}
+
+# Function to calculate actual multiplication cost for given parenthesization
+calculate_multiplication_cost <- function(dimensions, parentheses) {
+  #' Calculate the actual cost of multiplying matrices with given parenthesization
+  #' @param dimensions: Vector of matrix dimensions
+  #' @param parentheses: String representation of parenthesization
+  #' @return: Total cost of multiplication
+  
+  # Helper to parse the parenthesization string into a tree
+  parse_parentheses <- function(s) {
+    s <- gsub(" ", "", s) # Remove spaces
+    # If it's a single matrix, e.g. "A1"
+    if (grepl("^A[0-9]+$", s)) {
+      idx <- as.integer(sub("A", "", s))
+      return(list(type = "leaf", idx = idx))
+    }
+    # Otherwise, find the main split
+    # Remove outer parentheses if present
+    if (substr(s, 1, 1) == "(" && substr(s, nchar(s), nchar(s)) == ")") {
+      s <- substr(s, 2, nchar(s) - 1)
+    }
+    # Find the split point for " × " at the top level
+    depth <- 0
+    for (i in seq_len(nchar(s))) {
+      ch <- substr(s, i, i)
+      if (ch == "(") depth <- depth + 1
+      if (ch == ")") depth <- depth - 1
+      # Look for "×" at depth 0
+      if (depth == 0 && i < nchar(s) && substr(s, i, i+1) == "×") {
+        left <- substr(s, 1, i-2)
+        right <- substr(s, i+2, nchar(s))
+        return(list(
+          type = "node",
+          left = parse_parentheses(left),
+          right = parse_parentheses(right)
+        ))
+      }
+    }
+    stop("Invalid parenthesization string")
+  }
+  
+  # Helper to compute cost recursively
+  compute_cost <- function(node) {
+    if (node$type == "leaf") {
+      # Return dimensions for this matrix
+      idx <- node$idx
+      return(list(rows = dimensions[idx], cols = dimensions[idx+1], cost = 0))
+    } else {
+      left <- compute_cost(node$left)
+      right <- compute_cost(node$right)
+      # Multiply left and right matrices: left$rows x left$cols and right$rows x right$cols
+      if (left$cols != right$rows) stop("Incompatible matrix dimensions")
+      cost <- left$cost + right$cost + left$rows * left$cols * right$cols
+      return(list(rows = left$rows, cols = right$cols, cost = cost))
+    }
+  }
+  
+  tree <- parse_parentheses(parentheses)
+  result <- compute_cost(tree)
+  return(result$cost)
+}
+
+# Function to find all possible optimal parenthesizations
+find_all_optimal_parentheses <- function(dimensions) {
+  #' Find all possible optimal parenthesizations
+  #' @param dimensions: Vector of matrix dimensions
+  #' @return: List of all optimal parenthesizations
+  
+  n <- length(dimensions) - 1
+  if (n <= 1) return(list(paste0("A", 1:n)))
+  
+  result <- matrix_chain_multiplication(dimensions)
+  min_cost <- result$min_cost
+  
+  all_parentheses <- list()
+  
+  # Generate all possible parenthesizations and filter optimal ones
+  generate_all_parentheses <- function(i, j) {
+    if (i == j) {
+      return(list(paste0("A", i)))
+    }
+    
+    all_ways <- list()
+    for (k in i:(j - 1)) {
+      left_ways <- generate_all_parentheses(i, k)
+      right_ways <- generate_all_parentheses(k + 1, j)
+      
+      for (left in left_ways) {
+        for (right in right_ways) {
+          all_ways <- c(all_ways, list(paste0("(", left, " × ", right, ")")))
+        }
+      }
+    }
+    return(all_ways)
+  }
+  
+  all_ways <- generate_all_parentheses(1, n)
+  
+  # Helper function to compute cost of a parenthesization
+  compute_cost <- function(paren, dims) {
+    # Recursively compute cost based on parenthesization string
+    # paren: string like "(A1 × (A2 × A3))"
+    # dims: vector of dimensions
+    # Returns: cost (integer)
+    
+    # Parse the parenthesization string into a tree structure
+    # Helper: extract indices of matrices in a parenthesization
+    extract_indices <- function(s) {
+      # Returns vector of matrix indices in the string
+      matches <- gregexpr("A[0-9]+", s)
+      as.integer(unlist(regmatches(s, matches)))
+    }
+    
+    # Helper: recursively compute cost
+    recursive_cost <- function(s) {
+      # If s is a single matrix, cost is 0
+      indices <- extract_indices(s)
+      if (length(indices) == 1) {
+        return(list(cost = 0, left = indices[1], right = indices[1]))
+      }
+      
+      # Find the main split: the outermost multiplication
+      # Remove outer parentheses
+      s_trim <- substring(s, 2, nchar(s) - 1)
+      
+      # Find the split point (the × not inside parentheses)
+      depth <- 0
+      split_pos <- NULL
+      for (i in seq_len(nchar(s_trim))) {
+        ch <- substr(s_trim, i, i)
+        if (ch == "(") depth <- depth + 1
+        if (ch == ")") depth <- depth - 1
+        if (ch == "×" && depth == 0) {
+          split_pos <- i
+          break
+        }
+      }
+      if (is.null(split_pos)) {
+        # Should not happen
+        stop("Invalid parenthesization string: ", s)
+      }
+      
+      left_str <- trimws(substring(s_trim, 1, split_pos - 1))
+      right_str <- trimws(substring(s_trim, split_pos + 1))
+      
+      left <- recursive_cost(left_str)
+      right <- recursive_cost(right_str)
+      
+      # The multiplication cost: dims[left$left] x dims[left$right+1] x dims[right$right+1]
+      cost_here <- dims[left$left] * dims[left$right + 1] * dims[right$right + 1]
+      total_cost <- left$cost + right$cost + cost_here
+      return(list(cost = total_cost, left = left$left, right = right$right))
+    }
+    
+    recursive_cost(paren)$cost
+  }
+  
+  # Compute cost for each parenthesization
+  costs <- sapply(all_ways, compute_cost, dims = dimensions)
+  
+  # Find all parenthesizations with minimum cost
+  optimal_ways <- all_ways[costs == min_cost]
+  
+  return(optimal_ways)
+
+# Helper function to print DP table
+print_matrix_chain_dp <- function(dp_table, split_table, dimensions) {
+  n <- nrow(dp_table)
+  
+  cat("DP Table for Matrix Chain Multiplication:\n")
+  cat("Matrix dimensions:", paste(dimensions, collapse = " × "), "\n")
+  cat("Number of matrices:", n, "\n\n")
+  
+  # Print matrix indices
+  cat("     ")
+  for (j in 1:n) {
+    cat(sprintf("%4d", j))
+  }
+  cat("\n")
+  cat(paste(rep("-", 5 + 4 * n), collapse = ""), "\n")
+  
+  for (i in 1:n) {
+    cat(sprintf("%2d | ", i))
+    for (j in 1:n) {
+      if (i <= j) {
+        cat(sprintf("%4d", dp_table[i, j]))
+      } else {
+        cat("    ")
+      }
+    }
+    cat("\n")
+  }
+  cat("\n")
+  
+  # Print split table
+  cat("Split Table (optimal split points):\n")
+  cat("     ")
+  for (j in 1:n) {
+    cat(sprintf("%4d", j))
+  }
+  cat("\n")
+  cat(paste(rep("-", 5 + 4 * n), collapse = ""), "\n")
+  
+  for (i in 1:n) {
+    cat(sprintf("%2d | ", i))
+    for (j in 1:n) {
+      if (i < j) {
+        cat(sprintf("%4d", split_table[i, j]))
+      } else {
+        cat("    ")
+      }
+    }
+    cat("\n")
+  }
+  cat("\n")
+}
+
+# Helper function to show matrix multiplication steps
+show_multiplication_steps <- function(dimensions, parentheses) {
+  n <- length(dimensions) - 1
+  
+  cat("Matrix Chain Multiplication Steps:\n")
+  cat("Matrix dimensions:", paste(dimensions, collapse = " × "), "\n")
+  cat("Optimal parenthesization:", parentheses, "\n\n")
+  
+  for (i in 1:n) {
+    cat(sprintf("A%d: %d × %d matrix\n", i, dimensions[i], dimensions[i + 1]))
+  }
+  cat("\n")
+  
+  # Show cost calculation
+  result <- matrix_chain_multiplication(dimensions)
+  cat("Minimum scalar multiplications:", result$min_cost, "\n")
+  
+  # Show cost breakdown for small examples
+  if (n <= 4) {
+    cat("\nCost breakdown:\n")
+    for (i in 1:n) {
+      for (j in i:n) {
+        if (i < j) {
+          cat(sprintf("Cost[A%d..A%d] = %d\n", i, j, result$dp_table[i, j]))
+        }
+      }
+    }
+  }
+  cat("\n")
+}
+
+# ===========================
+# Example Usage & Testing
+# ===========================
+cat("=== Matrix Chain Multiplication Problem (Dynamic Programming) ===\n\n")
+
+# Test 1: Basic Example
+cat("Test 1: Basic Example\n")
+dims1 <- c(1, 5, 4, 6, 2)  # 4 matrices: 1×5, 5×4, 4×6, 6×2
+cat("Matrix dimensions:", paste(dims1, collapse = " × "), "\n")
+
+result1 <- matrix_chain_multiplication(dims1)
+print_matrix_chain_dp(result1$dp_table, result1$split_table, dims1)
+cat("Minimum cost:", result1$min_cost, "\n")
+cat("Optimal parenthesization:", result1$optimal_parentheses, "\n")
+show_multiplication_steps(dims1, result1$optimal_parentheses)
+
+# Test 2: Optimized Version
+cat("Test 2: Space Optimized Version\n")
+min_cost_opt <- matrix_chain_optimized(dims1)
+cat("Minimum cost (Optimized):", min_cost_opt, "\n")
+cat("Verification: Both methods match:", result1$min_cost == min_cost_opt, "\n\n")
+
+# Test 3: Edge Cases
+cat("Test 3: Edge Cases\n")
+cat("Single matrix:", matrix_chain_multiplication(c(3, 4))$min_cost, "\n")
+cat("Two matrices:", matrix_chain_multiplication(c(3, 4, 5))$min_cost, "\n")
+cat("Empty dimensions:", matrix_chain_multiplication(c())$min_cost, "\n\n")
+
+# Test 4: Larger Example
+cat("Test 4: Larger Example (6 matrices)\n")
+dims_large <- c(30, 35, 15, 5, 10, 20, 25)
+cat("Matrix dimensions:", paste(dims_large, collapse = " × "), "\n")
+
+result_large <- matrix_chain_multiplication(dims_large)
+cat("Minimum cost:", result_large$min_cost, "\n")
+cat("Optimal parenthesization:", result_large$optimal_parentheses, "\n\n")
+
+# Test 5: Performance Comparison
+cat("Test 5: Performance Comparison (8 matrices)\n")
+set.seed(42)
+dims_perf <- sample(10:50, 9)  # 8 matrices
+cat("Matrix dimensions:", paste(dims_perf, collapse = " × "), "\n")
+
+start_time <- Sys.time()
+result_std <- matrix_chain_multiplication(dims_perf)
+std_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+start_time <- Sys.time()
+result_opt <- matrix_chain_optimized(dims_perf)
+opt_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Standard DP result:", result_std$min_cost, "\n")
+cat("Optimized DP result:", result_opt, "\n")
+cat("Standard DP time:", sprintf("%.4f sec", std_time), "\n")
+cat("Optimized DP time:", sprintf("%.4f sec", opt_time), "\n")
+cat("Results match:", result_std$min_cost == result_opt, "\n\n")
+
+# Test 6: Multiple Optimal Solutions
+cat("Test 6: Multiple Optimal Solutions\n")
+dims_multiple <- c(2, 3, 2, 3, 2)  # 4 matrices with multiple optimal solutions
+cat("Matrix dimensions:", paste(dims_multiple, collapse = " × "), "\n")
+
+result_multiple <- matrix_chain_multiplication(dims_multiple)
+cat("Minimum cost:", result_multiple$min_cost, "\n")
+cat("One optimal parenthesization:", result_multiple$optimal_parentheses, "\n")
+
+# Find all optimal parenthesizations
+all_optimal <- find_all_optimal_parentheses(dims_multiple)
+cat("Total optimal parenthesizations found:", length(all_optimal), "\n")
+for (i in seq_along(all_optimal)) {
+  cat("Option", i, ":", all_optimal[[i]], "\n")
+}
+cat("\n")
+
+# Test 7: Real-world Example - Computer Graphics
+cat("Test 7: Real-world Example - 3D Graphics Pipeline\n")
+# Typical 3D transformation pipeline: Model → View → Projection → Screen
+# Each transformation is a matrix multiplication
+graphics_dims <- c(4, 4, 4, 4, 4)  # 4×4 transformation matrices
+cat("3D Graphics Pipeline (4×4 transformation matrices):\n")
+cat("Matrix dimensions:", paste(graphics_dims, collapse = " × "), "\n")
+
+graphics_result <- matrix_chain_multiplication(graphics_dims)
+cat("Minimum cost:", graphics_result$min_cost, "\n")
+cat("Optimal order:", graphics_result$optimal_parentheses, "\n")
+
+# Show the transformation pipeline
+cat("\nTransformation Pipeline:\n")
+cat("1. Model Matrix (4×4) - Object to World coordinates\n")
+cat("2. View Matrix (4×4) - World to Camera coordinates\n")
+cat("3. Projection Matrix (4×4) - Camera to Clip coordinates\n")
+cat("4. Viewport Matrix (4×4) - Clip to Screen coordinates\n")
+cat("Total operations saved with optimal order:", graphics_result$min_cost, "scalar multiplications\n\n")
+
+# Test 8: Cost Analysis
+cat("Test 8: Cost Analysis\n")
+dims_analysis <- c(10, 20, 30, 40, 50)
+cat("Matrix dimensions:", paste(dims_analysis, collapse = " × "), "\n")
+
+analysis_result <- matrix_chain_multiplication(dims_analysis)
+cat("Minimum cost:", analysis_result$min_cost, "\n")
+
+# Compare with naive left-to-right multiplication
+naive_cost <- 0
+# Simulate left-to-right multiplication, updating result matrix dimensions
+rows <- dims_analysis[1]
+cols <- dims_analysis[2]
+for (i in 2:(length(dims_analysis) - 1)) {
+  next_cols <- dims_analysis[i + 1]
+  naive_cost <- naive_cost + rows * cols * next_cols
+  cols <- next_cols
+}
+
+cat("Naive left-to-right cost:", naive_cost, "\n")
+cat("Savings with optimal order:", naive_cost - analysis_result$min_cost, "\n")
+cat("Percentage improvement:", sprintf("%.1f%%", (naive_cost - analysis_result$min_cost) / naive_cost * 100), "\n")
diff --git a/Desktop/open-source/R/dynamic_programming/minimum_path_sum.r b/Desktop/open-source/R/dynamic_programming/minimum_path_sum.r
new file mode 100644
index 00000000..15279100
--- /dev/null
+++ b/Desktop/open-source/R/dynamic_programming/minimum_path_sum.r
@@ -0,0 +1,373 @@
+# Minimum Path Sum Problem
+#
+# The Minimum Path Sum problem finds the minimum sum path from the top-left corner
+# to the bottom-right corner of a grid, moving only right or down at each step.
+# This is a classic dynamic programming problem that appears in various forms.
+#
+# Time Complexity: O(m * n) where m = number of rows, n = number of columns
+# Space Complexity: O(m * n) for DP table, O(min(m, n)) for optimized version
+#
+# Applications:
+# - Grid-based pathfinding algorithms
+# - Resource optimization in 2D grids
+# - Game development (pathfinding with costs)
+# - Network routing optimization
+# - Cost minimization in transportation
+
+# Basic DP solution for Minimum Path Sum
+minimum_path_sum <- function(grid) {
+  #' Find the minimum path sum from top-left to bottom-right corner
+  #' @param grid: 2D matrix of non-negative integers
+  #' @return: List containing minimum sum, path, and DP table
+  
+  m <- nrow(grid)
+  n <- ncol(grid)
+  
+  # Handle edge case
+  if (m == 0 || n == 0) {
+    return(list(
+      min_sum = 0,
+      path = c(),
+      dp_table = matrix(0, nrow = 1, ncol = 1)
+    ))
+  }
+  
+  # Create DP table: dp[i, j] = minimum sum to reach position (i, j)
+  dp <- matrix(0, nrow = m, ncol = n)
+  
+  # Initialize first row and column
+  dp[1, 1] <- grid[1, 1]
+  
+  # Fill first row (can only move right)
+  if (n > 1) {
+    for (j in 2:n) {
+      dp[1, j] <- dp[1, j - 1] + grid[1, j]
+    }
+  }
+  
+  # Fill first column (can only move down)
+  if (m > 1) {
+    for (i in 2:m) {
+      dp[i, 1] <- dp[i - 1, 1] + grid[i, 1]
+    }
+  }
+  
+  # Fill remaining cells
+  if (m > 1 && n > 1) {
+    for (i in 2:m) {
+      for (j in 2:n) {
+        dp[i, j] <- min(dp[i - 1, j], dp[i, j - 1]) + grid[i, j]
+      }
+    }
+  }
+  
+  # Backtrack to find the path
+  path <- list()
+  i <- m
+  j <- n
+  
+  while (i > 1 || j > 1) {
+    path <- c(list(c(i, j)), path)
+    
+    if (i == 1) {
+      # Can only move left
+      j <- j - 1
+    } else if (j == 1) {
+      # Can only move up
+      i <- i - 1
+    } else {
+      # Choose direction with minimum sum
+      if (dp[i - 1, j] < dp[i, j - 1]) {
+        i <- i - 1
+      } else {
+        j <- j - 1
+      }
+    }
+  }
+  path <- c(list(c(1, 1)), path)
+  
+  return(list(
+    min_sum = dp[m, n],
+    path = path,
+    dp_table = dp
+  ))
+}
+
+# Space-optimized version using only 1D array
+minimum_path_sum_optimized <- function(grid) {
+  #' Space optimized minimum path sum using 1D array
+  #' @param grid: 2D matrix of non-negative integers
+  #' @return: Minimum path sum
+  
+  m <- nrow(grid)
+  n <- ncol(grid)
+  
+  if (m == 0 || n == 0) return(0)
+  
+  # Use the smaller dimension for space optimization
+  if (m <= n) {
+    # Process row by row
+    dp <- rep(0, m)
+    dp[1] <- grid[1, 1]
+    
+    # Initialize first row
+    if (m > 1) {
+      for (i in 2:m) {
+        dp[i] <- dp[i - 1] + grid[i, 1]
+      }
+    }
+    
+    # Process remaining columns
+    for (j in 2:n) {
+      dp[1] <- dp[1] + grid[1, j]
+      for (i in 2:m) {
+        dp[i] <- min(dp[i - 1], dp[i]) + grid[i, j]
+      }
+    }
+  } else {
+    # Process column by column
+    dp <- rep(0, n)
+    dp[1] <- grid[1, 1]
+    
+    # Initialize first column
+    for (j in 2:n) {
+      dp[j] <- dp[j - 1] + grid[1, j]
+    }
+    
+    # Process remaining rows
+    for (i in 2:m) {
+      dp[1] <- dp[1] + grid[i, 1]
+      for (j in 2:n) {
+        dp[j] <- min(dp[j - 1], dp[j]) + grid[i, j]
+      }
+    }
+  }
+  
+  return(dp[length(dp)])
+}
+
+# Function to find all possible minimum paths
+find_all_minimum_paths <- function(grid) {
+  #' Find all possible paths that achieve the minimum sum
+  #' @param grid: 2D matrix of non-negative integers
+  #' @return: List of all minimum cost paths
+  
+  m <- nrow(grid)
+  n <- ncol(grid)
+  
+  if (m == 0 || n == 0) return(list())
+  
+  # First compute the minimum sum
+  result <- minimum_path_sum(grid)
+  min_sum <- result$min_sum
+  
+  all_paths <- list()
+  
+  # Use recursive backtracking to find all paths with minimum sum
+  find_paths_recursive <- function(current_path, current_sum, i, j) {
+    current_sum <- current_sum + grid[i, j]
+    
+    # If we've reached the bottom-right corner
+    if (i == m && j == n) {
+      if (current_sum == min_sum) {
+        all_paths <<- c(all_paths, list(c(current_path, list(c(i, j)))))
+      }
+      return
+    }
+    
+    # If current sum exceeds minimum, prune
+    if (current_sum > min_sum) {
+      return
+    }
+    
+    # Move right
+    if (j < n) {
+      find_paths_recursive(c(current_path, list(c(i, j))), current_sum, i, j + 1)
+    }
+    
+    # Move down
+    if (i < m) {
+      find_paths_recursive(c(current_path, list(c(i, j))), current_sum, i + 1, j)
+    }
+  }
+  
+  find_paths_recursive(list(), 0, 1, 1)
+  return(all_paths)
+}
+
+# Helper function to print DP table
+print_minimum_path_sum_dp <- function(dp_table, grid) {
+  m <- nrow(grid)
+  n <- ncol(grid)
+  
+  cat("DP Table for Minimum Path Sum:\n")
+  cat("Grid:\n")
+  for (i in 1:m) {
+    cat("  ")
+    for (j in 1:n) {
+      cat(sprintf("%3d ", grid[i, j]))
+    }
+    cat("\n")
+  }
+  cat("\nDP Table:\n")
+  for (i in 1:m) {
+    cat("  ")
+    for (j in 1:n) {
+      cat(sprintf("%3d ", dp_table[i, j]))
+    }
+    cat("\n")
+  }
+  cat("\n")
+}
+
+# Helper function to visualize path on grid
+visualize_path <- function(grid, path) {
+  m <- nrow(grid)
+  n <- ncol(grid)
+  
+  cat("Path Visualization:\n")
+  cat("Grid with path marked (*):\n")
+  
+  # Create a matrix to mark the path
+  path_matrix <- matrix(" ", nrow = m, ncol = n)
+  
+  for (pos in path) {
+    path_matrix[pos[1], pos[2]] <- "*"
+  }
+  
+  for (i in 1:m) {
+    cat("  ")
+    for (j in 1:n) {
+      if (path_matrix[i, j] == "*") {
+        cat(sprintf("%3s ", "*"))
+      } else {
+        cat(sprintf("%3d ", grid[i, j]))
+      }
+    }
+    cat("\n")
+  }
+  cat("\n")
+}
+
+# ===========================
+# Example Usage & Testing
+# ===========================
+cat("=== Minimum Path Sum Problem (Dynamic Programming) ===\n\n")
+
+# Test 1: Basic Example
+cat("Test 1: Basic Example\n")
+grid1 <- matrix(c(1, 3, 1, 1, 5, 1, 4, 2, 1), nrow = 3, ncol = 3, byrow = TRUE)
+cat("Grid:\n")
+print(grid1)
+
+result1 <- minimum_path_sum(grid1)
+print_minimum_path_sum_dp(result1$dp_table, grid1)
+cat("Minimum Path Sum:", result1$min_sum, "\n")
+cat("Path (row, col):", paste(sapply(result1$path, function(x) paste("(", x[1], ",", x[2], ")", sep="")), collapse = " -> "), "\n")
+visualize_path(grid1, result1$path)
+cat("\n")
+
+# Test 2: Optimized Version
+cat("Test 2: Space Optimized Version\n")
+min_sum_opt <- minimum_path_sum_optimized(grid1)
+cat("Minimum Path Sum (Optimized):", min_sum_opt, "\n")
+cat("Verification: Both methods match:", result1$min_sum == min_sum_opt, "\n\n")
+
+# Test 3: Single Row/Column Cases
+cat("Test 3: Edge Cases\n")
+cat("Single row grid:\n")
+grid_row <- matrix(c(1, 2, 3, 4, 5), nrow = 1)
+print(grid_row)
+result_row <- minimum_path_sum(grid_row)
+cat("Minimum sum:", result_row$min_sum, "\n\n")
+
+cat("Single column grid:\n")
+grid_col <- matrix(c(1, 2, 3, 4, 5), ncol = 1)
+print(grid_col)
+result_col <- minimum_path_sum(grid_col)
+cat("Minimum sum:", result_col$min_sum, "\n\n")
+
+# Test 4: Larger Grid
+cat("Test 4: Larger Grid (4x5)\n")
+# Set random seed for reproducibility in tests. The value 42 is chosen arbitrarily.
+SEED <- 42
+set.seed(SEED)
+grid_large <- matrix(sample(1:9, 20, replace = TRUE), nrow = 4, ncol = 5)
+cat("Grid:\n")
+print(grid_large)
+
+result_large <- minimum_path_sum(grid_large)
+cat("Minimum Path Sum:", result_large$min_sum, "\n")
+cat("Path length:", length(result_large$path), "steps\n")
+visualize_path(grid_large, result_large$path)
+cat("\n")
+
+# Test 5: Performance Comparison
+cat("Test 5: Performance Comparison (6x8 grid)\n")
+grid_perf <- matrix(sample(1:20, 48, replace = TRUE), nrow = 6, ncol = 8)
+
+library(microbenchmark)
+
+mbm <- microbenchmark(
+  std = minimum_path_sum(grid_perf),
+  opt = minimum_path_sum_optimized(grid_perf),
+  times = 100L
+)
+
+result_std <- minimum_path_sum(grid_perf)
+result_opt <- minimum_path_sum_optimized(grid_perf)
+
+cat("Standard DP result:", result_std$min_sum, "\n")
+cat("Optimized DP result:", result_opt, "\n")
+cat("Standard DP median time:", sprintf("%.6f sec", median(mbm$time[mbm$expr == "std"])/1e9), "\n")
+cat("Optimized DP median time:", sprintf("%.6f sec", median(mbm$time[mbm$expr == "opt"])/1e9), "\n")
+cat("Results match:", result_std$min_sum == result_opt, "\n\n")
+
+# Test 6: Multiple Minimum Paths
+cat("Test 6: Multiple Minimum Paths\n")
+grid_multiple <- matrix(c(1, 2, 1, 1, 1, 1, 1, 1, 1), nrow = 3, ncol = 3, byrow = TRUE)
+cat("Grid:\n")
+print(grid_multiple)
+
+result_multiple <- minimum_path_sum(grid_multiple)
+cat("Minimum Path Sum:", result_multiple$min_sum, "\n")
+cat("One possible path:", paste(sapply(result_multiple$path, function(x) paste("(", x[1], ",", x[2], ")", sep="")), collapse = " -> "), "\n")
+
+# Find all minimum paths
+all_paths <- find_all_minimum_paths(grid_multiple)
+cat("Total number of minimum paths:", length(all_paths), "\n")
+for (i in seq_along(all_paths)) {
+  path_str <- paste(sapply(all_paths[[i]], function(x) paste("(", x[1], ",", x[2], ")", sep="")), collapse = " -> ")
+  path_sum <- sum(sapply(all_paths[[i]], function(x) grid_multiple[x[1], x[2]]))
+  cat("Path", i, ":", path_str, "(sum =", path_sum, ")\n")
+}
+cat("\n")
+
+# Test 7: Real-world Example - Cost Optimization
+cat("Test 7: Real-world Example - Transportation Cost Optimization\n")
+# Grid representing transportation costs between cities
+transport_grid <- matrix(c(
+  2, 3, 4, 2, 1,
+  1, 2, 1, 3, 2,
+  3, 1, 2, 1, 4,
+  2, 4, 1, 2, 3
+), nrow = 4, ncol = 5, byrow = TRUE)
+
+cat("Transportation Cost Grid:\n")
+print(transport_grid)
+
+transport_result <- minimum_path_sum(transport_grid)
+cat("Minimum transportation cost:", transport_result$min_sum, "\n")
+cat("Optimal route:", paste(sapply(transport_result$path, function(x) paste("City(", x[1], ",", x[2], ")", sep="")), collapse = " -> "), "\n")
+visualize_path(transport_grid, transport_result$path)
+
+# Calculate cost breakdown
+cat("Cost breakdown:\n")
+total_cost <- 0
+for (i in seq_along(transport_result$path)) {
+  pos <- transport_result$path[[i]]
+  cost <- transport_grid[pos[1], pos[2]]
+  total_cost <- total_cost + cost
+  cat("  Step", i, ": City(", pos[1], ",", pos[2], ") =", cost, "\n")
+}
+cat("Total cost verification:", total_cost, "\n")
diff --git a/Desktop/open-source/R/dynamic_programming/subset_sum.r b/Desktop/open-source/R/dynamic_programming/subset_sum.r
new file mode 100644
index 00000000..8d4cf6bb
--- /dev/null
+++ b/Desktop/open-source/R/dynamic_programming/subset_sum.r
@@ -0,0 +1,288 @@
+# Subset Sum Problem
+#
+# The Subset Sum problem determines whether there exists a subset of a given set
+# of positive integers that sums to a target value. This is a classic NP-complete
+# problem solved using dynamic programming.
+#
+# Time Complexity: O(n * sum) where n = number of elements, sum = target sum
+# Space Complexity: O(n * sum) for DP table, O(sum) for optimized version
+#
+# Applications:
+# - Partition problems in computer science
+# - Knapsack problem variations
+# - Resource allocation and optimization
+# - Cryptography and number theory
+# - Game theory and decision making
+
+# Basic DP solution for Subset Sum Problem
+subset_sum <- function(arr, target) {
+  #' Check if there exists a subset that sums to the target value
+  #' @param arr: Numeric vector of positive integers
+  #' @param target: Target sum value
+  #' @return: Boolean indicating if subset exists, along with DP table
+  
+  n <- length(arr)
+  
+  # Handle edge cases
+  if (n == 0) {
+    return(list(
+      exists = (target == 0),
+      dp_table = matrix(FALSE, nrow = 1, ncol = 1),
+      subset = c()
+    ))
+  }
+  
+  if (target == 0) {
+    return(list(
+      exists = TRUE,
+      dp_table = matrix(TRUE, nrow = n + 1, ncol = 1),
+      subset = c()
+    ))
+  }
+  
+  # Create DP table: dp[i, j] = TRUE if sum j can be achieved using first i elements
+  dp <- matrix(FALSE, nrow = n + 1, ncol = target + 1)
+  
+  # Base case: sum 0 can always be achieved with empty subset
+  for (i in 1:(n + 1)) {
+    dp[i, 1] <- TRUE
+  }
+  
+  # Fill DP table
+  for (i in 2:(n + 1)) {
+    for (j in 1:(target + 1)) {
+      current_sum <- j - 1  # Convert to 0-based indexing
+      
+      # Don't include current element
+      dp[i, j] <- dp[i - 1, j]
+      
+      # Include current element (if it doesn't exceed current sum)
+      if (arr[i - 1] <= current_sum) {
+        dp[i, j] <- dp[i, j] || dp[i - 1, j - arr[i - 1]]
+      }
+    }
+  }
+  
+  # Backtrack to find one possible subset
+  subset <- c()
+  if (dp[n + 1, target + 1]) {
+    i <- n + 1
+    j <- target + 1
+    
+    while (i > 1 && j > 1) {
+      # If current sum was achieved without including arr[i-1]
+      if (dp[i - 1, j]) {
+        i <- i - 1
+      } else {
+        # Current element was included
+        subset <- c(arr[i - 1], subset)
+        j <- j - arr[i - 1]
+        i <- i - 1
+      }
+    }
+  }
+  
+  return(list(
+    exists = dp[n + 1, target + 1],
+    dp_table = dp,
+    subset = subset
+  ))
+}
+
+# Space-optimized version using only 1D array
+subset_sum_optimized <- function(arr, target) {
+  #' Space optimized subset sum using 1D array
+  #' @param arr: Numeric vector of positive integers
+  #' @param target: Target sum value
+  #' @return: Boolean indicating if subset exists
+  
+  n <- length(arr)
+  
+  if (n == 0) return(target == 0)
+  if (target == 0) return(TRUE)
+  
+  dp <- rep(FALSE, target + 1)
+  dp[1] <- TRUE  # sum 0 is always possible
+  
+  for (i in 1:n) {
+    # Traverse from right to left to avoid overwriting needed values
+    for (j in target:1) {
+      if (arr[i] <= j) {
+        dp[j + 1] <- dp[j + 1] || dp[j - arr[i] + 1]
+      }
+    }
+  }
+  
+  return(dp[target + 1])
+}
+
+# Function to find all subsets that sum to target
+find_all_subsets <- function(arr, target) {
+  #' Find all subsets that sum to the target value
+  #' @param arr: Numeric vector of positive integers
+  #' @param target: Target sum value
+  #' @return: List of subsets (each subset is a numeric vector) that sum to target
+  
+  n <- length(arr)
+  results <- list()
+  
+  # Helper recursive function
+  find_subsets_rec <- function(idx, current_subset, current_sum) {
+    if (current_sum == target) {
+      results <<- c(results, list(current_subset))
+      return()
+    }
+    if (idx > n || current_sum > target) {
+      return()
+    }
+    # Include arr[idx]
+    find_subsets_rec(idx + 1, c(current_subset, arr[idx]), current_sum + arr[idx])
+    # Exclude arr[idx]
+    find_subsets_rec(idx + 1, current_subset, current_sum)
+  }
+  
+  find_subsets_rec(1, c(), 0)
+  return(results)
+}
+
+# Helper function to print DP table
+print_subset_sum_dp <- function(dp_table, arr, target) {
+  cat("DP Table for Subset Sum Problem:\n")
+  cat("Array:", paste(arr, collapse = ", "), "\n")
+  cat("Target Sum:", target, "\n\n")
+  
+  # Print column headers (sums)
+  cat("        ")
+  cat(paste(sprintf("%4d", 0:target), collapse = " "))
+  cat("\n")
+  cat(paste(rep("-", 8 + 5 * (target + 1)), collapse = ""), "\n")
+  
+  for (i in 1:nrow(dp_table)) {
+    if (i == 1) {
+      cat("Empty  | ")
+    } else {
+      cat(sprintf("Elem%2d| ", i - 1))
+    }
+    
+    for (j in 1:ncol(dp_table)) {
+      cat(sprintf("%4s", ifelse(dp_table[i, j], " T", " F")))
+    }
+    cat("\n")
+  }
+  cat("\n")
+}
+
+# ===========================
+# Example Usage & Testing
+# ===========================
+cat("=== Subset Sum Problem (Dynamic Programming) ===\n\n")
+
+# Test 1: Basic Example
+arr1 <- c(3, 34, 4, 12, 5, 2)
+target1 <- 9
+cat("Test 1: Basic Example\n")
+cat("Array:", paste(arr1, collapse = ", "), "\n")
+cat("Target Sum:", target1, "\n\n")
+
+result1 <- subset_sum(arr1, target1)
+print_subset_sum_dp(result1$dp_table, arr1, target1)
+cat("Subset exists:", result1$exists, "\n")
+if (result1$exists) {
+  cat("One possible subset:", paste(result1$subset, collapse = ", "), "\n")
+  cat("Sum verification:", sum(result1$subset), "\n")
+}
+cat("\n")
+
+# Test 2: Optimized Version
+cat("Test 2: Space Optimized Version\n")
+exists_opt <- subset_sum_optimized(arr1, target1)
+cat("Subset exists (Optimized):", exists_opt, "\n")
+cat("Verification: Both methods match:", result1$exists == exists_opt, "\n\n")
+
+# Test 3: No Solution Case
+cat("Test 3: No Solution Case\n")
+arr3 <- c(3, 34, 4, 12, 5, 2)
+target3 <- 30
+cat("Array:", paste(arr3, collapse = ", "), "\n")
+cat("Target Sum:", target3, "\n")
+
+result3 <- subset_sum(arr3, target3)
+cat("Subset exists:", result3$exists, "\n\n")
+
+# Test 4: Multiple Solutions
+cat("Test 4: Multiple Solutions\n")
+arr4 <- c(1, 2, 3, 4, 5)
+target4 <- 6
+cat("Array:", paste(arr4, collapse = ", "), "\n")
+cat("Target Sum:", target4, "\n")
+
+result4 <- subset_sum(arr4, target4)
+cat("Subset exists:", result4$exists, "\n")
+if (result4$exists) {
+  cat("One possible subset:", paste(result4$subset, collapse = ", "), "\n")
+  
+  # Find all possible subsets
+  all_subsets <- find_all_subsets(arr4, target4)
+  cat("Total number of subsets:", length(all_subsets), "\n")
+  for (i in seq_along(all_subsets)) {
+    cat("Subset", i, ":", paste(all_subsets[[i]], collapse = ", "), 
+        "(sum =", sum(all_subsets[[i]]), ")\n")
+  }
+}
+cat("\n")
+
+# Test 5: Edge Cases
+cat("Test 5: Edge Cases\n")
+cat("Empty array, target 0:", subset_sum(c(), 0)$exists, "\n")
+cat("Empty array, target 5:", subset_sum(c(), 5)$exists, "\n")
+cat("Array [1,2,3], target 0:", subset_sum(c(1, 2, 3), 0)$exists, "\n")
+cat("Array [5], target 5:", subset_sum(c(5), 5)$exists, "\n")
+cat("Array [5], target 3:", subset_sum(c(5), 3)$exists, "\n\n")
+
+# Test 6: Larger Dataset
+cat("Test 6: Larger Dataset (n=15)\n")
+set.seed(42)
+arr_large <- sample(1:20, 15)
+target_large <- 50
+cat("Array:", paste(arr_large, collapse = ", "), "\n")
+cat("Target Sum:", target_large, "\n")
+
+start_time <- Sys.time()
+result_large <- subset_sum(arr_large, target_large)
+dp_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+start_time <- Sys.time()
+exists_large_opt <- subset_sum_optimized(arr_large, target_large)
+opt_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Subset exists:", result_large$exists, "\n")
+cat("DP method time:", sprintf("%.4f sec", dp_time), "\n")
+cat("Optimized method time:", sprintf("%.4f sec", opt_time), "\n")
+cat("Results match:", result_large$exists == exists_large_opt, "\n")
+
+if (result_large$exists) {
+  cat("One possible subset:", paste(result_large$subset, collapse = ", "), "\n")
+  cat("Sum verification:", sum(result_large$subset), "\n")
+}
+cat("\n")
+
+# Test 7: Real-world Example - Budget Allocation
+cat("Test 7: Real-world Example - Budget Allocation\n")
+project_costs <- c(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
+budget <- 150
+cat("Project costs:", paste(project_costs, collapse = ", "), "\n")
+cat("Available budget:", budget, "\n")
+
+budget_result <- subset_sum(project_costs, budget)
+cat("Exact budget allocation possible:", budget_result$exists, "\n")
+
+if (budget_result$exists) {
+  selected_projects <- budget_result$subset
+  cat("Selected projects (costs):", paste(selected_projects, collapse = ", "), "\n")
+  cat("Total cost:", sum(selected_projects), "\n")
+  cat("Remaining budget:", budget - sum(selected_projects), "\n")
+} else {
+  # Find closest possible sum (≤ budget) in a single pass
+  closest_sum <- max_subset_sum_leq(project_costs, budget)
+  cat("Closest possible sum:", closest_sum, "\n")
+}
diff --git a/Desktop/open-source/R/graph_algorithms/bellman_ford_shortest_path.r b/Desktop/open-source/R/graph_algorithms/bellman_ford_shortest_path.r
new file mode 100644
index 00000000..f6d06a74
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/bellman_ford_shortest_path.r
@@ -0,0 +1,146 @@
+# Bellman-Ford Shortest Path Algorithm
+#
+# The Bellman-Ford algorithm computes shortest paths from a single source vertex to
+# all other vertices in a weighted graph. Unlike Dijkstra's algorithm, Bellman-Ford
+# supports graphs with negative edge weights and can detect negative-weight cycles.
+#
+# Time Complexity: O(V * E)
+# Space Complexity: O(V)
+#
+# Input: graph as an adjacency list where each entry is a list of edges with fields
+#        `vertex` and `weight`, and `source` vertex index (integer)
+# Output: A list containing distances, predecessors, and a flag indicating whether
+#         a negative cycle was detected
+
+bellman_ford_shortest_path <- function(graph, source) {
+  # Collect all vertices (numeric indices expected)
+  all_vertices <- unique(c(names(graph), unlist(lapply(graph, function(x) sapply(x, function(e) e$vertex)))))
+  # Convert to numeric vector
+  all_vertices <- as.numeric(all_vertices)
+  num_vertices <- max(all_vertices)
+
+  # Initialize distances and predecessors
+  distances <- rep(Inf, num_vertices)
+  predecessor <- rep(-1, num_vertices)
+
+  distances[source] <- 0
+
+  # Relax edges repeatedly (V-1 times)
+  for (i in 1:(num_vertices - 1)) {
+    updated <- FALSE
+    # Iterate all edges
+    for (u_char in names(graph)) {
+      u <- as.numeric(u_char)
+      for (edge in graph[[u_char]]) {
+        v <- edge$vertex
+        w <- edge$weight
+        if (distances[u] != Inf && distances[u] + w < distances[v]) {
+          distances[v] <- distances[u] + w
+          predecessor[v] <- u
+          updated <- TRUE
+        }
+      }
+    }
+    # If no update in this pass, we can stop early
+    if (!updated) break
+  }
+
+  # Check for negative-weight cycles: if we can still relax, there is a negative cycle
+  negative_cycle <- FALSE
+  for (u_char in names(graph)) {
+    u <- as.numeric(u_char)
+    for (edge in graph[[u_char]]) {
+      v <- edge$vertex
+      w <- edge$weight
+      if (distances[u] != Inf && distances[u] + w < distances[v]) {
+        negative_cycle <- TRUE
+        break
+      }
+    }
+    if (negative_cycle) break
+  }
+
+  return(list(
+    distances = distances,
+    predecessor = predecessor,
+    negative_cycle = negative_cycle
+  ))
+}
+
+# Helper to reconstruct the shortest path from source to target
+get_bellman_ford_path <- function(result, source, target) {
+  if (result$negative_cycle) {
+    return(list(path = NULL, distance = NA, message = "Negative-weight cycle detected; shortest path undefined"))
+  }
+
+  distances <- result$distances
+  predecessor <- result$predecessor
+
+  if (is.infinite(distances[target])) {
+    return(list(path = NULL, distance = Inf, message = "Target not reachable from source"))
+  }
+
+  path <- c()
+  current <- target
+  while (current != -1) {
+    path <- c(current, path)
+    if (current == source) break
+    current <- predecessor[current]
+}
+
+  return(list(path = path, distance = distances[target]))
+}
+
+# Example usage and tests
+cat("=== Bellman-Ford Shortest Path Algorithm ===\n")
+
+# Example graph with negative edges but no negative cycle
+# Graph structure:
+# 1 -> 2 (6), 1 -> 3 (5), 1 -> 4 (5)
+# 2 -> 5 (-1)
+# 3 -> 2 (-2), 3 -> 5 (1)
+# 4 -> 3 (-2), 4 -> 6 (-1)
+# 5 -> 6 (3)
+# 6 -> (none)
+bf_graph <- list(
+  "1" = list(list(vertex = 2, weight = 6), list(vertex = 3, weight = 5), list(vertex = 4, weight = 5)),
+  "2" = list(list(vertex = 5, weight = -1)),
+  "3" = list(list(vertex = 2, weight = -2), list(vertex = 5, weight = 1)),
+  "4" = list(list(vertex = 3, weight = -2), list(vertex = 6, weight = -1)),
+  "5" = list(list(vertex = 6, weight = 3)),
+  "6" = list()
+)
+
+cat("Graph (adjacency list):\n")
+for (v in names(bf_graph)) {
+  edges <- bf_graph[[v]]
+  if (length(edges) > 0) {
+    edge_strs <- sapply(edges, function(e) paste0(e$vertex, "(", e$weight, ")"))
+    cat("Vertex", v, "-> [", paste(edge_strs, collapse = ", "), "]\n")
+  } else {
+    cat("Vertex", v, "-> []\n")
+  }
+}
+
+cat("\nRunning Bellman-Ford from vertex 1:\n")
+bf_result <- bellman_ford_shortest_path(bf_graph, 1)
+cat("Negative cycle detected:", bf_result$negative_cycle, "\n")
+
+cat("Distances from vertex 1:\n")
+for (i in 1:length(bf_result$distances)) {
+  d <- bf_result$distances[i]
+  if (is.infinite(d)) {
+    cat("To vertex", i, ": unreachable\n")
+  } else {
+    cat("To vertex", i, ": distance =", d, "\n")
+  }
+}
+
+cat("\nShortest path from 1 to 6:\n")
+path_info <- get_bellman_ford_path(bf_result, 1, 6)
+if (!is.null(path_info$path)) {
+  cat("Path:", paste(path_info$path, collapse = " -> "), "\n")
+  cat("Distance:", path_info$distance, "\n")
+} else {
+  cat(path_info$message, "\n")
+}
diff --git a/Desktop/open-source/R/graph_algorithms/breadth_first_search.r b/Desktop/open-source/R/graph_algorithms/breadth_first_search.r
new file mode 100644
index 00000000..049fc4ef
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/breadth_first_search.r
@@ -0,0 +1,217 @@
+# Breadth-First Search (BFS) Algorithm
+#
+# BFS is a graph traversal algorithm that explores all vertices at the current depth
+# before moving to vertices at the next depth level. It uses a queue data structure.
+#
+# Time Complexity: O(V + E) where V is vertices and E is edges
+# Space Complexity: O(V) for the visited array and queue
+#
+# Input: An adjacency list representation of a graph and a starting vertex
+# Output: The order in which vertices are visited during BFS traversal
+
+# BFS function using queue (implemented with vector)
+breadth_first_search <- function(graph, start_vertex) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array and queue
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  queue <- c(start_vertex)
+  result <- c()
+  
+  # Mark starting vertex as visited
+  visited[start_vertex] <- TRUE
+  
+  while (length(queue) > 0) {
+    # Dequeue vertex from front of queue
+    vertex <- queue[1]
+    queue <- queue[-1]
+    result <- c(result, vertex)
+    
+    # Add all unvisited neighbors to queue
+    if (as.character(vertex) %in% names(graph)) {
+      for (neighbor in graph[[as.character(vertex)]]) {
+        if (!visited[neighbor]) {
+          visited[neighbor] <- TRUE
+          queue <- c(queue, neighbor)
+        }
+      }
+    }
+  }
+  
+  return(result)
+}
+
+# BFS to find shortest path between two vertices
+bfs_shortest_path <- function(graph, start_vertex, end_vertex) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array, queue, and parent tracking
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  parent <- rep(-1, max(all_vertices))
+  names(parent) <- 1:max(all_vertices)
+  queue <- c(start_vertex)
+  
+  # Mark starting vertex as visited
+  visited[start_vertex] <- TRUE
+  
+  while (length(queue) > 0) {
+    # Dequeue vertex from front of queue
+    vertex <- queue[1]
+    queue <- queue[-1]
+    
+    # If we reached the target vertex, reconstruct path
+    if (vertex == end_vertex) {
+      path <- c()
+      current <- end_vertex
+      
+      # Backtrack using parent array
+      while (current != -1) {
+        path <- c(current, path)
+        current <- parent[current]
+      }
+      
+      return(list(
+        path = path,
+        distance = length(path) - 1
+      ))
+    }
+    
+    # Add all unvisited neighbors to queue
+    if (as.character(vertex) %in% names(graph)) {
+      for (neighbor in graph[[as.character(vertex)]]) {
+        if (!visited[neighbor]) {
+          visited[neighbor] <- TRUE
+          parent[neighbor] <- vertex
+          queue <- c(queue, neighbor)
+        }
+      }
+    }
+  }
+  
+  # No path found
+  return(list(
+    path = NULL,
+    distance = -1
+  ))
+}
+
+# BFS to find all vertices at a specific distance
+bfs_vertices_at_distance <- function(graph, start_vertex, target_distance) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array, queue with distances
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  queue <- list(list(vertex = start_vertex, distance = 0))
+  vertices_at_distance <- c()
+  
+  # Mark starting vertex as visited
+  visited[start_vertex] <- TRUE
+  
+  while (length(queue) > 0) {
+    # Dequeue vertex with distance from front of queue
+    current <- queue[[1]]
+    queue <- queue[-1]
+    vertex <- current$vertex
+    distance <- current$distance
+    
+    # If current distance matches target, add to result
+    if (distance == target_distance) {
+      vertices_at_distance <- c(vertices_at_distance, vertex)
+    }
+    
+    # Don't explore further if we've reached target distance
+    if (distance < target_distance) {
+      # Add all unvisited neighbors to queue
+      if (as.character(vertex) %in% names(graph)) {
+        for (neighbor in graph[[as.character(vertex)]]) {
+          if (!visited[neighbor]) {
+            visited[neighbor] <- TRUE
+            queue <- c(queue, list(list(vertex = neighbor, distance = distance + 1)))
+          }
+        }
+      }
+    }
+  }
+  
+  return(vertices_at_distance)
+}
+
+# Example usage and testing
+cat("=== Breadth-First Search (BFS) Algorithm ===\n")
+
+# Create a sample graph as adjacency list
+# Graph structure:
+#     1
+#    / \
+#   2   3
+#  / \   \
+# 4   5   6
+graph <- list(
+  "1" = c(2, 3),
+  "2" = c(4, 5),
+  "3" = c(6),
+  "4" = c(),
+  "5" = c(),
+  "6" = c()
+)
+
+cat("Graph structure (adjacency list):\n")
+for (vertex in names(graph)) {
+  cat("Vertex", vertex, "-> [", paste(graph[[vertex]], collapse = ", "), "]\n")
+}
+
+# Test BFS traversal
+cat("\nBFS starting from vertex 1:\n")
+result <- breadth_first_search(graph, 1)
+cat("Traversal order:", paste(result, collapse = " -> "), "\n")
+
+# Test BFS from different starting vertex
+cat("\nBFS starting from vertex 2:\n")
+result_from_2 <- breadth_first_search(graph, 2)
+cat("Traversal order:", paste(result_from_2, collapse = " -> "), "\n")
+
+# Test shortest path finding
+cat("\n=== Shortest Path Finding ===\n")
+path_result <- bfs_shortest_path(graph, 1, 5)
+if (!is.null(path_result$path)) {
+  cat("Shortest path from 1 to 5:", paste(path_result$path, collapse = " -> "), "\n")
+  cat("Distance:", path_result$distance, "\n")
+} else {
+  cat("No path found from 1 to 5\n")
+}
+
+# Test vertices at specific distance
+cat("\n=== Vertices at Specific Distance ===\n")
+vertices_dist_2 <- bfs_vertices_at_distance(graph, 1, 2)
+cat("Vertices at distance 2 from vertex 1:", paste(vertices_dist_2, collapse = ", "), "\n")
+
+# Example with a more complex connected graph
+cat("\n=== Example with More Complex Graph ===\n")
+complex_graph <- list(
+  "1" = c(2, 3),
+  "2" = c(1, 4, 5),
+  "3" = c(1, 6),
+  "4" = c(2, 7),
+  "5" = c(2, 8),
+  "6" = c(3, 9),
+  "7" = c(4),
+  "8" = c(5),
+  "9" = c(6)
+)
+
+cat("Complex graph BFS starting from vertex 1:\n")
+complex_result <- breadth_first_search(complex_graph, 1)
+cat("Traversal order:", paste(complex_result, collapse = " -> "), "\n")
+
+# Test shortest path in complex graph
+path_complex <- bfs_shortest_path(complex_graph, 1, 9)
+if (!is.null(path_complex$path)) {
+  cat("Shortest path from 1 to 9:", paste(path_complex$path, collapse = " -> "), "\n")
+  cat("Distance:", path_complex$distance, "\n")
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/graph_algorithms/bridge_detector.r b/Desktop/open-source/R/graph_algorithms/bridge_detector.r
new file mode 100644
index 00000000..ffd6eeac
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/bridge_detector.r
@@ -0,0 +1,226 @@
+# bridge_detector.r
+# Bridge Detection Algorithm in R using Tarjan's Algorithm
+# Finds all critical edges (bridges) in an undirected graph.
+# A bridge is an edge whose removal increases the number of connected components.
+#
+# Algorithm details:
+# - Uses DFS traversal with discovery time and low-link values
+# - disc[v]: Discovery time of vertex v in DFS
+# - low[v]: Earliest discovered vertex reachable from v's subtree
+# - Bridge condition: For edge (u,v), if low[v] > disc[u], then (u,v) is a bridge
+# - Time complexity: O(V + E) where V = vertices, E = edges
+# - Space complexity: O(V) for visited, discovery, and low-link arrays
+
+library(R6)
+
+BridgeDetector <- R6Class(
+  "BridgeDetector",
+  
+  public = list(
+    vertices = NULL,
+    graph = NULL,
+    time_counter = NULL,
+    
+    initialize = function(n_vertices) {
+      "Initialize the bridge detector with specified number of vertices"
+      if (!is.numeric(n_vertices) || n_vertices < 0 || n_vertices != round(n_vertices)) {
+        stop("Number of vertices must be a non-negative integer")
+      }
+      self$vertices <- n_vertices
+      self$graph <- vector("list", n_vertices)
+      self$time_counter <- 0
+      
+      for (i in seq_len(n_vertices)) {
+        self$graph[[i]] <- integer(0)
+      }
+    },
+    
+    add_edge = function(u, v) {
+      "Add an undirected edge between vertices u and v (0-indexed)"
+      if (!is.numeric(u) || !is.numeric(v) || 
+          u < 0 || v < 0 || 
+          u >= self$vertices || v >= self$vertices ||
+          u != round(u) || v != round(v)) {
+        stop("Vertex indices must be integers in range [0, n_vertices-1]")
+      }
+      u_idx <- u + 1
+      v_idx <- v + 1
+      self$graph[[u_idx]] <- c(self$graph[[u_idx]], v_idx)
+      self$graph[[v_idx]] <- c(self$graph[[v_idx]], u_idx)
+    },
+    
+    find_bridges = function() {
+      "Find all bridges in the graph using Tarjan's algorithm"
+      visited <- rep(FALSE, self$vertices)
+      disc <- rep(Inf, self$vertices)
+      low <- rep(Inf, self$vertices)
+      parent <- rep(-1, self$vertices)
+      bridges <- list()
+      
+      self$time_counter <- 0
+      
+      for (v in seq_len(self$vertices)) {
+        if (!visited[v]) {
+          res <- private$dfs_bridge(v, visited, disc, low, parent, bridges)
+          visited <- res$visited
+          disc <- res$disc
+          low <- res$low
+          parent <- res$parent
+          bridges <- res$bridges
+        }
+      }
+      return(bridges)
+    },
+    
+    print_graph = function() {
+      "Print adjacency list of the graph (0-indexed)"
+      cat("Graph Adjacency List:\n")
+      for (i in seq_len(self$vertices)) {
+        neighbors <- if (length(self$graph[[i]]) > 0) {
+          paste(self$graph[[i]] - 1, collapse = ", ")
+        } else {
+          "none"
+        }
+        cat(sprintf("Vertex %d: %s\n", i - 1, neighbors))
+      }
+    }
+  ),
+  
+  private = list(
+    dfs_bridge = function(u, visited, disc, low, parent, bridges) {
+      visited[u] <- TRUE
+      disc[u] <- self$time_counter
+      low[u] <- self$time_counter
+      self$time_counter <- self$time_counter + 1
+      
+      for (v_idx in self$graph[[u]]) {
+        if (!visited[v_idx]) {
+          parent[v_idx] <- u
+          res <- private$dfs_bridge(v_idx, visited, disc, low, parent, bridges)
+          visited <- res$visited
+          disc <- res$disc
+          low <- res$low
+          parent <- res$parent
+          bridges <- res$bridges
+          
+          low[u] <- min(low[u], low[v_idx])
+          
+          if (low[v_idx] > disc[u]) {
+            bridges[[length(bridges) + 1]] <- c(u - 1, v_idx - 1)
+          }
+        } else if (v_idx != parent[u]) {
+          low[u] <- min(low[u], disc[v_idx])
+        }
+      }
+      
+      return(list(
+        visited = visited, 
+        disc = disc, 
+        low = low, 
+        parent = parent, 
+        bridges = bridges
+      ))
+    }
+  )
+)
+
+# Demonstration
+demonstrate_bridge_detection <- function() {
+  cat("=== Bridge Detection Algorithm Demo ===\n\n")
+  
+  # Example 1
+  cat("Example 1: Simple network with bridges\n")
+  cat("Graph: 0-1-2-3\n")
+  cat("       |   |\n")
+  cat("       4   5\n\n")
+  
+  detector1 <- BridgeDetector$new(6)
+  detector1$add_edge(0, 1)
+  detector1$add_edge(1, 2)
+  detector1$add_edge(2, 3)
+  detector1$add_edge(0, 4)
+  detector1$add_edge(2, 5)
+  
+  bridges1 <- detector1$find_bridges()
+  cat("Bridges found:\n")
+  for (b in bridges1) {
+    cat(sprintf("  (%d, %d)\n", b[1], b[2]))
+  }
+  cat("All edges are critical - removing any disconnects the network.\n\n")
+  
+  # Example 2
+  cat("Example 2: Network with cycle (no bridges)\n")
+  cat("Graph: 0-1-2\n")
+  cat("       |   |\n")
+  cat("       +---+\n\n")
+  
+  detector2 <- BridgeDetector$new(3)
+  detector2$add_edge(0, 1)
+  detector2$add_edge(1, 2)
+  detector2$add_edge(2, 0)
+  
+  bridges2 <- detector2$find_bridges()
+  if (length(bridges2) == 0) {
+    cat("Bridges found: None\n")
+    cat("The cycle provides redundancy - no single edge is critical.\n\n")
+  }
+  
+  # Example 3
+  cat("Example 3: Complex network topology\n")
+  detector3 <- BridgeDetector$new(7)
+  detector3$add_edge(0, 1)
+  detector3$add_edge(1, 2)
+  detector3$add_edge(2, 0)
+  detector3$add_edge(1, 3)
+  detector3$add_edge(3, 4)
+  detector3$add_edge(4, 5)
+  detector3$add_edge(5, 6)
+  detector3$add_edge(6, 4)
+  
+  bridges3 <- detector3$find_bridges()
+  cat("Bridges found:\n")
+  for (b in bridges3) {
+    cat(sprintf("  (%d, %d)\n", b[1], b[2]))
+  }
+  cat("Edge (1,3) connects two robust sub-networks.\n\n")
+  
+  # Example 4: Testing print_graph
+  cat("Example 4: Viewing graph structure\n")
+  detector4 <- BridgeDetector$new(4)
+  detector4$add_edge(0, 1)
+  detector4$add_edge(1, 2)
+  detector4$add_edge(2, 3)
+  detector4$print_graph()
+  cat("\n")
+  
+  # Example 5: Edge cases
+  cat("Example 5: Edge cases\n")
+  
+  # Empty graph
+  detector5 <- BridgeDetector$new(0)
+  bridges5 <- detector5$find_bridges()
+  cat("Empty graph bridges: ", length(bridges5), "\n")
+  
+  # Single edge
+  detector6 <- BridgeDetector$new(2)
+  detector6$add_edge(0, 1)
+  bridges6 <- detector6$find_bridges()
+  cat("Single edge graph bridges:\n")
+  for (b in bridges6) {
+    cat(sprintf("  (%d, %d)\n", b[1], b[2]))
+  }
+  
+  # Disconnected components
+  detector7 <- BridgeDetector$new(4)
+  detector7$add_edge(0, 1)
+  detector7$add_edge(2, 3)
+  bridges7 <- detector7$find_bridges()
+  cat("Disconnected components bridges:\n")
+  for (b in bridges7) {
+    cat(sprintf("  (%d, %d)\n", b[1], b[2]))
+  }
+  cat("\n")
+}
+
+# Run demo
+demonstrate_bridge_detection()
\ No newline at end of file
diff --git a/Desktop/open-source/R/graph_algorithms/depth_first_search.r b/Desktop/open-source/R/graph_algorithms/depth_first_search.r
new file mode 100644
index 00000000..70532463
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/depth_first_search.r
@@ -0,0 +1,138 @@
+# Depth-First Search (DFS) Algorithm
+# 
+# DFS is a graph traversal algorithm that explores as far as possible along each branch
+# before backtracking. It uses a stack data structure (implemented via recursion here).
+#
+# Time Complexity: O(V + E) where V is vertices and E is edges
+# Space Complexity: O(V) for the visited array and recursion stack
+#
+# Input: An adjacency list representation of a graph and a starting vertex
+# Output: The order in which vertices are visited during DFS traversal
+
+# Recursive DFS function
+dfs_recursive <- function(graph, vertex, visited, result) {
+  # Mark current vertex as visited
+  visited[vertex] <- TRUE
+  result <- c(result, vertex)
+  
+  # Visit all unvisited adjacent vertices
+  if (vertex %in% names(graph)) {
+    for (neighbor in graph[[as.character(vertex)]]) {
+      if (!visited[neighbor]) {
+        result <- dfs_recursive(graph, neighbor, visited, result)
+      }
+    }
+  }
+  
+  return(result)
+}
+
+# Main DFS function
+depth_first_search <- function(graph, start_vertex) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  
+  # Perform DFS starting from the given vertex
+  result <- dfs_recursive(graph, start_vertex, visited, c())
+  
+  return(result)
+}
+
+# Iterative DFS function using explicit stack
+dfs_iterative <- function(graph, start_vertex) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  
+  # Initialize visited array and stack
+  visited <- rep(FALSE, max(all_vertices))
+  names(visited) <- 1:max(all_vertices)
+  stack <- c(start_vertex)
+  result <- c()
+  
+  while (length(stack) > 0) {
+    # Pop vertex from stack
+    vertex <- stack[length(stack)]
+    stack <- stack[-length(stack)]
+    
+    if (!visited[vertex]) {
+      # Mark as visited and add to result
+      visited[vertex] <- TRUE
+      result <- c(result, vertex)
+      
+      # Add all unvisited neighbors to stack (in reverse order to maintain left-to-right traversal)
+      if (as.character(vertex) %in% names(graph)) {
+        neighbors <- graph[[as.character(vertex)]]
+        for (neighbor in rev(neighbors)) {
+          if (!visited[neighbor]) {
+            stack <- c(stack, neighbor)
+          }
+        }
+      }
+    }
+  }
+  
+  return(result)
+}
+
+# Example usage and testing
+cat("=== Depth-First Search (DFS) Algorithm ===\n")
+
+# Create a sample graph as adjacency list
+# Graph structure:
+#     1
+#    / \
+#   2   3
+#  / \   \
+# 4   5   6
+graph <- list(
+  "1" = c(2, 3),
+  "2" = c(4, 5),
+  "3" = c(6),
+  "4" = c(),
+  "5" = c(),
+  "6" = c()
+)
+
+cat("Graph structure (adjacency list):\n")
+for (vertex in names(graph)) {
+  cat("Vertex", vertex, "-> [", paste(graph[[vertex]], collapse = ", "), "]\n")
+}
+
+# Test recursive DFS
+cat("\nRecursive DFS starting from vertex 1:\n")
+result_recursive <- depth_first_search(graph, 1)
+cat("Traversal order:", paste(result_recursive, collapse = " -> "), "\n")
+
+# Test iterative DFS
+cat("\nIterative DFS starting from vertex 1:\n")
+result_iterative <- dfs_iterative(graph, 1)
+cat("Traversal order:", paste(result_iterative, collapse = " -> "), "\n")
+
+# Test with different starting vertex
+cat("\nRecursive DFS starting from vertex 2:\n")
+result_from_2 <- depth_first_search(graph, 2)
+cat("Traversal order:", paste(result_from_2, collapse = " -> "), "\n")
+
+# Example with a more complex graph (with cycles)
+cat("\n=== Example with Cyclic Graph ===\n")
+cyclic_graph <- list(
+  "1" = c(2, 3),
+  "2" = c(1, 4),
+  "3" = c(1, 5),
+  "4" = c(2, 6),
+  "5" = c(3, 6),
+  "6" = c(4, 5)
+)
+
+cat("Cyclic graph structure:\n")
+for (vertex in names(cyclic_graph)) {
+  cat("Vertex", vertex, "-> [", paste(cyclic_graph[[vertex]], collapse = ", "), "]\n")
+}
+
+cat("\nDFS on cyclic graph starting from vertex 1:\n")
+cyclic_result <- depth_first_search(cyclic_graph, 1)
+cat("Traversal order:", paste(cyclic_result, collapse = " -> "), "\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/graph_algorithms/dijkstra_shortest_path.r b/Desktop/open-source/R/graph_algorithms/dijkstra_shortest_path.r
new file mode 100644
index 00000000..c9174e2d
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/dijkstra_shortest_path.r
@@ -0,0 +1,258 @@
+# Dijkstra's Shortest Path Algorithm
+#
+# Dijkstra's algorithm finds the shortest path between a source vertex and all other vertices
+# in a weighted graph with non-negative edge weights. It uses a greedy approach with a priority queue.
+#
+# Time Complexity: O((V + E) log V) with binary heap, O(V^2) with simple array
+# Space Complexity: O(V) for distance and visited arrays
+#
+# Input: A weighted graph represented as adjacency list with weights, and a source vertex
+# Output: Shortest distances from source to all vertices and the paths
+
+# Priority queue implementation using simple vector (for educational purposes)
+# In production, use more efficient data structures
+create_priority_queue <- function() {
+  list(
+    elements = data.frame(vertex = integer(0), distance = numeric(0)),
+    size = 0
+  )
+}
+
+# Insert element into priority queue
+pq_insert <- function(pq, vertex, distance) {
+  pq$elements <- rbind(pq$elements, data.frame(vertex = vertex, distance = distance))
+  pq$size <- pq$size + 1
+  return(pq)
+}
+
+# Extract minimum element from priority queue
+pq_extract_min <- function(pq) {
+  if (pq$size == 0) {
+    return(list(pq = pq, min_element = NULL))
+  }
+  
+  min_idx <- which.min(pq$elements$distance)
+  min_element <- pq$elements[min_idx, ]
+  pq$elements <- pq$elements[-min_idx, ]
+  pq$size <- pq$size - 1
+  
+  return(list(pq = pq, min_element = min_element))
+}
+
+# Check if priority queue is empty
+pq_is_empty <- function(pq) {
+  return(pq$size == 0)
+}
+
+# Main Dijkstra's algorithm implementation
+dijkstra_shortest_path <- function(graph, source) {
+  # Get all vertices in the graph
+  all_vertices <- unique(c(names(graph), unlist(lapply(graph, function(x) x$vertex))))
+  num_vertices <- max(all_vertices)
+  
+  # Initialize distances and previous vertices
+  distances <- rep(Inf, num_vertices)
+  previous <- rep(-1, num_vertices)
+  visited <- rep(FALSE, num_vertices)
+  
+  # Set source distance to 0
+  distances[source] <- 0
+  
+  # Create priority queue and add source
+  pq <- create_priority_queue()
+  pq <- pq_insert(pq, source, 0)
+  
+  while (!pq_is_empty(pq)) {
+    # Extract vertex with minimum distance
+    result <- pq_extract_min(pq)
+    pq <- result$pq
+    current <- result$min_element
+    
+    if (is.null(current)) break
+    
+    u <- current$vertex
+    
+    # Skip if already visited
+    if (visited[u]) next
+    
+    # Mark as visited
+    visited[u] <- TRUE
+    
+    # Update distances to neighbors
+    if (as.character(u) %in% names(graph)) {
+      for (edge in graph[[as.character(u)]]) {
+        v <- edge$vertex
+        weight <- edge$weight
+        
+        # Relaxation step
+        if (!visited[v] && distances[u] + weight < distances[v]) {
+          distances[v] <- distances[u] + weight
+          previous[v] <- u
+          pq <- pq_insert(pq, v, distances[v])
+        }
+      }
+    }
+  }
+  
+  return(list(
+    distances = distances,
+    previous = previous
+  ))
+}
+
+# Reconstruct shortest path from source to target
+get_shortest_path <- function(dijkstra_result, source, target) {
+  previous <- dijkstra_result$previous
+  distances <- dijkstra_result$distances
+  
+  # Check if target is reachable
+  if (distances[target] == Inf) {
+    return(list(
+      path = NULL,
+      distance = Inf
+    ))
+  }
+  
+  # Reconstruct path by backtracking
+  path <- c()
+  current <- target
+  
+  while (current != -1) {
+    path <- c(current, path)
+    current <- previous[current]
+  }
+  
+  return(list(
+    path = path,
+    distance = distances[target]
+  ))
+}
+
+# Find shortest paths to all vertices
+get_all_shortest_paths <- function(dijkstra_result, source) {
+  distances <- dijkstra_result$distances
+  previous <- dijkstra_result$previous
+  paths <- list()
+  
+  for (target in 1:length(distances)) {
+    if (distances[target] != Inf) {
+      path_result <- get_shortest_path(dijkstra_result, source, target)
+      paths[[as.character(target)]] <- path_result
+    }
+  }
+  
+  return(paths)
+}
+
+# Example usage and testing
+cat("=== Dijkstra's Shortest Path Algorithm ===\n")
+
+# Create a weighted graph as adjacency list
+# Graph structure with weights:
+#       1
+#     /   \
+#   4/     \2
+#   /       \
+#  2         3
+#  |3      /1
+#  |      /
+#  4-----5
+#     2
+weighted_graph <- list(
+  "1" = list(
+    list(vertex = 2, weight = 4),
+    list(vertex = 3, weight = 2)
+  ),
+  "2" = list(
+    list(vertex = 4, weight = 3)
+  ),
+  "3" = list(
+    list(vertex = 5, weight = 1)
+  ),
+  "4" = list(
+    list(vertex = 5, weight = 2)
+  ),
+  "5" = list()
+)
+
+cat("Weighted graph structure:\n")
+for (vertex in names(weighted_graph)) {
+  edges <- weighted_graph[[vertex]]
+  if (length(edges) > 0) {
+    edge_strs <- sapply(edges, function(e) paste0(e$vertex, "(", e$weight, ")"))
+    cat("Vertex", vertex, "-> [", paste(edge_strs, collapse = ", "), "]\n")
+  } else {
+    cat("Vertex", vertex, "-> []\n")
+  }
+}
+
+# Run Dijkstra's algorithm from vertex 1
+cat("\nRunning Dijkstra's algorithm from vertex 1:\n")
+result <- dijkstra_shortest_path(weighted_graph, 1)
+
+# Display shortest distances
+cat("Shortest distances from vertex 1:\n")
+for (i in 1:length(result$distances)) {
+  if (result$distances[i] != Inf) {
+    cat("To vertex", i, ": distance =", result$distances[i], "\n")
+  }
+}
+
+# Get shortest path to specific vertex
+cat("\nShortest path from 1 to 5:\n")
+path_to_5 <- get_shortest_path(result, 1, 5)
+if (!is.null(path_to_5$path)) {
+  cat("Path:", paste(path_to_5$path, collapse = " -> "), "\n")
+  cat("Distance:", path_to_5$distance, "\n")
+}
+
+# Get all shortest paths
+cat("\nAll shortest paths from vertex 1:\n")
+all_paths <- get_all_shortest_paths(result, 1)
+for (target in names(all_paths)) {
+  path_info <- all_paths[[target]]
+  cat("To vertex", target, ": ", paste(path_info$path, collapse = " -> "), 
+      " (distance:", path_info$distance, ")\n")
+}
+
+# Example with a more complex graph
+cat("\n=== More Complex Weighted Graph Example ===\n")
+complex_weighted_graph <- list(
+  "1" = list(
+    list(vertex = 2, weight = 7),
+    list(vertex = 3, weight = 9),
+    list(vertex = 6, weight = 14)
+  ),
+  "2" = list(
+    list(vertex = 3, weight = 10),
+    list(vertex = 4, weight = 15)
+  ),
+  "3" = list(
+    list(vertex = 4, weight = 11),
+    list(vertex = 6, weight = 2)
+  ),
+  "4" = list(
+    list(vertex = 5, weight = 6)
+  ),
+  "5" = list(),
+  "6" = list(
+    list(vertex = 5, weight = 9)
+  )
+)
+
+cat("Complex weighted graph from vertex 1:\n")
+complex_result <- dijkstra_shortest_path(complex_weighted_graph, 1)
+
+cat("Shortest distances:\n")
+for (i in 1:length(complex_result$distances)) {
+  if (complex_result$distances[i] != Inf) {
+    cat("To vertex", i, ": distance =", complex_result$distances[i], "\n")
+  }
+}
+
+# Shortest path to vertex 5
+path_to_5_complex <- get_shortest_path(complex_result, 1, 5)
+if (!is.null(path_to_5_complex$path)) {
+  cat("Shortest path from 1 to 5:", paste(path_to_5_complex$path, collapse = " -> "), "\n")
+  cat("Distance:", path_to_5_complex$distance, "\n")
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/graph_algorithms/floyd_warshall.r b/Desktop/open-source/R/graph_algorithms/floyd_warshall.r
new file mode 100644
index 00000000..3f7fb199
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/floyd_warshall.r
@@ -0,0 +1,285 @@
+# Floyd-Warshall Algorithm Implementation in R
+# Finds shortest paths between all pairs of vertices in a weighted graph
+# Can handle negative edge weights, but not negative cycles
+# Time complexity: O(V^3) where V is number of vertices
+# Space complexity: O(V^2) for distance and predecessor matrices
+
+
+
+#' FloydWarshall Class
+#' @description R6 class implementing the Floyd-Warshall algorithm
+#' @details Finds shortest paths between all pairs of vertices in a weighted directed graph.
+#' @importFrom R6 R6Class
+#' Can handle:
+#' - Positive and negative edge weights
+#' - Direct path reconstruction
+#' - Cycle detection
+#' - Disconnected components (represented by Inf)
+FloydWarshall <- R6::R6Class(
+  "FloydWarshall",
+  
+  public = list(
+    #' @description Initialize the algorithm with graph size
+    #' @param n_vertices Number of vertices in the graph
+    initialize = function(n_vertices) {
+      if (!is.numeric(n_vertices) || n_vertices < 1 || n_vertices != round(n_vertices)) {
+        stop("Number of vertices must be a positive integer (at least 1)")
+      }
+      
+      self$n_vertices <- n_vertices
+      private$initialize_matrices()
+      invisible(self)
+    },
+    
+    #' @description Add a weighted edge to the graph
+    #' @param from Source vertex (1-based indexing)
+    #' @param to Target vertex (1-based indexing)
+    #' @param weight Edge weight (can be negative)
+    add_edge = function(from, to, weight) {
+      private$validate_vertices(from, to)
+      if (!is.numeric(weight)) {
+        stop("Edge weight must be numeric")
+      }
+      
+      private$dist_matrix[from, to] <- weight
+      private$pred_matrix[from, to] <- from
+      invisible(self)
+    },
+    
+    #' @description Run the Floyd-Warshall algorithm
+    #' @return List containing distance matrix and presence of negative cycles
+    run = function() {
+      # Floyd-Warshall main loop
+      for (k in 1:self$n_vertices) {
+        for (i in 1:self$n_vertices) {
+          for (j in 1:self$n_vertices) {
+            if (!is.infinite(private$dist_matrix[i, k]) && 
+                !is.infinite(private$dist_matrix[k, j])) {
+              new_dist <- private$dist_matrix[i, k] + private$dist_matrix[k, j]
+              if (new_dist < private$dist_matrix[i, j]) {
+                private$dist_matrix[i, j] <- new_dist
+                private$pred_matrix[i, j] <- private$pred_matrix[k, j]
+              }
+            }
+          }
+        }
+      }
+      
+      # Check for negative cycles
+      has_negative_cycle <- FALSE
+      for (i in 1:self$n_vertices) {
+        if (private$dist_matrix[i, i] < 0) {
+          has_negative_cycle <- TRUE
+          break
+        }
+      }
+      
+      private$algorithm_run <- TRUE
+      
+      return(list(
+        distances = private$dist_matrix,
+        has_negative_cycle = has_negative_cycle
+      ))
+    },
+    
+    #' @description Get the shortest path between two vertices
+    #' @param from Source vertex
+    #' @param to Target vertex
+    #' @return List containing path and total distance
+    get_path = function(from, to) {
+      if (!private$algorithm_run) {
+        stop("Run the algorithm first using run()")
+      }
+      
+      private$validate_vertices(from, to)
+      
+      if (is.infinite(private$dist_matrix[from, to])) {
+        return(list(
+          path = numeric(0),
+          distance = Inf,
+          exists = FALSE
+        ))
+      }
+      
+      # Reconstruct path backward from 'to' using pred[from, current], then reverse
+      path <- c()
+      current <- to
+      
+      while (!is.na(current) && current != from) {
+        path <- c(current, path)
+        prev <- private$pred_matrix[from, current]
+        
+        # Check for cycles
+        if (length(path) > self$n_vertices) {
+          stop("Negative cycle detected in path reconstruction")
+        }
+        current <- prev
+      }
+      if (is.na(current)) {
+        # No path exists
+        return(list(
+          path = numeric(0),
+          distance = Inf,
+          exists = FALSE
+        ))
+      }
+      path <- c(from, path)
+      
+      return(list(
+        path = path,
+        distance = private$dist_matrix[from, to],
+        exists = TRUE
+      ))
+    },
+    
+    #' @description Get minimum distances from a source vertex to all others
+    #' @param from Source vertex
+    #' @return Named vector of distances
+    get_distances_from = function(from) {
+      if (!private$algorithm_run) {
+        stop("Run the algorithm first using run()")
+      }
+      
+      private$validate_vertices(from)
+      d <- private$dist_matrix[from, ]
+      names(d) <- as.character(seq_len(self$n_vertices))
+      return(d)
+    },
+    
+    #' @description Check if the graph has a negative cycle
+    #' @return TRUE if negative cycle exists, FALSE otherwise
+    has_negative_cycle = function() {
+      if (!private$algorithm_run) {
+        stop("Run the algorithm first using run()")
+      }
+      
+      for (i in 1:self$n_vertices) {
+        if (private$dist_matrix[i, i] < 0) {
+          return(TRUE)
+        }
+      }
+      return(FALSE)
+    },
+    
+    #' @description Print the distance matrix
+    print_distances = function() {
+      if (!private$algorithm_run) {
+        stop("Run the algorithm first using run()")
+      }
+      
+      cat("Distance Matrix:\n")
+      print(private$dist_matrix)
+      invisible(self)
+    },
+    
+    # Public fields
+    n_vertices = NULL
+  ),
+  
+  private = list(
+    dist_matrix = NULL,
+    pred_matrix = NULL,
+    algorithm_run = FALSE,
+    
+    initialize_matrices = function() {
+      # Initialize distance matrix with Inf for non-adjacent vertices
+      private$dist_matrix <- matrix(Inf, nrow = self$n_vertices, ncol = self$n_vertices)
+      diag(private$dist_matrix) <- 0
+      
+      # Initialize predecessor matrix
+      private$pred_matrix <- matrix(NA, nrow = self$n_vertices, ncol = self$n_vertices)
+      for (i in 1:self$n_vertices) {
+        private$pred_matrix[i, i] <- i
+      }
+    },
+    
+    validate_vertices = function(from, to = NULL) {
+      vertices <- if (is.null(to)) from else c(from, to)
+      
+      if (!all(is.numeric(vertices)) || 
+          !all(vertices == round(vertices)) ||
+          !all(vertices >= 1) ||
+          !all(vertices <= self$n_vertices)) {
+        stop("Vertex indices must be integers between 1 and ", self$n_vertices)
+      }
+    }
+  )
+)
+
+# Demonstration
+demonstrate_floyd_warshall <- function() {
+  cat("=== Floyd-Warshall Algorithm Demo ===\n\n")
+  
+  # Example 1: Simple weighted graph
+  cat("Example 1: Simple weighted graph\n")
+  cat("Graph: 4 vertices with various weighted edges\n\n")
+  
+  fw <- FloydWarshall$new(4)
+  
+  # Add edges (with weights)
+  fw$add_edge(1, 2, 5)
+  fw$add_edge(2, 3, 3)
+  fw$add_edge(3, 4, 1)
+  fw$add_edge(1, 3, 10)
+  fw$add_edge(2, 4, 6)
+  
+  # Run algorithm
+  result <- fw$run()
+  
+  cat("All-pairs shortest distances:\n")
+  fw$print_distances()
+  
+  # Get specific path
+  path_result <- fw$get_path(1, 4)
+  cat("\nShortest path from 1 to 4:\n")
+  cat(sprintf("Path: %s\n", paste(path_result$path, collapse = " → ")))
+  cat(sprintf("Distance: %g\n\n", path_result$distance))
+  
+  # Example 2: Graph with negative weights
+  cat("Example 2: Graph with negative weights\n")
+  cat("Graph: 3 vertices with some negative edges\n\n")
+  
+  fw2 <- FloydWarshall$new(3)
+  fw2$add_edge(1, 2, 4)
+  fw2$add_edge(2, 3, -2)
+  fw2$add_edge(1, 3, 5)
+  
+  result2 <- fw2$run()
+  
+  cat("All-pairs shortest distances:\n")
+  fw2$print_distances()
+  
+  # Example 3: Negative cycle detection
+  cat("\nExample 3: Negative cycle detection\n")
+  cat("Graph: 3 vertices with a negative cycle\n\n")
+  
+  fw3 <- FloydWarshall$new(3)
+  fw3$add_edge(1, 2, 1)
+  fw3$add_edge(2, 3, -5)
+  fw3$add_edge(3, 1, 2)
+  
+  result3 <- fw3$run()
+  
+  cat(sprintf("Contains negative cycle: %s\n\n",
+              ifelse(result3$has_negative_cycle, "Yes", "No")))
+  
+  # Example 4: Disconnected components
+  cat("Example 4: Disconnected components\n")
+  cat("Graph: 4 vertices with two components\n\n")
+  
+  fw4 <- FloydWarshall$new(4)
+  fw4$add_edge(1, 2, 3)
+  fw4$add_edge(3, 4, 2)
+  
+  result4 <- fw4$run()
+  
+  cat("All-pairs shortest distances:\n")
+  fw4$print_distances()
+  
+  cat("\n=== Demo Complete ===\n")
+}
+
+# Run demonstration only if explicitly requested via environment variable
+if (identical(Sys.getenv("RUN_FLOYD_WARSHALL_DEMO"), "true")) {
+  demonstrate_floyd_warshall()
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/graph_algorithms/hamilitonian_cycle.r b/Desktop/open-source/R/graph_algorithms/hamilitonian_cycle.r
new file mode 100644
index 00000000..be3a2950
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/hamilitonian_cycle.r
@@ -0,0 +1,102 @@
+# Hamiltonian Cycle Detection (Backtracking)
+#
+# The Hamiltonian Cycle problem determines whether there exists a cycle
+# in a graph that visits each vertex exactly once and returns to the start.
+# It is an NP-complete problem.
+#
+# This implementation uses backtracking to explore possible paths.
+#
+# Time Complexity: O(N!)
+# Space Complexity: O(N)
+#
+# Input: adjacency matrix (square matrix where adj[i][j] = 1 if edge exists)
+# Output: list containing:
+#   - has_cycle: TRUE/FALSE
+#   - cycle: list of vertices forming the Hamiltonian cycle (if found)
+#
+# Example usage at the end of this file.
+
+hamiltonian_cycle <- function(graph) {
+  num_vertices <- nrow(graph)
+  path <- rep(-1, num_vertices)
+  
+  # Start at vertex 1 (can be any vertex)
+  path[1] <- 1
+
+  # Helper function to check if vertex v can be added at position pos
+  is_safe <- function(v, graph, path, pos) {
+    # Check if current vertex is adjacent to previous vertex
+    if (graph[path[pos - 1], v] == 0) return(FALSE)
+    
+    # Check if vertex is already in the path
+    if (v %in% path[1:(pos - 1)]) return(FALSE)
+    
+    return(TRUE)
+  }
+
+  # Recursive utility to build Hamiltonian cycle
+  ham_cycle_util <- function(graph, path, pos) {
+    if (pos == num_vertices + 1) {
+      # If last vertex connects to the first → cycle found
+      if (graph[path[num_vertices], path[1]] == 1) {
+        return(TRUE)
+      } else {
+        return(FALSE)
+      }
+    }
+
+    # Try adding each vertex as next candidate
+    for (v in 2:num_vertices) {
+      if (is_safe(v, graph, path, pos)) {
+        path[pos] <- v
+        if (ham_cycle_util(graph, path, pos + 1)) return(TRUE)
+        # Backtrack
+        path[pos] <- -1
+      }
+    }
+    return(FALSE)
+  }
+
+  # Start backtracking from vertex 1
+  if (ham_cycle_util(graph, path, 2)) {
+    path <- c(path, path[1])  # complete the cycle
+    return(list(has_cycle = TRUE, cycle = path))
+  } else {
+    return(list(has_cycle = FALSE, cycle = NULL))
+  }
+}
+
+# ============================
+# Example Usage and Test
+# ============================
+
+cat("=== Hamiltonian Cycle Detection ===\n")
+
+# Example graph (Adjacency Matrix)
+# Graph:
+# 1 - 2 - 3
+# |   |   |
+# 4 - 5 - 6
+# This graph contains a Hamiltonian cycle
+ham_graph <- matrix(
+  c(0,1,0,1,0,0,
+    1,0,1,1,1,0,
+    0,1,0,0,1,1,
+    1,1,0,0,1,0,
+    0,1,1,1,0,1,
+    0,0,1,0,1,0),
+  nrow = 6, byrow = TRUE
+)
+
+cat("Adjacency Matrix:\n")
+print(ham_graph)
+
+cat("\nRunning Hamiltonian Cycle detection...\n")
+result <- hamiltonian_cycle(ham_graph)
+
+if (result$has_cycle) {
+  cat("Hamiltonian Cycle found:\n")
+  cat("Cycle:", paste(result$cycle, collapse = " -> "), "\n")
+} else {
+  cat("No Hamiltonian Cycle exists in this graph.\n")
+}
diff --git a/Desktop/open-source/R/graph_algorithms/hierholzer_eulerian.r b/Desktop/open-source/R/graph_algorithms/hierholzer_eulerian.r
new file mode 100644
index 00000000..923fd934
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/hierholzer_eulerian.r
@@ -0,0 +1,56 @@
+# Hierholzer's Algorithm for Eulerian Circuit
+#
+# Hierholzer's algorithm finds an Eulerian circuit in a graph, i.e., a closed path
+# that visits every edge exactly once. The graph must be connected, and all vertices
+# must have even degree (for undirected graphs) or in-degree = out-degree (for directed graphs).
+#
+# Time Complexity: O(E)
+# Space Complexity: O(V + E)
+#
+# Input: graph as an adjacency list (each entry is a vector of neighbors)
+# Output: Eulerian circuit as a vector of vertices in order
+
+hierholzer_eulerian <- function(graph) {
+  # Copy of the graph to modify during traversal
+  temp_graph <- lapply(graph, function(x) x)
+  
+  circuit <- c()
+  stack <- c(1)  # Start from vertex 1 (can choose any vertex)
+  
+  while (length(stack) > 0) {
+    u <- tail(stack, 1)
+    if (length(temp_graph[[as.character(u)]]) > 0) {
+      v <- temp_graph[[as.character(u)]][1]
+      temp_graph[[as.character(u)]] <- temp_graph[[as.character(u)]][-1]
+      stack <- c(stack, v)
+    } else {
+      circuit <- c(stack[length(stack)], circuit)
+      stack <- stack[-length(stack)]
+    }
+  }
+  
+  return(circuit)
+}
+
+# Example usage
+cat("=== Hierholzer's Algorithm for Eulerian Circuit ===\n")
+
+# Example undirected graph with Eulerian circuit:
+# 1-2, 1-3, 2-3, 2-4, 3-4
+hierholzer_graph <- list(
+  "1" = c(2,3),
+  "2" = c(1,3,4),
+  "3" = c(1,2,4),
+  "4" = c(2,3)
+)
+
+cat("Graph (adjacency list):\n")
+for (v in names(hierholzer_graph)) {
+  edges <- hierholzer_graph[[v]]
+  cat("Vertex", v, "-> [", paste(edges, collapse = ", "), "]\n")
+}
+
+cat("\nFinding Eulerian circuit:\n")
+euler_circuit <- hierholzer_eulerian(hierholzer_graph)
+cat("Eulerian circuit:", paste(euler_circuit, collapse = " -> "), "\n")
+
diff --git a/Desktop/open-source/R/graph_algorithms/hopcroft_karp_max_matching.r b/Desktop/open-source/R/graph_algorithms/hopcroft_karp_max_matching.r
new file mode 100644
index 00000000..d89e874c
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/hopcroft_karp_max_matching.r
@@ -0,0 +1,101 @@
+# Hopcroft-Karp Algorithm for Maximum Bipartite Matching
+#
+# The Hopcroft-Karp algorithm finds the maximum matching in a bipartite graph.
+# It alternates between BFS to find shortest augmenting paths and DFS to augment them.
+#
+# Time Complexity: O(E * sqrt(V))
+# Space Complexity: O(V + E)
+#
+# Input: bipartite graph as adjacency list (from left partition to right partition)
+# Output: Matching as a list where match_left[i] = matched vertex on right (or 0 if unmatched)
+
+hopcroft_karp <- function(graph, num_left, num_right) {
+  INF <- 1e9
+  match_left <- rep(0, num_left)
+  match_right <- rep(0, num_right)
+  dist <- rep(0, num_left)
+  
+  bfs <- function() {
+    queue <- c()
+    for (u in 1:num_left) {
+      if (match_left[u] == 0) {
+        dist[u] <<- 0
+        queue <- c(queue, u)
+      } else {
+        dist[u] <<- INF
+      }
+    }
+    found <- FALSE
+    while (length(queue) > 0) {
+      u <- queue[1]; queue <- queue[-1]
+      for (v in graph[[as.character(u)]]) {
+        mv <- match_right[v]
+        if (mv == 0) {
+          found <- TRUE
+        } else if (dist[mv] == INF) {
+          dist[mv] <<- dist[u] + 1
+          queue <- c(queue, mv)
+        }
+      }
+    }
+    return(found)
+  }
+  
+  dfs <- function(u) {
+    for (v in graph[[as.character(u)]]) {
+      mv <- match_right[v]
+      if (mv == 0 || (dist[mv] == dist[u] + 1 && dfs(mv))) {
+        match_left[u] <<- v
+        match_right[v] <<- u
+        return(TRUE)
+      }
+    }
+    dist[u] <<- INF
+    return(FALSE)
+  }
+  
+  matching <- 0
+  while (bfs()) {
+    for (u in 1:num_left) {
+      if (match_left[u] == 0 && dfs(u)) {
+        matching <- matching + 1
+      }
+    }
+  }
+  
+  return(list(match_left = match_left, match_right = match_right, max_matching = matching))
+}
+
+# Example usage
+cat("=== Hopcroft-Karp Maximum Bipartite Matching ===\n")
+
+# Bipartite graph: left partition 1..4, right partition 1..4
+# Graph edges: 1->1,1->2, 2->1, 3->2,3->3, 4->3,4->4
+bipartite_graph <- list(
+  "1" = c(1,2),
+  "2" = c(1),
+  "3" = c(2,3),
+  "4" = c(3,4)
+)
+
+num_left <- 4
+num_right <- 4
+
+cat("Graph (adjacency list from left partition):\n")
+for (u in names(bipartite_graph)) {
+  edges <- bipartite_graph[[u]]
+  cat("Vertex", u, "-> [", paste(edges, collapse = ", "), "]\n")
+}
+
+cat("\nRunning Hopcroft-Karp algorithm:\n")
+hk_result <- hopcroft_karp(bipartite_graph, num_left, num_right)
+cat("Maximum Matching Size:", hk_result$max_matching, "\n")
+
+cat("Matching from left partition:\n")
+for (i in 1:num_left) {
+  if (hk_result$match_left[i] != 0) {
+    cat("Left vertex", i, "-> Right vertex", hk_result$match_left[i], "\n")
+  } else {
+    cat("Left vertex", i, "is unmatched\n")
+  }
+}
diff --git a/Desktop/open-source/R/graph_algorithms/kosaraju_scc.r b/Desktop/open-source/R/graph_algorithms/kosaraju_scc.r
new file mode 100644
index 00000000..a10c5aa6
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/kosaraju_scc.r
@@ -0,0 +1,104 @@
+# Kosaraju's Strongly Connected Components (SCC) Algorithm
+#
+# Kosaraju's algorithm finds all strongly connected components in a directed graph.
+# It performs two depth-first searches (DFS):
+#   1. DFS on the original graph to compute finishing times of vertices.
+#   2. DFS on the transposed graph in the order of decreasing finishing times.
+#
+# Time Complexity: O(V + E)
+# Space Complexity: O(V + E)
+#
+# Input: graph as an adjacency list where each entry is a list of vertices it points to
+# Output: A list of SCCs (each SCC is a vector of vertices)
+
+kosaraju_scc <- function(graph) {
+  
+  num_vertices <- max(as.numeric(names(graph)))
+  visited <- rep(FALSE, num_vertices)
+  finish_stack <- c()
+  
+  # DFS to compute finishing times
+  dfs1 <- function(u) {
+    visited[u] <<- TRUE
+    for (v in graph[[as.character(u)]]) {
+      if (!visited[v]) dfs1(v)
+    }
+    finish_stack <<- c(u, finish_stack)  # push to stack
+  }
+  
+  # Step 1: Run DFS on all vertices
+  for (u in 1:num_vertices) {
+    if (!visited[u]) dfs1(u)
+  }
+  
+  # Step 2: Transpose the graph
+  transposed <- vector("list", num_vertices)
+  for (i in 1:num_vertices) transposed[[i]] <- c()
+  
+  for (u_char in names(graph)) {
+    u <- as.numeric(u_char)
+    for (v in graph[[u_char]]) {
+      transposed[[v]] <- c(transposed[[v]], u)
+    }
+  }
+  
+  # Step 3: DFS on transposed graph in order of decreasing finish time
+  visited <- rep(FALSE, num_vertices)
+  scc_list <- list()
+  
+  dfs2 <- function(u, current_scc) {
+    visited[u] <<- TRUE
+    current_scc <<- c(current_scc, u)
+    for (v in transposed[[u]]) {
+      if (!visited[v]) current_scc <<- dfs2(v, current_scc)
+    }
+    return(current_scc)
+  }
+  
+  for (u in finish_stack) {
+    if (!visited[u]) {
+      scc <- dfs2(u, c())
+      scc_list <- append(scc_list, list(scc))
+    }
+  }
+  
+  return(scc_list)
+}
+
+# Example usage
+cat("=== Kosaraju's Strongly Connected Components (SCC) Algorithm ===\n")
+
+# Example directed graph
+# Graph structure:
+# 1 -> 2
+# 2 -> 3
+# 3 -> 1, 4
+# 4 -> 5
+# 5 -> 6
+# 6 -> 4, 7
+# 7 -> (none)
+kosaraju_graph <- list(
+  "1" = c(2),
+  "2" = c(3),
+  "3" = c(1, 4),
+  "4" = c(5),
+  "5" = c(6),
+  "6" = c(4, 7),
+  "7" = c()
+)
+
+cat("Graph (adjacency list):\n")
+for (v in names(kosaraju_graph)) {
+  edges <- kosaraju_graph[[v]]
+  if (length(edges) > 0) {
+    cat("Vertex", v, "-> [", paste(edges, collapse = ", "), "]\n")
+  } else {
+    cat("Vertex", v, "-> []\n")
+  }
+}
+
+cat("\nFinding strongly connected components:\n")
+scc_result <- kosaraju_scc(kosaraju_graph)
+for (i in 1:length(scc_result)) {
+  cat("SCC", i, ":", paste(scc_result[[i]], collapse = ", "), "\n")
+}
diff --git a/Desktop/open-source/R/graph_algorithms/kruskal_mst.r b/Desktop/open-source/R/graph_algorithms/kruskal_mst.r
new file mode 100644
index 00000000..705f51d2
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/kruskal_mst.r
@@ -0,0 +1,124 @@
+# Kruskal's Minimum Spanning Tree (MST) Algorithm
+#
+# Kruskal's algorithm finds a subset of edges that connects all vertices in a graph
+# without any cycles and with the minimum possible total edge weight.
+#
+# It uses the Disjoint Set Union (DSU) or Union-Find data structure to detect cycles efficiently.
+#
+# Time Complexity: O(E log E) — dominated by sorting edges
+# Space Complexity: O(V)
+#
+# Input: graph as a list of edges (each edge has `u`, `v`, and `weight`)
+# Output: List containing MST edges and total minimum cost
+
+# -------------------------
+# Helper: Disjoint Set (Union-Find)
+# -------------------------
+
+make_set <- function(n) {
+  parent <- 1:n
+  rank <- rep(0, n)
+  return(list(parent = parent, rank = rank))
+}
+
+find_set <- function(parent, v) {
+  if (parent[v] != v) {
+    parent[v] <- find_set(parent, parent[v])  # Path compression
+  }
+  return(parent[v])
+}
+
+union_sets <- function(parent, rank, a, b) {
+  a_root <- find_set(parent, a)
+  b_root <- find_set(parent, b)
+  
+  if (a_root != b_root) {
+    if (rank[a_root] < rank[b_root]) {
+      temp <- a_root
+      a_root <- b_root
+      b_root <- temp
+    }
+    parent[b_root] <- a_root
+    if (rank[a_root] == rank[b_root]) {
+      rank[a_root] <- rank[a_root] + 1
+    }
+  }
+  return(list(parent = parent, rank = rank))
+}
+
+# -------------------------
+# Kruskal's MST Algorithm
+# -------------------------
+
+kruskal_mst <- function(edges, num_vertices) {
+  # Sort edges by weight
+  edges <- edges[order(sapply(edges, function(e) e$weight))]
+  
+  # Initialize disjoint sets
+  dsu <- make_set(num_vertices)
+  parent <- dsu$parent
+  rank <- dsu$rank
+  
+  mst_edges <- list()
+  total_cost <- 0
+  
+  # Process each edge
+  for (edge in edges) {
+    u <- edge$u
+    v <- edge$v
+    w <- edge$weight
+    
+    u_root <- find_set(parent, u)
+    v_root <- find_set(parent, v)
+    
+    # If u and v are in different sets, include this edge
+    if (u_root != v_root) {
+      mst_edges <- append(mst_edges, list(edge))
+      total_cost <- total_cost + w
+      merged <- union_sets(parent, rank, u_root, v_root)
+      parent <- merged$parent
+      rank <- merged$rank
+    }
+  }
+  
+  return(list(
+    mst_edges = mst_edges,
+    total_cost = total_cost
+  ))
+}
+
+# -------------------------
+# Example usage and testing
+# -------------------------
+
+cat("=== Kruskal's Minimum Spanning Tree Algorithm ===\n")
+
+# Example undirected weighted graph (edges list)
+# Graph:
+# 1 --(4)-- 2
+# 1 --(3)-- 3
+# 2 --(1)-- 3
+# 2 --(2)-- 4
+# 3 --(5)-- 4
+edges <- list(
+  list(u = 1, v = 2, weight = 4),
+  list(u = 1, v = 3, weight = 3),
+  list(u = 2, v = 3, weight = 1),
+  list(u = 2, v = 4, weight = 2),
+  list(u = 3, v = 4, weight = 5)
+)
+
+cat("Graph edges:\n")
+for (e in edges) {
+  cat(paste0("(", e$u, " -- ", e$v, ") weight = ", e$weight, "\n"))
+}
+
+cat("\nRunning Kruskal's MST:\n")
+result <- kruskal_mst(edges, num_vertices = 4)
+
+cat("MST Edges:\n")
+for (e in result$mst_edges) {
+  cat(paste0("(", e$u, " -- ", e$v, ") weight = ", e$weight, "\n"))
+}
+
+cat("Total Minimum Cost:", result$total_cost, "\n")
diff --git a/Desktop/open-source/R/graph_algorithms/page_rank.r b/Desktop/open-source/R/graph_algorithms/page_rank.r
new file mode 100644
index 00000000..825fd8c1
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/page_rank.r
@@ -0,0 +1,70 @@
+# PageRank Algorithm
+#
+# PageRank computes the importance of each vertex (web page) in a directed graph
+# based on the link structure. Pages linked by important pages get higher rank.
+#
+# Time Complexity: O(V^2) for dense graphs (can be O(E) for sparse graphs using adjacency lists)
+# Space Complexity: O(V)
+#
+# Input: graph as an adjacency list where each entry is a vector of outgoing links
+#        damping_factor (default 0.85), max_iterations, tolerance for convergence
+# Output: PageRank vector with scores for each vertex
+
+page_rank <- function(graph, damping_factor=0.85, max_iterations=100, tol=1e-6) {
+  num_vertices <- max(as.numeric(names(graph)))
+  pr <- rep(1/num_vertices, num_vertices)
+  
+  out_degree <- sapply(graph, length)
+  
+  for (iter in 1:max_iterations) {
+    pr_new <- rep((1 - damping_factor)/num_vertices, num_vertices)
+    for (u_char in names(graph)) {
+      u <- as.numeric(u_char)
+      neighbors <- graph[[u_char]]
+      if (length(neighbors) > 0) {
+        for (v in neighbors) {
+          pr_new[v] <- pr_new[v] + damping_factor * pr[u] / out_degree[u]
+        }
+      } else {
+        # Handle dangling nodes (no outgoing edges)
+        pr_new <- pr_new + damping_factor * pr[u] / num_vertices
+      }
+    }
+    if (sum(abs(pr_new - pr)) < tol) break
+    pr <- pr_new
+  }
+  
+  return(pr)
+}
+
+# Example usage
+cat("=== PageRank Algorithm ===\n")
+
+# Example directed graph (adjacency list)
+# Graph structure:
+# 1 -> 2,3
+# 2 -> 3
+# 3 -> 1
+# 4 -> 3
+pr_graph <- list(
+  "1" = c(2,3),
+  "2" = c(3),
+  "3" = c(1),
+  "4" = c(3)
+)
+
+cat("Graph (adjacency list):\n")
+for (v in names(pr_graph)) {
+  edges <- pr_graph[[v]]
+  if (length(edges) > 0) {
+    cat("Vertex", v, "-> [", paste(edges, collapse = ", "), "]\n")
+  } else {
+    cat("Vertex", v, "-> []\n")
+  }
+}
+
+cat("\nComputing PageRank:\n")
+pr_result <- page_rank(pr_graph)
+for (i in 1:length(pr_result)) {
+  cat("Vertex", i, ": PageRank =", round(pr_result[i], 4), "\n")
+}
diff --git a/Desktop/open-source/R/graph_algorithms/prim_mst.r b/Desktop/open-source/R/graph_algorithms/prim_mst.r
new file mode 100644
index 00000000..62f628d2
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/prim_mst.r
@@ -0,0 +1,88 @@
+# Prim's Minimum Spanning Tree Algorithm
+#
+# The Prim algorithm finds the Minimum Spanning Tree (MST) of a connected, undirected, weighted graph.
+# It starts from a source vertex and grows the MST by adding the smallest-weight edge connecting
+# the MST to a new vertex.
+#
+# Time Complexity: O(V^2) with adjacency matrix, can be O(E log V) with priority queue
+# Space Complexity: O(V)
+#
+# Input: graph as an adjacency list where each entry is a list of edges with fields
+#        `vertex` and `weight`, and `source` vertex index (integer)
+# Output: A list containing MST edges, total weight
+
+prim_mst <- function(graph, source = 1) {
+  all_vertices <- unique(c(names(graph), unlist(lapply(graph, function(x) sapply(x, function(e) e$vertex)))))
+  all_vertices <- as.numeric(all_vertices)
+  num_vertices <- max(all_vertices)
+
+  in_mst <- rep(FALSE, num_vertices)
+  key <- rep(Inf, num_vertices)
+  parent <- rep(-1, num_vertices)
+
+  key[source] <- 0
+
+  for (i in 1:num_vertices) {
+    # Pick the minimum key vertex not in MST
+    u <- which.min(ifelse(in_mst, Inf, key))
+
+    in_mst[u] <- TRUE
+
+    # Update keys and parents for adjacent vertices
+    for (edge in graph[[as.character(u)]]) {
+      v <- edge$vertex
+      w <- edge$weight
+      if (!in_mst[v] && w < key[v]) {
+        key[v] <- w
+        parent[v] <- u
+      }
+    }
+  }
+
+  # Build MST edges
+  mst_edges <- list()
+  total_weight <- 0
+  for (v in 1:num_vertices) {
+    if (parent[v] != -1) {
+      mst_edges <- append(mst_edges, list(list(from = parent[v], to = v, weight = key[v])))
+      total_weight <- total_weight + key[v]
+    }
+  }
+
+  return(list(
+    edges = mst_edges,
+    total_weight = total_weight
+  ))
+}
+
+# Example usage
+cat("=== Prim's Minimum Spanning Tree Algorithm ===\n")
+
+# Example undirected graph
+# Graph structure:
+# 1 --2--> 2
+# 1 --3--> 3
+# 2 --1--> 3
+# 2 --4--> 4
+# 3 --5--> 4
+prim_graph <- list(
+  "1" = list(list(vertex = 2, weight = 2), list(vertex = 3, weight = 3)),
+  "2" = list(list(vertex = 1, weight = 2), list(vertex = 3, weight = 1), list(vertex = 4, weight = 4)),
+  "3" = list(list(vertex = 1, weight = 3), list(vertex = 2, weight = 1), list(vertex = 4, weight = 5)),
+  "4" = list(list(vertex = 2, weight = 4), list(vertex = 3, weight = 5))
+)
+
+cat("Graph (adjacency list):\n")
+for (v in names(prim_graph)) {
+  edges <- prim_graph[[v]]
+  edge_strs <- sapply(edges, function(e) paste0(e$vertex, "(", e$weight, ")"))
+  cat("Vertex", v, "-> [", paste(edge_strs, collapse = ", "), "]\n")
+}
+
+cat("\nRunning Prim's MST from vertex 1:\n")
+mst_result <- prim_mst(prim_graph, 1)
+cat("MST edges:\n")
+for (edge in mst_result$edges) {
+  cat(edge$from, "--", edge$weight, "-->", edge$to, "\n")
+}
+cat("Total weight of MST:", mst_result$total_weight, "\n")
diff --git a/Desktop/open-source/R/graph_algorithms/stoer_wagner_min_cut.r b/Desktop/open-source/R/graph_algorithms/stoer_wagner_min_cut.r
new file mode 100644
index 00000000..09224565
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/stoer_wagner_min_cut.r
@@ -0,0 +1,70 @@
+# Stoer-Wagner Minimum Cut Algorithm
+#
+# Computes the global minimum cut of an undirected weighted graph.
+# The minimum cut is a partition of vertices into two sets minimizing
+# the sum of weights of edges crossing the partition.
+
+stoer_wagner_min_cut <- function(graph) {
+  num_vertices <- max(as.numeric(names(graph)))
+  vertices <- 1:num_vertices
+  min_cut_value <- Inf
+  best_cut <- NULL
+  
+  g <- graph  # copy of graph to modify
+  
+  while(length(vertices) > 1) {
+    used <- rep(FALSE, num_vertices)
+    weights <- rep(0, num_vertices)
+    prev <- NULL
+    
+    for (i in 1:length(vertices)) {
+      sel <- which.max(weights * (!used))
+      used[sel] <- TRUE
+      if (i == length(vertices)) {
+        # last vertex added
+        if (weights[sel] < min_cut_value) {
+          min_cut_value <- weights[sel]
+          best_cut <- c(sel)
+        }
+        # merge sel and prev
+        if (!is.null(prev)) {
+          for (v in 1:num_vertices) {
+            g[[prev]][v] <- g[[prev]][v] + g[[sel]][v]
+            g[[v]][prev] <- g[[prev]][v]
+          }
+          vertices <- vertices[vertices != sel]
+        }
+      } else {
+        # update weights
+        for (v in vertices) {
+          if (!used[v]) weights[v] <- weights[v] + g[[sel]][v]
+        }
+        prev <- sel
+      }
+    }
+  }
+  
+  return(list(min_cut_value = min_cut_value, cut_vertex = best_cut))
+}
+
+# Example usage
+cat("=== Stoer-Wagner Minimum Cut Algorithm ===\n")
+
+# Example undirected weighted graph as adjacency matrix
+# 1-2(3), 1-3(1), 2-3(3), 2-4(4), 3-4(5)
+graph_matrix <- list(
+  "1" = c(0,3,1,0),
+  "2" = c(3,0,3,4),
+  "3" = c(1,3,0,5),
+  "4" = c(0,4,5,0)
+)
+
+cat("Graph (adjacency matrix):\n")
+for (i in names(graph_matrix)) {
+  cat("Vertex", i, "-> [", paste(graph_matrix[[i]], collapse = ", "), "]\n")
+}
+
+cat("\nComputing global minimum cut:\n")
+min_cut_result <- stoer_wagner_min_cut(graph_matrix)
+cat("Minimum cut value:", min_cut_result$min_cut_value, "\n")
+cat("Cut vertex (representative):", min_cut_result$cut_vertex, "\n")
diff --git a/Desktop/open-source/R/graph_algorithms/topological_sort.r b/Desktop/open-source/R/graph_algorithms/topological_sort.r
new file mode 100644
index 00000000..1c27b137
--- /dev/null
+++ b/Desktop/open-source/R/graph_algorithms/topological_sort.r
@@ -0,0 +1,90 @@
+# Topological Sort Algorithm (Kahn's Algorithm)
+#
+# Topological sorting of a Directed Acyclic Graph (DAG) is a linear ordering 
+# of vertices such that for every directed edge u -> v, vertex u comes before v.
+# It is not possible if the graph has cycles.
+#
+# Time Complexity: O(V + E)
+# Space Complexity: O(V + E)
+#
+# Input: graph as an adjacency list where each entry is a list of vertices it points to
+# Output: A list containing the topological order and a flag indicating if a cycle exists
+
+topological_sort <- function(graph) {
+  all_vertices <- unique(c(names(graph), unlist(graph)))
+  all_vertices <- as.numeric(all_vertices)
+  
+  num_vertices <- max(all_vertices)
+  
+  # Compute in-degree of each vertex
+  in_degree <- rep(0, num_vertices)
+  for (u_char in names(graph)) {
+    u <- as.numeric(u_char)
+    for (v in graph[[u_char]]) {
+      in_degree[v] <- in_degree[v] + 1
+    }
+  }
+  
+  # Initialize queue with vertices having in-degree 0
+  queue <- which(in_degree == 0)
+  topo_order <- c()
+  
+  while (length(queue) > 0) {
+    u <- queue[1]
+    queue <- queue[-1]
+    topo_order <- c(topo_order, u)
+    
+    if (!is.null(graph[[as.character(u)]])) {
+      for (v in graph[[as.character(u)]]) {
+        in_degree[v] <- in_degree[v] - 1
+        if (in_degree[v] == 0) {
+          queue <- c(queue, v)
+        }
+      }
+    }
+  }
+  
+  # Check for cycles
+  has_cycle <- length(topo_order) != num_vertices
+  
+  return(list(
+    topo_order = if (!has_cycle) topo_order else NULL,
+    has_cycle = has_cycle
+  ))
+}
+
+# Example usage
+cat("=== Topological Sort (Kahn's Algorithm) ===\n")
+
+# Example DAG
+# Graph structure:
+# 1 -> 2, 1 -> 3
+# 2 -> 4
+# 3 -> 4
+# 4 -> 5
+topo_graph <- list(
+  "1" = c(2, 3),
+  "2" = c(4),
+  "3" = c(4),
+  "4" = c(5),
+  "5" = c()
+)
+
+cat("Graph (adjacency list):\n")
+for (v in names(topo_graph)) {
+  edges <- topo_graph[[v]]
+  if (length(edges) > 0) {
+    cat("Vertex", v, "-> [", paste(edges, collapse = ", "), "]\n")
+  } else {
+    cat("Vertex", v, "-> []\n")
+  }
+}
+
+cat("\nRunning Topological Sort:\n")
+ts_result <- topological_sort(topo_graph)
+
+if (!ts_result$has_cycle) {
+  cat("Topological Order:", paste(ts_result$topo_order, collapse = " -> "), "\n")
+} else {
+  cat("Cycle detected! Topological sort not possible.\n")
+}
diff --git a/Desktop/open-source/R/kruskal_mst.r b/Desktop/open-source/R/kruskal_mst.r
new file mode 100644
index 00000000..705f51d2
--- /dev/null
+++ b/Desktop/open-source/R/kruskal_mst.r
@@ -0,0 +1,124 @@
+# Kruskal's Minimum Spanning Tree (MST) Algorithm
+#
+# Kruskal's algorithm finds a subset of edges that connects all vertices in a graph
+# without any cycles and with the minimum possible total edge weight.
+#
+# It uses the Disjoint Set Union (DSU) or Union-Find data structure to detect cycles efficiently.
+#
+# Time Complexity: O(E log E) — dominated by sorting edges
+# Space Complexity: O(V)
+#
+# Input: graph as a list of edges (each edge has `u`, `v`, and `weight`)
+# Output: List containing MST edges and total minimum cost
+
+# -------------------------
+# Helper: Disjoint Set (Union-Find)
+# -------------------------
+
+make_set <- function(n) {
+  parent <- 1:n
+  rank <- rep(0, n)
+  return(list(parent = parent, rank = rank))
+}
+
+find_set <- function(parent, v) {
+  if (parent[v] != v) {
+    parent[v] <- find_set(parent, parent[v])  # Path compression
+  }
+  return(parent[v])
+}
+
+union_sets <- function(parent, rank, a, b) {
+  a_root <- find_set(parent, a)
+  b_root <- find_set(parent, b)
+  
+  if (a_root != b_root) {
+    if (rank[a_root] < rank[b_root]) {
+      temp <- a_root
+      a_root <- b_root
+      b_root <- temp
+    }
+    parent[b_root] <- a_root
+    if (rank[a_root] == rank[b_root]) {
+      rank[a_root] <- rank[a_root] + 1
+    }
+  }
+  return(list(parent = parent, rank = rank))
+}
+
+# -------------------------
+# Kruskal's MST Algorithm
+# -------------------------
+
+kruskal_mst <- function(edges, num_vertices) {
+  # Sort edges by weight
+  edges <- edges[order(sapply(edges, function(e) e$weight))]
+  
+  # Initialize disjoint sets
+  dsu <- make_set(num_vertices)
+  parent <- dsu$parent
+  rank <- dsu$rank
+  
+  mst_edges <- list()
+  total_cost <- 0
+  
+  # Process each edge
+  for (edge in edges) {
+    u <- edge$u
+    v <- edge$v
+    w <- edge$weight
+    
+    u_root <- find_set(parent, u)
+    v_root <- find_set(parent, v)
+    
+    # If u and v are in different sets, include this edge
+    if (u_root != v_root) {
+      mst_edges <- append(mst_edges, list(edge))
+      total_cost <- total_cost + w
+      merged <- union_sets(parent, rank, u_root, v_root)
+      parent <- merged$parent
+      rank <- merged$rank
+    }
+  }
+  
+  return(list(
+    mst_edges = mst_edges,
+    total_cost = total_cost
+  ))
+}
+
+# -------------------------
+# Example usage and testing
+# -------------------------
+
+cat("=== Kruskal's Minimum Spanning Tree Algorithm ===\n")
+
+# Example undirected weighted graph (edges list)
+# Graph:
+# 1 --(4)-- 2
+# 1 --(3)-- 3
+# 2 --(1)-- 3
+# 2 --(2)-- 4
+# 3 --(5)-- 4
+edges <- list(
+  list(u = 1, v = 2, weight = 4),
+  list(u = 1, v = 3, weight = 3),
+  list(u = 2, v = 3, weight = 1),
+  list(u = 2, v = 4, weight = 2),
+  list(u = 3, v = 4, weight = 5)
+)
+
+cat("Graph edges:\n")
+for (e in edges) {
+  cat(paste0("(", e$u, " -- ", e$v, ") weight = ", e$weight, "\n"))
+}
+
+cat("\nRunning Kruskal's MST:\n")
+result <- kruskal_mst(edges, num_vertices = 4)
+
+cat("MST Edges:\n")
+for (e in result$mst_edges) {
+  cat(paste0("(", e$u, " -- ", e$v, ") weight = ", e$weight, "\n"))
+}
+
+cat("Total Minimum Cost:", result$total_cost, "\n")
diff --git a/Desktop/open-source/R/machine_learning/.gitignore b/Desktop/open-source/R/machine_learning/.gitignore
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/Desktop/open-source/R/machine_learning/.gitignore
@@ -0,0 +1 @@
+
diff --git a/Desktop/open-source/R/machine_learning/README.md b/Desktop/open-source/R/machine_learning/README.md
new file mode 100644
index 00000000..86fe2aaf
--- /dev/null
+++ b/Desktop/open-source/R/machine_learning/README.md
@@ -0,0 +1,8 @@
+# Machine Learning with R
+
+## Tutorials
+
+- [Introduction to machine learning in R (tutorial) --- from Kaggle](https://www.kaggle.com/camnugent/introduction-to-machine-learning-in-r-tutorial)
+- [An Introduction to Machine Learning with R](https://lgatto.github.io/IntroMachineLearningWithR/)
+- [Machine Learning in R for beginners](https://www.datacamp.com/community/tutorials/machine-learning-in-r)
+- [Machine Learning in R: mlr-tutorial](https://www.notion.so/mlr-Tutorial-b71444fe979c4a8cafe91e10e7f81d79)
diff --git a/Desktop/open-source/R/machine_learning/gradient_boosting.r b/Desktop/open-source/R/machine_learning/gradient_boosting.r
new file mode 100644
index 00000000..a07d68bb
--- /dev/null
+++ b/Desktop/open-source/R/machine_learning/gradient_boosting.r
@@ -0,0 +1,435 @@
+# gradient_boosting.r
+# Gradient Boosting Algorithm Implementation in R
+# A sequential ensemble learning method that builds models iteratively
+# Each new model corrects errors made by previous models
+#
+# Algorithm details:
+# - Uses decision trees as weak learners
+# - Fits each tree to the residuals (errors) of previous predictions
+# - Combines predictions using weighted sum
+# - Learning rate controls contribution of each tree
+# - Time complexity: O(n_trees * n_samples * log(n_samples))
+# - Space complexity: O(n_trees * tree_size)
+
+library(R6)
+
+#' Decision Tree Node
+#' Simple decision tree implementation for gradient boosting
+DecisionTreeNode <- R6Class(
+  "DecisionTreeNode",
+  
+  public = list(
+    feature = NULL,
+    threshold = NULL,
+    left = NULL,
+    right = NULL,
+    value = NULL,
+    
+    initialize = function(feature = NULL, threshold = NULL, 
+                         left = NULL, right = NULL, value = NULL) {
+      self$feature <- feature
+      self$threshold <- threshold
+      self$left <- left
+      self$right <- right
+      self$value <- value
+    },
+    
+    is_leaf = function() {
+      return(!is.null(self$value))
+    }
+  )
+)
+
+#' Regression Tree for Gradient Boosting
+RegressionTree <- R6Class(
+  "RegressionTree",
+  
+  public = list(
+    max_depth = NULL,
+    min_samples_split = NULL,
+    root = NULL,
+    
+    initialize = function(max_depth = 3, min_samples_split = 2) {
+      self$max_depth <- max_depth
+      self$min_samples_split <- min_samples_split
+      self$root <- NULL
+    },
+    
+    fit = function(X, y) {
+      "Build the decision tree"
+      self$root <- private$build_tree(X, y, depth = 0)
+      invisible(self)
+    },
+    
+    predict = function(X) {
+      "Predict values for input data"
+      if (is.vector(X)) {
+        X <- matrix(X, nrow = 1)
+      }
+      apply(X, 1, function(row) private$predict_sample(row, self$root))
+    }
+  ),
+  
+  private = list(
+    build_tree = function(X, y, depth) {
+      "Recursively build decision tree"
+      n_samples <- nrow(X)
+      
+      # Stopping criteria
+      if (depth >= self$max_depth || 
+          n_samples < self$min_samples_split ||
+          length(unique(y)) == 1) {
+        return(DecisionTreeNode$new(value = mean(y)))
+      }
+      
+      # Find best split
+      best_split <- private$find_best_split(X, y)
+      
+      if (is.null(best_split)) {
+        return(DecisionTreeNode$new(value = mean(y)))
+      }
+      
+      # Split data
+      left_idx <- X[, best_split$feature] <= best_split$threshold
+      right_idx <- !left_idx
+      
+      # Build subtrees
+      left_subtree <- private$build_tree(
+        X[left_idx, , drop = FALSE], 
+        y[left_idx], 
+        depth + 1
+      )
+      right_subtree <- private$build_tree(
+        X[right_idx, , drop = FALSE], 
+        y[right_idx], 
+        depth + 1
+      )
+      
+      return(DecisionTreeNode$new(
+        feature = best_split$feature,
+        threshold = best_split$threshold,
+        left = left_subtree,
+        right = right_subtree
+      ))
+    },
+    
+    find_best_split = function(X, y) {
+      "Find the best feature and threshold to split on"
+      best_mse <- Inf
+      best_split <- NULL
+      n_features <- ncol(X)
+      n_samples <- nrow(X)
+      min_samples_leaf <- max(1, floor(self$min_samples_split / 2))
+      
+      for (feature in 1:n_features) {
+        # Sort feature values and corresponding targets
+        sorted_idx <- order(X[, feature])
+        sorted_x <- X[sorted_idx, feature]
+        sorted_y <- y[sorted_idx]
+        
+        # Consider only unique values as potential thresholds
+        unique_vals <- unique(sorted_x)
+        if (length(unique_vals) <= 1) next
+        
+        # Pre-compute cumulative statistics
+        cum_sum <- cumsum(sorted_y)
+        cum_sum_sq <- cumsum(sorted_y^2)
+        
+        # Evaluate splits between unique values
+        for (i in 1:(length(unique_vals)-1)) {
+          threshold <- (unique_vals[i] + unique_vals[i+1]) / 2
+          split_idx <- which(sorted_x <= threshold)
+          n_left <- length(split_idx)
+          n_right <- n_samples - n_left
+          
+          # Skip if split doesn't meet minimum samples requirement
+          if (n_left < min_samples_leaf || n_right < min_samples_leaf) next
+          
+          # Calculate MSE using pre-computed statistics
+          left_sum <- cum_sum[n_left]
+          left_sum_sq <- cum_sum_sq[n_left]
+          right_sum <- cum_sum[n_samples] - left_sum
+          right_sum_sq <- cum_sum_sq[n_samples] - left_sum_sq
+          
+          left_mse <- (left_sum_sq - (left_sum^2)/n_left)
+          right_mse <- (right_sum_sq - (right_sum^2)/n_right)
+          mse <- left_mse + right_mse
+          
+          if (mse < best_mse) {
+            best_mse <- mse
+            best_split <- list(feature = feature, threshold = threshold)
+          }
+        }
+      }
+      
+      return(best_split)
+    },
+    
+    predict_sample = function(x, node) {
+      "Predict single sample by traversing tree"
+      if (node$is_leaf()) {
+        return(node$value)
+      }
+      
+      if (x[node$feature] <= node$threshold) {
+        return(private$predict_sample(x, node$left))
+      } else {
+        return(private$predict_sample(x, node$right))
+      }
+    }
+  )
+)
+
+#' Gradient Boosting Regressor
+GradientBoostingRegressor <- R6Class(
+  "GradientBoostingRegressor",
+  
+  public = list(
+    n_estimators = NULL,
+    learning_rate = NULL,
+    max_depth = NULL,
+    min_samples_split = NULL,
+    trees = NULL,
+    initial_prediction = NULL,
+    early_stopping_rounds = NULL,
+    best_iteration = NULL,
+    
+    initialize = function(n_estimators = 100, learning_rate = 0.1, 
+                         max_depth = 3, min_samples_split = 2,
+                         early_stopping_rounds = NULL) {
+      "Initialize gradient boosting parameters"
+      if (n_estimators <= 0 || learning_rate <= 0 || max_depth <= 0) {
+        stop("Parameters must be positive")
+      }
+      
+      self$n_estimators <- n_estimators
+      self$learning_rate <- learning_rate
+      self$max_depth <- max_depth
+      self$min_samples_split <- min_samples_split
+      self$trees <- list()
+      self$initial_prediction <- NULL
+    },
+    
+    fit = function(X, y, verbose = FALSE) {
+      "Train the gradient boosting model"
+      # Input validation
+      if (!is.numeric(y)) {
+        stop("Target variable 'y' must be numeric")
+      }
+      if (is.vector(X)) {
+        X <- matrix(X, ncol = 1)
+      }
+      if (!is.matrix(X) || !is.numeric(X)) {
+        stop("Input 'X' must be a numeric matrix or vector")
+      }
+      if (length(y) != nrow(X)) {
+        stop("Number of samples in X and y must match")
+      }
+      if (any(is.na(X)) || any(is.na(y))) {
+        stop("Input contains missing values")
+      }
+      
+      # Initialize with mean of target
+      self$initial_prediction <- mean(y)
+      predictions <- rep(self$initial_prediction, length(y))
+      
+      # Build trees sequentially
+      for (i in 1:self$n_estimators) {
+        # Calculate residuals (negative gradient for MSE loss)
+        residuals <- y - predictions
+        
+        # Fit tree to residuals
+        tree <- RegressionTree$new(
+          max_depth = self$max_depth,
+          min_samples_split = self$min_samples_split
+        )
+        tree$fit(X, residuals)
+        
+        # Update predictions
+        tree_predictions <- tree$predict(X)
+        predictions <- predictions + self$learning_rate * tree_predictions
+        
+        # Store tree
+        self$trees[[i]] <- tree
+        
+        # Calculate training error
+        if (verbose && (i %% 10 == 0 || i == 1)) {
+          mse <- mean((y - predictions)^2)
+          rmse <- sqrt(mse)
+          cat(sprintf("Iteration %d/%d - RMSE: %.4f\n", 
+                     i, self$n_estimators, rmse))
+        }
+      }
+      
+      invisible(self)
+    },
+    
+    predict = function(X) {
+      "Make predictions using the trained model"
+      if (is.null(self$initial_prediction)) {
+        stop("Model has not been fitted yet")
+      }
+      
+      if (is.vector(X)) {
+        X <- matrix(X, ncol = 1)
+      }
+      
+      # Start with initial prediction
+      predictions <- rep(self$initial_prediction, nrow(X))
+      
+      # Add contribution from each tree
+      for (tree in self$trees) {
+        predictions <- predictions + self$learning_rate * tree$predict(X)
+      }
+      
+      return(predictions)
+    },
+    
+    score = function(X, y) {
+      "Calculate R-squared score"
+      predictions <- self$predict(X)
+      ss_res <- sum((y - predictions)^2)
+      ss_tot <- sum((y - mean(y))^2)
+      r2 <- 1 - (ss_res / ss_tot)
+      return(r2)
+    },
+    
+    get_feature_importance = function() {
+      "Calculate relative feature importance based on split frequency and gain"
+      if (length(self$trees) == 0) {
+        stop("Model has not been fitted yet")
+      }
+      
+      # Count feature usage and gain in splits
+      n_features <- ncol(X)  # Assumes X from last fit
+      importance <- rep(0, n_features)
+      names(importance) <- paste0("Feature_", 1:n_features)
+      
+      calculate_tree_importance <- function(node, depth = 0) {
+        if (is.null(node) || node$is_leaf()) {
+          return(NULL)
+        }
+        
+        # Add importance score based on depth (earlier splits are more important)
+        feature_idx <- node$feature
+        importance[feature_idx] <<- importance[feature_idx] + 1 / (depth + 1)
+        
+        calculate_tree_importance(node$left, depth + 1)
+        calculate_tree_importance(node$right, depth + 1)
+      }
+      
+      # Calculate importance for each tree
+      for (tree in self$trees) {
+        calculate_tree_importance(tree$root)
+      }
+      
+      # Normalize importance scores
+      if (sum(importance) > 0) {
+        importance <- importance / sum(importance)
+      }
+      
+      # Sort and return as named vector
+      importance <- sort(importance, decreasing = TRUE)
+      return(importance)
+    }
+  )
+)
+
+# Demonstration and testing
+demonstrate_gradient_boosting <- function() {
+  cat("=== Gradient Boosting Algorithm Demo ===\n\n")
+  
+  # Generate synthetic dataset
+  set.seed(42)
+  n_samples <- 200
+  
+  cat("Example 1: Non-linear regression problem\n")
+  cat("Generating synthetic data...\n\n")
+  
+  # Create non-linear relationship
+  X <- matrix(runif(n_samples, -3, 3), ncol = 1)
+  y <- sin(X[, 1]) + 0.3 * X[, 1]^2 + rnorm(n_samples, 0, 0.1)
+  
+  # Split into train and test
+  train_idx <- sample(1:n_samples, size = 0.8 * n_samples)
+  test_idx <- setdiff(1:n_samples, train_idx)
+  
+  X_train <- matrix(X[train_idx, ], ncol = 1)
+  y_train <- y[train_idx]
+  X_test <- matrix(X[test_idx, ], ncol = 1)
+  y_test <- y[test_idx]
+  
+  # Train model
+  cat("Training Gradient Boosting model...\n")
+  model <- GradientBoostingRegressor$new(
+    n_estimators = 50,
+    learning_rate = 0.1,
+    max_depth = 3
+  )
+  model$fit(X_train, y_train, verbose = TRUE)
+  
+  # Make predictions
+  cat("\nEvaluating model...\n")
+  train_pred <- model$predict(X_train)
+  test_pred <- model$predict(X_test)
+  
+  # Calculate metrics
+  train_rmse <- sqrt(mean((y_train - train_pred)^2))
+  test_rmse <- sqrt(mean((y_test - test_pred)^2))
+  train_r2 <- model$score(X_train, y_train)
+  test_r2 <- model$score(X_test, y_test)
+  
+  cat(sprintf("\nResults:\n"))
+  cat(sprintf("Train RMSE: %.4f | Train R²: %.4f\n", train_rmse, train_r2))
+  cat(sprintf("Test RMSE:  %.4f | Test R²:  %.4f\n\n", test_rmse, test_r2))
+  
+  # Example 2: Multi-feature problem
+  cat("Example 2: Multi-feature regression\n")
+  cat("Generating multi-dimensional data...\n")
+  
+  X_multi <- matrix(rnorm(n_samples * 3), ncol = 3)
+  y_multi <- 2 * X_multi[, 1] - 3 * X_multi[, 2] + 
+             0.5 * X_multi[, 3]^2 + rnorm(n_samples, 0, 0.5)
+  
+  # Train-test split
+  X_train_multi <- X_multi[train_idx, ]
+  y_train_multi <- y_multi[train_idx]
+  X_test_multi <- X_multi[test_idx, ]
+  y_test_multi <- y_multi[test_idx]
+  
+  # Train model
+  model2 <- GradientBoostingRegressor$new(
+    n_estimators = 50,
+    learning_rate = 0.1,
+    max_depth = 4
+  )
+  model2$fit(X_train_multi, y_train_multi)
+  
+  # Evaluate
+  test_rmse2 <- sqrt(mean((y_test_multi - model2$predict(X_test_multi))^2))
+  test_r2_2 <- model2$score(X_test_multi, y_test_multi)
+  
+  cat(sprintf("Test RMSE: %.4f | Test R²: %.4f\n\n", test_rmse2, test_r2_2))
+  
+  # Example 3: Hyperparameter comparison
+  cat("Example 3: Impact of learning rate\n")
+  learning_rates <- c(0.01, 0.1, 0.5)
+  
+  for (lr in learning_rates) {
+    model_lr <- GradientBoostingRegressor$new(
+      n_estimators = 30,
+      learning_rate = lr,
+      max_depth = 3
+    )
+    model_lr$fit(X_train, y_train, verbose = FALSE)
+    test_rmse_lr <- sqrt(mean((y_test - model_lr$predict(X_test))^2))
+    cat(sprintf("Learning rate %.2f - Test RMSE: %.4f\n", lr, test_rmse_lr))
+  }
+  
+  cat("\n=== Demo Complete ===\n")
+}
+
+# Run demonstration
+if (!interactive()) {
+  demonstrate_gradient_boosting()
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/mathematics/amicable_numbers.r b/Desktop/open-source/R/mathematics/amicable_numbers.r
new file mode 100644
index 00000000..8b21590e
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/amicable_numbers.r
@@ -0,0 +1,34 @@
+are_numbers_amicable <- function(x, y) {
+
+  #' @description Checks if numbers passed as a parameter are amicable numbers.
+  #' @param x first number to check
+  #' @param y second number to check
+  #' @usage are_numbers_amicable(x, y)
+  #' @details Amicable numbers are two different natural numbers related
+  #' in such a way that the sum of the proper divisors of each
+  #' is equal to the other number.
+  #' @references https://en.wikipedia.org/wiki/Amicable_numbers
+
+  x_divisors_sum <- get_sum_of_divisors(x)
+  y_divisors_sum <- get_sum_of_divisors(y)
+
+  return((x_divisors_sum == y) && (y_divisors_sum == x))
+}
+
+get_sum_of_divisors <- function(n) {
+  sum <- 0
+  limit <- n - 1
+  for (i in 1:limit) {
+     if (n %% i == 0) {
+        sum <- sum + i
+     }
+  }
+
+  return(sum)
+}
+
+result <- are_numbers_amicable(220, 284)
+print(result)  # expected true
+
+result <- are_numbers_amicable(15, 100)
+print(result)  # expected false
\ No newline at end of file
diff --git a/Desktop/open-source/R/mathematics/armstrong_number.r b/Desktop/open-source/R/mathematics/armstrong_number.r
new file mode 100644
index 00000000..25f6f0eb
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/armstrong_number.r
@@ -0,0 +1,27 @@
+# Armstrong Number (also know as narcissistic numbers) checking in R
+
+isArmstrong <- function(integer){
+  
+  digitAmount <- if(integer > 0){ 
+    floor(log10(integer))+1
+  } else if(integer == 0){
+    1
+  } else return(FALSE)
+  
+  temp <- integer
+  Armstrong <- 0
+  
+  while(temp > 0){
+    Armstrong <- Armstrong + (temp %% 10)^digitAmount
+    temp <- floor(temp / 10)
+  }
+  
+  if(Armstrong == integer){
+    return(TRUE)
+  } else return(FALSE)
+  
+}
+
+isArmstrong(5) #returns TRUE
+isArmstrong(29) #returns FALSE
+isArmstrong(370) #returns TRUE
diff --git a/Desktop/open-source/R/mathematics/bisection_method.r b/Desktop/open-source/R/mathematics/bisection_method.r
new file mode 100644
index 00000000..2c06126b
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/bisection_method.r
@@ -0,0 +1,58 @@
+# Bisection method
+library(roxygen2)
+library(docstring)
+
+NMAX = 100 # maximum number of iterations
+EPSILON = 1e-4 # a small positive quantity
+
+
+func <- function(x) {
+  #' Continuous function for which we want to find the root
+  #' @param x Real input variable
+  #' @returns The evaluation result of the function using the input value
+  x^3 + 2.0*x - 10.0
+}
+
+
+bisection <- function(x_left, x_right, tolerance) {
+  #' Bisection method is a root-finding method that applies to any continuous 
+  #' function for which one knows two values with opposite signs.
+  #' @description Finds the root value of a continuous function.
+  #' @param x_left Float
+  #' @param x_right Float
+  #' @param tolerance Float
+  #' @returns Root value
+  #' @usage bisection(x_left, x_right, tolerance)
+  #' @details The method consists of repeatedly bisecting the interval defined 
+  #' by the two values and then selecting the subinterval in which the function 
+  #' changes sign, and therefore must contain a root. It is a very simple and 
+  #' robust method, but it is also relatively slow. Because of this, it is 
+  #' often used to obtain a rough approximation to a solution which is then 
+  #' used as a starting point for more rapidly converging methods.
+  #' @references https://en.wikipedia.org/wiki/Bisection_method
+  #' @author Aybars Nazlica https://github.com/aybarsnazlica
+  
+  n = 1 # step counter
+  
+  while(n <= NMAX) {
+    middle = (x_left + x_right) / 2 # midpoint
+    error = middle - x_left
+    
+    if (abs(func(middle)) < EPSILON || error < tolerance) {
+      return(middle)
+    }
+    
+    if (prod(sign(c(func(middle), func(x_left)))) > 0) { # if sign is positive
+      x_left = middle # new lower endpoint
+    } else {
+      x_right = middle # new upper endpoint
+    }
+    
+    n = n + 1 # increase step counter
+  }
+  print("Maximum number of steps exceeded!") # method failed
+}
+
+
+print(abs(bisection(1.0, 2.0, 1e-3) - 1.84668) < EPSILON) # returns TRUE
+print(abs(bisection(100.0, 250.0, 1e-3) - 249.9994) < EPSILON) # returns TRUE
diff --git a/Desktop/open-source/R/mathematics/catalan_numbers.r b/Desktop/open-source/R/mathematics/catalan_numbers.r
new file mode 100644
index 00000000..c9e44a27
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/catalan_numbers.r
@@ -0,0 +1,110 @@
+# Catalan Numbers Implementation in R
+#
+# Catalan numbers form a sequence of natural numbers that occur in various counting problems.
+# The nth Catalan number is given by the formula: C(n) = (2n)! / ((n+1)! * n!)
+# They appear in problems like counting binary trees, valid parentheses combinations,
+# paths in a grid, and polygon triangulations.
+#
+# Time Complexity: O(n) for iterative approach, O(n^2) for recursive with memoization
+# Space Complexity: O(n) for memoization table
+
+# Function to calculate nth Catalan number using dynamic programming
+# @param n: Non-negative integer for which to calculate Catalan number
+# @return: The nth Catalan number
+catalan_dp <- function(n) {
+    # Base cases
+    if (n <= 1) {
+        return(1)
+    }
+    
+    # Initialize dp table
+    catalan <- numeric(n + 1)
+    catalan[1] <- 1  # C(0) = 1
+    catalan[2] <- 1  # C(1) = 1
+    
+    # Fill the table using the recurrence relation:
+    # C(n) = sum(C(i) * C(n-1-i)) for i from 0 to n-1
+    for (i in 2:n) {
+        catalan[i + 1] <- 0
+        for (j in 0:(i - 1)) {
+            catalan[i + 1] <- catalan[i + 1] + catalan[j + 1] * catalan[i - j]
+        }
+    }
+    
+    return(catalan[n + 1])
+}
+
+# Function to calculate nth Catalan number using direct formula
+# @param n: Non-negative integer for which to calculate Catalan number
+# @return: The nth Catalan number
+catalan_formula <- function(n) {
+    if (n <= 1) {
+        return(1)
+    }
+    
+    # Use the formula: C(n) = (2n)! / ((n+1)! * n!)
+    # Simplified to: C(n) = (2n choose n) / (n+1)
+    result <- 1
+    
+    # Calculate using the iterative formula to avoid large factorials
+    for (i in 0:(n - 1)) {
+        result <- result * (n + i + 1) / (i + 1)
+    }
+    
+    return(result / (n + 1))
+}
+
+# Function to generate first n Catalan numbers
+# @param n: Number of Catalan numbers to generate
+# @return: Vector containing first n Catalan numbers
+first_n_catalan <- function(n) {
+    if (n <= 0) {
+        return(numeric(0))
+    }
+    
+    result <- numeric(n)
+    
+    for (i in 1:n) {
+        result[i] <- catalan_dp(i - 1)  # Generate C(0) to C(n-1)
+    }
+    
+    return(result)
+}
+
+# Function to find applications of Catalan numbers
+# @param n: The index for which to show applications
+# @return: List of interpretations of the nth Catalan number
+catalan_applications <- function(n) {
+    cat_n <- catalan_dp(n)
+    
+    applications <- list(
+        value = cat_n,
+        interpretations = c(
+            paste("Number of ways to arrange", n, "pairs of parentheses"),
+            paste("Number of full binary trees with", n + 1, "leaves"),
+            paste("Number of ways to triangulate a convex polygon with", n + 2, "vertices"),
+            paste("Number of monotonic lattice paths from (0,0) to (n,n) not crossing y=x"),
+            paste("Number of ways to arrange", n, "non-attacking rooks on a triangular board")
+        )
+    )
+    
+    return(applications)
+}
+
+# Example usage:
+# # Calculate specific Catalan numbers
+# print(paste("5th Catalan number (DP):", catalan_dp(5)))
+# print(paste("5th Catalan number (Formula):", catalan_formula(5)))
+# 
+# # Generate first 10 Catalan numbers
+# first_10 <- first_n_catalan(10)
+# print("First 10 Catalan numbers:")
+# print(first_10)
+# 
+# # Show applications of 4th Catalan number
+# apps <- catalan_applications(4)
+# print(paste("C(4) =", apps$value))
+# print("Applications:")
+# for (app in apps$interpretations) {
+#     print(app)
+# }
\ No newline at end of file
diff --git a/Desktop/open-source/R/mathematics/euclidean_distance.r b/Desktop/open-source/R/mathematics/euclidean_distance.r
new file mode 100644
index 00000000..08af7ce2
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/euclidean_distance.r
@@ -0,0 +1,8 @@
+euclideanDistance <- function(x, y) {
+    return(sqrt(sum((x - y)^2)))
+}
+
+set.seed(1)
+x <- rnorm(1000)
+y <- runif(1000)
+print(euclideanDistance(x, y))
\ No newline at end of file
diff --git a/Desktop/open-source/R/mathematics/extended_euclidean_algorithm.r b/Desktop/open-source/R/mathematics/extended_euclidean_algorithm.r
new file mode 100644
index 00000000..0594abeb
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/extended_euclidean_algorithm.r
@@ -0,0 +1,282 @@
+# Extended Euclidean Algorithm
+#
+# The Extended Euclidean Algorithm not only finds the Greatest Common Divisor (GCD)
+# of two integers a and b, but also finds integers x and y such that:
+# ax + by = gcd(a, b) (Bézout's identity)
+#
+# This is particularly useful in modular arithmetic, RSA cryptography, and 
+# finding modular multiplicative inverses.
+#
+# Time Complexity: O(log(min(a, b)))
+# Space Complexity: O(log(min(a, b))) due to recursion, O(1) for iterative version
+#
+# Input: Two integers a and b
+# Output: A list containing gcd, and coefficients x, y such that ax + by = gcd(a, b)
+
+# Recursive implementation of Extended Euclidean Algorithm
+extended_gcd_recursive <- function(a, b) {
+  # Base case
+  if (b == 0) {
+    return(list(
+      gcd = abs(a),
+      x = sign(a),  # Coefficient for a
+      y = 0         # Coefficient for b
+    ))
+  }
+  
+  # Recursive call
+  result <- extended_gcd_recursive(b, a %% b)
+  
+  # Update coefficients using the relation:
+  # gcd(a, b) = gcd(b, a mod b)
+  # If gcd(b, a mod b) = x1*b + y1*(a mod b)
+  # Then gcd(a, b) = y1*a + (x1 - floor(a/b)*y1)*b
+  x <- result$y
+  y <- result$x - (a %/% b) * result$y
+  
+  return(list(
+    gcd = result$gcd,
+    x = x,
+    y = y
+  ))
+}
+
+# Iterative implementation of Extended Euclidean Algorithm
+extended_gcd_iterative <- function(a, b) {
+  # Store original values for final adjustment
+  orig_a <- a
+  orig_b <- b
+  
+  # Initialize coefficients
+  old_x <- 1; x <- 0
+  old_y <- 0; y <- 1
+  
+  while (b != 0) {
+    quotient <- a %/% b
+    
+    # Update a and b
+    temp <- b
+    b <- a %% b
+    a <- temp
+    
+    # Update x coefficients
+    temp <- x
+    x <- old_x - quotient * x
+    old_x <- temp
+    
+    # Update y coefficients
+    temp <- y
+    y <- old_y - quotient * y
+    old_y <- temp
+  }
+  
+  # Adjust signs based on original inputs
+  if (orig_a < 0) {
+    a <- -a
+    old_x <- -old_x
+  }
+  if (orig_b < 0) {
+    old_y <- -old_y
+  }
+  
+  return(list(
+    gcd = abs(a),
+    x = old_x,
+    y = old_y
+  ))
+}
+
+# Function to find modular multiplicative inverse
+modular_inverse <- function(a, m) {
+  #' Find modular multiplicative inverse of a modulo m
+  #' Returns x such that (a * x) ≡ 1 (mod m)
+  #' Only exists if gcd(a, m) = 1
+  
+  result <- extended_gcd_iterative(a, m)
+  
+  if (result$gcd != 1) {
+    return(NULL)  # Inverse doesn't exist
+  }
+  
+  # Make sure the result is positive
+  inverse <- result$x %% m
+  if (inverse < 0) {
+    inverse <- inverse + m
+  }
+  
+  return(inverse)
+}
+
+# Function to solve linear Diophantine equation ax + by = c
+solve_diophantine <- function(a, b, c) {
+  #' Solve the linear Diophantine equation ax + by = c
+  #' Returns NULL if no integer solutions exist
+  #' Returns one particular solution and the general solution pattern
+  
+  result <- extended_gcd_iterative(a, b)
+  gcd_ab <- result$gcd
+  
+  # Check if solution exists
+  if (c %% gcd_ab != 0) {
+    return(NULL)  # No integer solutions exist
+  }
+  
+  # Scale the coefficients
+  scale <- c / gcd_ab
+  x0 <- result$x * scale
+  y0 <- result$y * scale
+  
+  return(list(
+    particular_solution = list(x = x0, y = y0),
+    general_solution = list(
+      x_formula = paste0(x0, " + ", b/gcd_ab, "*t"),
+      y_formula = paste0(y0, " - ", a/gcd_ab, "*t"),
+      description = "where t is any integer"
+    ),
+    verification = a * x0 + b * y0 == c
+  ))
+}
+
+# Function to find all solutions in a given range
+find_diophantine_solutions_in_range <- function(a, b, c, x_min, x_max, y_min, y_max) {
+  #' Find all integer solutions to ax + by = c in the given ranges
+  
+  dioph_result <- solve_diophantine(a, b, c)
+  if (is.null(dioph_result)) {
+    return(NULL)
+  }
+  
+  x0 <- dioph_result$particular_solution$x
+  y0 <- dioph_result$particular_solution$y
+  gcd_ab <- extended_gcd_iterative(a, b)$gcd
+  
+  b_coeff <- b / gcd_ab
+  a_coeff <- a / gcd_ab
+  
+  # Find range of t values
+  t_min_x <- ceiling((x_min - x0) / b_coeff)
+  t_max_x <- floor((x_max - x0) / b_coeff)
+  t_min_y <- ceiling((y0 - y_max) / a_coeff)
+  t_max_y <- floor((y0 - y_min) / a_coeff)
+  
+  t_min <- max(t_min_x, t_min_y)
+  t_max <- min(t_max_x, t_max_y)
+  
+  if (t_min > t_max) {
+    return(data.frame(x = integer(0), y = integer(0), t = integer(0)))
+  }
+  
+  # Generate solutions
+  t_values <- t_min:t_max
+  x_values <- x0 + b_coeff * t_values
+  y_values <- y0 - a_coeff * t_values
+  
+  return(data.frame(x = x_values, y = y_values, t = t_values))
+}
+
+# Example usage and testing
+cat("=== Extended Euclidean Algorithm ===\n")
+
+# Test basic extended GCD
+cat("Testing Extended GCD with a=240, b=46:\n")
+result1 <- extended_gcd_iterative(240, 46)
+cat("GCD:", result1$gcd, "\n")
+cat("Coefficients: x =", result1$x, ", y =", result1$y, "\n")
+cat("Verification:", 240 * result1$x + 46 * result1$y, "= GCD:", result1$gcd, "\n")
+cat("Check:", 240 * result1$x + 46 * result1$y == result1$gcd, "\n\n")
+
+# Compare recursive and iterative methods
+cat("Comparing recursive vs iterative methods:\n")
+result_rec <- extended_gcd_recursive(240, 46)
+result_iter <- extended_gcd_iterative(240, 46)
+cat("Recursive - GCD:", result_rec$gcd, ", x:", result_rec$x, ", y:", result_rec$y, "\n")
+cat("Iterative - GCD:", result_iter$gcd, ", x:", result_iter$x, ", y:", result_iter$y, "\n")
+cat("Results match:", 
+    result_rec$gcd == result_iter$gcd && 
+    result_rec$x == result_iter$x && 
+    result_rec$y == result_iter$y, "\n\n")
+
+# Test modular multiplicative inverse
+cat("=== Modular Multiplicative Inverse ===\n")
+cat("Finding inverse of 7 modulo 26:\n")
+inv <- modular_inverse(7, 26)
+if (!is.null(inv)) {
+  cat("7^(-1) ≡", inv, "(mod 26)\n")
+  cat("Verification: 7 *", inv, "≡", (7 * inv) %% 26, "(mod 26)\n")
+} else {
+  cat("Inverse does not exist\n")
+}
+
+# Test case where inverse doesn't exist
+cat("\nTesting case where inverse doesn't exist (a=6, m=9):\n")
+inv2 <- modular_inverse(6, 9)
+if (is.null(inv2)) {
+  cat("Inverse does not exist (as expected, since gcd(6,9) = 3 ≠ 1)\n")
+}
+
+# Test solving Diophantine equations
+cat("\n=== Linear Diophantine Equations ===\n")
+cat("Solving 25x + 9y = 7:\n")
+dioph1 <- solve_diophantine(25, 9, 7)
+if (!is.null(dioph1)) {
+  cat("Particular solution: x =", dioph1$particular_solution$x, 
+      ", y =", dioph1$particular_solution$y, "\n")
+  cat("General solution:\n")
+  cat("  x =", dioph1$general_solution$x_formula, "\n")
+  cat("  y =", dioph1$general_solution$y_formula, "\n")
+  cat("  ", dioph1$general_solution$description, "\n")
+  cat("Verification:", dioph1$verification, "\n")
+} else {
+  cat("No integer solutions exist\n")
+}
+
+# Test equation with no solutions
+cat("\nSolving 6x + 9y = 10 (should have no integer solutions):\n")
+dioph2 <- solve_diophantine(6, 9, 10)
+if (is.null(dioph2)) {
+  cat("No integer solutions exist (as expected, since gcd(6,9)=3 does not divide 10)\n")
+}
+
+# Find solutions in a specific range
+cat("\n=== Solutions in Range ===\n")
+cat("Finding solutions to 25x + 9y = 7 where -10 ≤ x ≤ 10 and -10 ≤ y ≤ 10:\n")
+range_solutions <- find_diophantine_solutions_in_range(25, 9, 7, -10, 10, -10, 10)
+if (!is.null(range_solutions) && nrow(range_solutions) > 0) {
+  print(range_solutions)
+  
+  # Verify solutions
+  cat("Verification of solutions:\n")
+  for (i in 1:nrow(range_solutions)) {
+    x <- range_solutions$x[i]
+    y <- range_solutions$y[i]
+    result_check <- 25 * x + 9 * y
+    cat("25 *", x, "+ 9 *", y, "=", result_check, 
+        "(", if(result_check == 7) "✓" else "✗", ")\n")
+  }
+} else {
+  cat("No solutions found in the specified range\n")
+}
+
+# Applications example
+cat("\n=== Practical Applications ===\n")
+cat("Example: Making change with 3-cent and 5-cent coins\n")
+cat("Problem: Can we make exactly 14 cents? Find all ways.\n")
+change_problem <- solve_diophantine(3, 5, 14)
+if (!is.null(change_problem)) {
+  cat("Yes! Particular solution:", 
+      change_problem$particular_solution$x, "three-cent coins and",
+      change_problem$particular_solution$y, "five-cent coins\n")
+  
+  # Find all non-negative solutions
+  solutions_range <- find_diophantine_solutions_in_range(3, 5, 14, 0, 10, 0, 10)
+  if (nrow(solutions_range) > 0) {
+    cat("All valid ways to make 14 cents:\n")
+    for (i in 1:nrow(solutions_range)) {
+      x <- solutions_range$x[i]
+      y <- solutions_range$y[i]
+      if (x >= 0 && y >= 0) {
+        cat(x, "× 3¢ +", y, "× 5¢ = 14¢\n")
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/mathematics/factorial.r b/Desktop/open-source/R/mathematics/factorial.r
new file mode 100644
index 00000000..409999c5
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/factorial.r
@@ -0,0 +1,12 @@
+Fact <- function(n){
+  if(n < 0){
+    stop("Error: your input is wrong!")
+  } else if(n == 0){
+    return(1)
+  } else {
+    return(prod(1:n))
+  }
+}
+
+Fact(5)
+Fact(6)
diff --git a/Desktop/open-source/R/mathematics/fibonacci.r b/Desktop/open-source/R/mathematics/fibonacci.r
new file mode 100644
index 00000000..6dfdbf21
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/fibonacci.r
@@ -0,0 +1,14 @@
+Fibonacci <- function(n)
+{
+  if(n == 1|n == 2)
+  {
+    return(1)
+  }
+  else
+  {
+    return(Fibonacci(n-1) + Fibonacci(n - 2))
+  }
+}
+
+Fibonacci(1)
+Fibonacci(11)
diff --git a/Desktop/open-source/R/mathematics/first_n_fibonacci.r b/Desktop/open-source/R/mathematics/first_n_fibonacci.r
new file mode 100644
index 00000000..b1137781
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/first_n_fibonacci.r
@@ -0,0 +1,25 @@
+
+First_n_Fibonacci <- function(n)
+{
+  # creating empty array of size n
+  Fibonacci <- numeric(n)
+  
+  # assigning first 2 fibonacci values
+  Fibonacci[1] <- 0
+  Fibonacci[2] <- 1
+  
+  # finding the remaining fibonacci numbers using a for loop ranging from 3 to n
+  for (i in 3:n) 
+  {
+    Fibonacci[i] <- Fibonacci[i - 2] + Fibonacci[i - 1]
+  }  
+  
+  # printing the result
+  print(Fibonacci)
+}
+
+First_n_Fibonacci(10) #returns 0 1 1 2 3 5 8 13 21 34
+First_n_Fibonacci(15) #returns 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 
+
+
+
diff --git a/Desktop/open-source/R/mathematics/greatest_common_divisor.r b/Desktop/open-source/R/mathematics/greatest_common_divisor.r
new file mode 100644
index 00000000..9c2b94c1
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/greatest_common_divisor.r
@@ -0,0 +1,24 @@
+# GCD Calculation using Euclidean Algorithm
+find_gcd <- function(a, b) {
+  
+  #' @description Computes the Greatest Common Divisor (GCD) of two integers.
+  #' @param a Integer
+  #' @param b Integer
+  #' @usage find_gcd(a, b)
+  #' @details This function uses the Euclidean algorithm to find the GCD.
+  #' GCD is essential in various mathematical contexts, particularly in
+  #' simplification of fractions and number theory applications.
+  #' @references https://en.wikipedia.org/wiki/Euclidean_algorithm
+  
+  while (b != 0) {
+    temp <- b
+    b <- a %% b
+    a <- temp
+  }
+  
+  return(abs(a))
+}
+
+# Examples
+print(find_gcd(48, 18))  # expected 6
+print(find_gcd(54, 24))  # expected 6
diff --git a/Desktop/open-source/R/mathematics/josephus_problem.r b/Desktop/open-source/R/mathematics/josephus_problem.r
new file mode 100644
index 00000000..7bbfad50
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/josephus_problem.r
@@ -0,0 +1,27 @@
+find_winner <- function(n, k) {
+
+  #' @description Finds the winner in the Josephus problem
+  #' @param n The number of people in the initial circle
+  #' @param k The count of each step
+  #' @usage find_winner(n, k)
+  #' @details In computer science and mathematics, the Josephus problem
+  #' (or Josephus permutation) is a theoretical problem related to a certain
+  #' counting-out game. Such games are used to pick out a person from a group.
+  #' @references https://en.wikipedia.org/wiki/Josephus_problem
+
+  if (k > n) stop("Size of the group must be greater than step")
+
+  winner <- 0
+
+  for (i in 1:n) {
+     winner <- (winner + k) %% i
+  }
+
+  return(winner + 1)
+}
+
+result <- find_winner(11, 2)
+print(result)  # expected 7
+
+result <- find_winner(5, 2)
+print(result)  # expected 3
\ No newline at end of file
diff --git a/Desktop/open-source/R/mathematics/least_common_multiple.r b/Desktop/open-source/R/mathematics/least_common_multiple.r
new file mode 100644
index 00000000..d440f29c
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/least_common_multiple.r
@@ -0,0 +1,27 @@
+# LCM Calculation
+find_lcm <- function(a, b) {
+  
+  #' @description Computes the Least Common Multiple (LCM) of two integers.
+  #' @param a Integer
+  #' @param b Integer
+  #' @usage find_lcm(a, b)
+  #' @details This function uses the relationship between GCD and LCM,
+  #' i.e., LCM(a, b) = |a * b| / GCD(a, b).
+  #' LCM is useful in fraction operations and periodicity calculations.
+  #' @references https://en.wikipedia.org/wiki/Least_common_multiple
+  
+  gcd <- function(x, y) {
+    while (y != 0) {
+      temp <- y
+      y <- x %% y
+      x <- temp
+    }
+    return(abs(x))
+  }
+  
+  return(abs(a * b) / gcd(a, b))
+}
+
+# Examples
+print(find_lcm(48, 18))  # expected 144
+print(find_lcm(54, 24))  # expected 216
diff --git a/Desktop/open-source/R/mathematics/modular_exponentiation.r b/Desktop/open-source/R/mathematics/modular_exponentiation.r
new file mode 100644
index 00000000..49a0a417
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/modular_exponentiation.r
@@ -0,0 +1,70 @@
+#' Computes modular exponentiation using fast binary exponentiation.
+#'
+#' @param base Numeric or integer base.
+#' @param exp Non-negative integer exponent.
+#' @param mod Optional positive integer modulus. If `NULL`, computes
+#'   \eqn{base^{exp}} without modulus (may overflow for large values).
+#'
+#' @return If `mod` is provided, returns an integer in \[0, mod - 1\] equal to
+#'   \eqn{(base^{exp}) \bmod mod}. If `mod` is `NULL`, returns \eqn{base^{exp}}.
+#'
+#' @details
+#' Implements **binary (fast) exponentiation** running in \eqn{O(\log exp)} time
+#' and \eqn{O(1)} extra space.
+#' - When `mod` is provided, intermediate values are reduced modulo `mod` to
+#'   avoid overflow and keep numbers bounded.
+#' - Negative bases are handled correctly in modular mode by normalizing
+#'   \code{base <- (base \%\% mod + mod) \%\% mod}.
+#' - Negative exponents are **not supported** (would require modular inverse).
+#'
+#' @examples
+#' # 2^10 = 1024, and 1024 mod 1000 = 24
+#' modular_exponentiation(2, 10, 1000)
+#' # [1] 24
+#' modular_exponentiation(3, 0, 7)       # 1
+#' modular_exponentiation(5, 3)          # 125 (no modulus)
+#' modular_exponentiation(-2, 5, 13)     # 6  because (-2)^5 = -32 ≡ 6 (mod 13)
+#'
+#' @seealso \code{\link[base]{%%}} for modulus operator.
+#'
+#' @export
+modular_exponentiation <- function(base, exp, mod = NULL) {
+  # validate exponent
+  if (length(exp) != 1 || is.na(exp) || exp < 0 || exp != as.integer(exp)) {
+    stop("`exp` must be a single non-negative integer.")
+  }
+  exp <- as.integer(exp)
+
+  # no modulus: compute power with fast exponentiation (may overflow for large numbers)
+  if (is.null(mod)) {
+    result <- 1
+    b <- base
+    e <- exp
+    while (e > 0) {
+      if (e %% 2L == 1L) result <- result * b
+      b <- b * b
+      e <- e %/% 2L
+    }
+    return(result)
+  }
+
+  # validate modulus
+  if (length(mod) != 1 || is.na(mod) || mod <= 0 || mod != as.integer(mod)) {
+    stop("`mod` must be a single positive integer when provided.")
+  }
+  mod <- as.integer(mod)
+
+  # normalize base into [0, mod-1]
+  b <- ((base %% mod) + mod) %% mod
+  result <- 1L
+  e <- exp
+
+  while (e > 0L) {
+    if (e %% 2L == 1L) {
+      result <- (result * b) %% mod
+    }
+    b <- (b * b) %% mod
+    e <- e %/% 2L
+  }
+  result
+}
diff --git a/Desktop/open-source/R/mathematics/newton_raphson_method.r b/Desktop/open-source/R/mathematics/newton_raphson_method.r
new file mode 100644
index 00000000..4a226aa8
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/newton_raphson_method.r
@@ -0,0 +1,16 @@
+newton_raphson <- function(f, fprime, x0, tol = 1e-6, max_iter = 100) {
+  x <- x0
+  for (i in 1:max_iter) {
+    deriv <- fprime(x)
+    if (abs(deriv) < .Machine$double.eps) {
+      warning("Derivative is zero. Newton-Raphson method fails.")
+      return(NA)
+    }
+    x_new <- x - f(x) / deriv
+   if (abs(x_new - x) < tol) {
+     return(x_new)
+   }
+   x <- x_new
+ }
+  return(x)
+}
diff --git a/Desktop/open-source/R/mathematics/perfect_number.r b/Desktop/open-source/R/mathematics/perfect_number.r
new file mode 100644
index 00000000..3b52e506
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/perfect_number.r
@@ -0,0 +1,39 @@
+is_perfect_number <- function(n) {
+
+  #' @description Checks if number passed as a parameter is a perfect number.
+  #' @param n number to check
+  #' @usage is_perfect_number(n)
+  #' @details In number theory, a perfect number is a positive integer that
+  #' is equal to the sum of its positive divisors, excluding the number itself.
+  #' For instance, 6 has divisors 1, 2 and 3 (excluding itself)
+  #' and 1 + 2 + 3 = 6, so 6 is a perfect number.
+  #' @references https://en.wikipedia.org/wiki/Perfect_number
+
+  if (n < 0) stop("Parameter n must have positive value")
+
+  sum_of_divisors <- 0
+  limit <- n - 1
+
+  for (i in 1:limit) {
+     if (n %% i == 0) {
+        sum_of_divisors <- sum_of_divisors + i
+     }
+  }
+
+  return(sum_of_divisors == n)
+}
+
+result <- is_perfect_number(4)
+print(result)  # expected false
+
+result <- is_perfect_number(5)
+print(result)  # expected false
+
+result <- is_perfect_number(6)
+print(result)  # expected true
+
+result <- is_perfect_number(7)
+print(result)  # expected false
+
+result <- is_perfect_number(28)
+print(result)  # expected true
\ No newline at end of file
diff --git a/Desktop/open-source/R/mathematics/perfect_square.r b/Desktop/open-source/R/mathematics/perfect_square.r
new file mode 100644
index 00000000..cbdd3772
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/perfect_square.r
@@ -0,0 +1,7 @@
+perfectSquare <- function(x){
+    return(floor(sqrt(x)) == sqrt(x))
+}
+
+set.seed(1)
+inputs <- sample(1:100, 10)
+perfectSquare(inputs)
\ No newline at end of file
diff --git a/Desktop/open-source/R/mathematics/permutation_calculation.r b/Desktop/open-source/R/mathematics/permutation_calculation.r
new file mode 100644
index 00000000..c59b7684
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/permutation_calculation.r
@@ -0,0 +1,21 @@
+# Permutation Calculation
+calculate_permutations <- function(n, r) {
+  
+  #' @description Calculates the number of permutations of n objects taken r at a time.
+  #' @param n Total number of objects
+  #' @param r Number of objects in each arrangement
+  #' @usage calculate_permutations(n, r)
+  #' @details Permutations represent the number of ways to arrange r objects from n.
+  #' It is calculated as n! / (n - r)! and is widely used in combinatorics.
+  #' @references https://en.wikipedia.org/wiki/Permutation
+  
+  if (r > n) stop("r must be less than or equal to n")
+  
+  factorial <- function(x) if (x == 0) 1 else prod(1:x)
+  
+  return(factorial(n) / factorial(n - r))
+}
+
+# Example
+print(calculate_permutations(5, 3))  # expected 60
+print(calculate_permutations(10, 2)) # expected 90
diff --git a/Desktop/open-source/R/mathematics/pi_monte_carlo.r b/Desktop/open-source/R/mathematics/pi_monte_carlo.r
new file mode 100644
index 00000000..fd3382f1
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/pi_monte_carlo.r
@@ -0,0 +1,10 @@
+estimatePi <- function(numSims){
+    x <- runif(numSims)
+    y <- runif(numSims)
+    inUnitCircle <- as.integer(x^2 + y^2 <= 1)
+    return(4 * sum(inUnitCircle) / numSims)
+}
+
+set.seed(1)
+estimatePi(3000)
+estimatePi(30000)
diff --git a/Desktop/open-source/R/mathematics/prime.r b/Desktop/open-source/R/mathematics/prime.r
new file mode 100644
index 00000000..7e49a256
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/prime.r
@@ -0,0 +1,17 @@
+# Prime Number Checking in R
+isPrime <- function(number) {
+  (number == 2L || number == 3L) && return(TRUE)
+  (number %% 2L == 0L || number %% 3L == 0L) && return(FALSE)
+  s <- sqrt(number)
+  k <- 1L
+  while (6L * k - 1L <= s) {
+    if (number %% (6L * k + 1L) == 0L || number %% (6L * k - 1L) == 0L)
+      return(FALSE)
+    k <- k + 1L
+  }
+  TRUE
+}
+
+isPrime(2)
+isPrime(5)
+isPrime(4)
diff --git a/Desktop/open-source/R/mathematics/sieve_of_eratosthenes.r b/Desktop/open-source/R/mathematics/sieve_of_eratosthenes.r
new file mode 100644
index 00000000..14c50d4c
--- /dev/null
+++ b/Desktop/open-source/R/mathematics/sieve_of_eratosthenes.r
@@ -0,0 +1,212 @@
+# Sieve of Eratosthenes Algorithm
+#
+# The Sieve of Eratosthenes is an ancient algorithm for finding all prime numbers
+# up to a given limit. It works by iteratively marking the multiples of each prime
+# starting from 2, and the unmarked numbers that remain are primes.
+#
+# Time Complexity: O(n log log n)
+# Space Complexity: O(n)
+#
+# Input: A positive integer n (the upper limit)
+# Output: A vector of all prime numbers from 2 to n
+
+sieve_of_eratosthenes <- function(n) {
+  # Handle edge cases
+  if (n < 2) {
+    return(integer(0))  # No primes less than 2
+  }
+  
+  # Create a boolean array "prime[0..n]" and initialize all entries as TRUE
+  prime <- rep(TRUE, n + 1)
+  prime[1] <- FALSE  # 1 is not a prime number
+  
+  p <- 2
+  while (p * p <= n) {
+    # If prime[p] is not changed, then it is a prime
+    if (prime[p]) {
+      # Update all multiples of p starting from p^2
+      for (i in seq(p * p, n, by = p)) {
+        prime[i] <- FALSE
+      }
+    }
+    p <- p + 1
+  }
+  
+  # Collect all prime numbers
+  primes <- which(prime)[-1]  # Remove index 1 (since 1 is not prime)
+  return(primes)
+}
+
+# Optimized version that only checks odd numbers after 2
+sieve_of_eratosthenes_optimized <- function(n) {
+  # Handle edge cases
+  if (n < 2) {
+    return(integer(0))
+  }
+  if (n == 2) {
+    return(2)
+  }
+  
+  # Start with 2 (the only even prime)
+  primes <- c(2)
+  
+  # Create boolean array for odd numbers only (3, 5, 7, ...)
+  # Index i represents number (2*i + 3)
+  size <- (n - 1) %/% 2
+  is_prime <- rep(TRUE, size)
+  
+  # Sieve process for odd numbers
+  for (i in 1:size) {
+    if (is_prime[i]) {
+      num <- 2 * i + 1  # Convert index to actual odd number
+      
+      # Mark multiples of num starting from num^2
+      if (num * num <= n) {
+        start_idx <- (num * num - 1) %/% 2  # Convert num^2 to index
+        for (j in seq(start_idx, size, by = num)) {
+          if (j <= size) {
+            is_prime[j] <- FALSE
+          }
+        }
+      }
+    }
+  }
+  
+  # Collect odd primes
+  odd_primes <- 2 * which(is_prime) + 1
+  primes <- c(primes, odd_primes)
+  
+  return(primes)
+}
+
+# Function to count primes up to n (useful for large n)
+count_primes_sieve <- function(n) {
+  if (n < 2) {
+    return(0)
+  }
+  
+  prime <- rep(TRUE, n + 1)
+  prime[1] <- FALSE
+  
+  p <- 2
+  while (p * p <= n) {
+    if (prime[p]) {
+      for (i in seq(p * p, n, by = p)) {
+        prime[i] <- FALSE
+      }
+    }
+    p <- p + 1
+  }
+  
+  return(sum(prime))
+}
+
+# Function to check if a number is prime using trial division (for comparison)
+is_prime_trial_division <- function(n) {
+  if (n <= 1) return(FALSE)
+  if (n <= 3) return(TRUE)
+  if (n %% 2 == 0 || n %% 3 == 0) return(FALSE)
+  
+  i <- 5
+  while (i * i <= n) {
+    if (n %% i == 0 || n %% (i + 2) == 0) {
+      return(FALSE)
+    }
+    i <- i + 6
+  }
+  return(TRUE)
+}
+
+# Segmented sieve for finding primes in a range [low, high]
+segmented_sieve <- function(low, high) {
+  # First, find all primes up to sqrt(high)
+  limit <- floor(sqrt(high))
+  primes <- sieve_of_eratosthenes(limit)
+  
+  # Create a boolean array for range [low, high]
+  size <- high - low + 1
+  is_prime <- rep(TRUE, size)
+  
+  # Mark multiples of each prime in the range
+  for (prime in primes) {
+    # Find the minimum number in [low, high] that is a multiple of prime
+    start <- max(prime * prime, low + (prime - low %% prime) %% prime)
+    
+    # Mark multiples of prime in the range
+    for (j in seq(start, high, by = prime)) {
+      is_prime[j - low + 1] <- FALSE
+    }
+  }
+  
+  # Handle the case where low = 1 (1 is not prime)
+  if (low == 1) {
+    is_prime[1] <- FALSE
+  }
+  
+  # Collect primes in the range
+  range_primes <- (low:high)[is_prime]
+  return(range_primes)
+}
+
+# Example usage and testing
+cat("=== Sieve of Eratosthenes Algorithm ===\n")
+
+# Test with small number
+cat("Primes up to 30:\n")
+primes_30 <- sieve_of_eratosthenes(30)
+cat(paste(primes_30, collapse = ", "), "\n")
+cat("Count:", length(primes_30), "\n\n")
+
+# Test optimized version
+cat("Optimized sieve - Primes up to 30:\n")
+primes_30_opt <- sieve_of_eratosthenes_optimized(30)
+cat(paste(primes_30_opt, collapse = ", "), "\n")
+cat("Count:", length(primes_30_opt), "\n\n")
+
+# Test with larger number
+cat("Primes up to 100:\n")
+primes_100 <- sieve_of_eratosthenes(100)
+cat("Count:", length(primes_100), "\n")
+cat("First 10 primes:", paste(primes_100[1:10], collapse = ", "), "\n")
+cat("Last 10 primes:", paste(tail(primes_100, 10), collapse = ", "), "\n\n")
+
+# Performance comparison for counting primes
+cat("=== Performance Comparison ===\n")
+n <- 1000
+
+# Count using sieve
+start_time <- Sys.time()
+sieve_count <- count_primes_sieve(n)
+sieve_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+# Count using trial division
+start_time <- Sys.time()
+trial_count <- sum(sapply(2:n, is_prime_trial_division))
+trial_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("Primes up to", n, ":\n")
+cat("Sieve method:", sieve_count, "primes (", sprintf("%.4f", sieve_time), "seconds )\n")
+cat("Trial division:", trial_count, "primes (", sprintf("%.4f", trial_time), "seconds )\n")
+cat("Speedup:", sprintf("%.2f", trial_time / sieve_time), "x\n\n")
+
+# Test segmented sieve
+cat("=== Segmented Sieve Example ===\n")
+cat("Primes between 50 and 100:\n")
+range_primes <- segmented_sieve(50, 100)
+cat(paste(range_primes, collapse = ", "), "\n")
+cat("Count:", length(range_primes), "\n\n")
+
+# Edge cases
+cat("=== Edge Cases ===\n")
+cat("Primes up to 1:", paste(sieve_of_eratosthenes(1), collapse = ", "), "\n")
+cat("Primes up to 2:", paste(sieve_of_eratosthenes(2), collapse = ", "), "\n")
+cat("Primes up to 3:", paste(sieve_of_eratosthenes(3), collapse = ", "), "\n")
+
+# Large example (uncomment for larger tests)
+# cat("\n=== Large Scale Test ===\n")
+# large_n <- 10000
+# start_time <- Sys.time()
+# large_primes <- sieve_of_eratosthenes(large_n)
+# end_time <- Sys.time()
+# cat("Found", length(large_primes), "primes up to", large_n, "\n")
+# cat("Computation time:", as.numeric(end_time - start_time, units = "secs"), "seconds\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/quantitative_finance/black_scholes_option_pricing.r b/Desktop/open-source/R/quantitative_finance/black_scholes_option_pricing.r
new file mode 100644
index 00000000..4979946c
--- /dev/null
+++ b/Desktop/open-source/R/quantitative_finance/black_scholes_option_pricing.r
@@ -0,0 +1,251 @@
+# Black-Scholes Option Pricing Algorithm in R
+# Implements the Black-Scholes-Merton model for European option pricing
+# Features: Call/Put pricing, Greeks calculation, and implied volatility estimation
+
+library(R6)
+
+#' BlackScholesCalculator Class
+#' @description R6 class for option pricing using Black-Scholes model
+#' @details Calculates option prices and Greeks for European options
+#' Assumptions:
+#' - No dividend payments
+#' - European-style options (can only be exercised at expiration)
+#' - Log-normal distribution of stock prices
+#' - Constant risk-free rate and volatility
+#' - No transaction costs or taxes
+#' - Perfectly divisible securities
+BlackScholesCalculator <- R6Class(
+  "BlackScholesCalculator",
+  
+  public = list(
+    #' @description Initialize calculator with market parameters
+    #' @param r Risk-free interest rate (annualized)
+    #' @param include_checks Whether to perform parameter validation
+    initialize = function(r = 0.05, include_checks = TRUE) {
+      private$risk_free_rate <- r
+      private$validate_params <- include_checks
+      invisible(self)
+    },
+
+    #' @description Calculate call option price
+    #' @param S Current stock price
+    #' @param K Strike price
+    #' @param T Time to expiration (in years)
+    #' @param sigma Volatility (annualized)
+    calculate_call_price = function(S, K, T, sigma) {
+      if (private$validate_params) {
+        private$validate_inputs(S, K, T, sigma)
+      }
+      
+      d1 <- private$calculate_d1(S, K, T, sigma)
+      d2 <- private$calculate_d2(d1, sigma, T)
+      
+      call_price <- S * stats::pnorm(d1) - K * exp(-private$risk_free_rate * T) * stats::pnorm(d2)
+      return(call_price)
+    },
+
+    #' @description Calculate put option price
+    #' @param S Current stock price
+    #' @param K Strike price
+    #' @param T Time to expiration (in years)
+    #' @param sigma Volatility (annualized)
+    calculate_put_price = function(S, K, T, sigma) {
+      if (private$validate_params) {
+        private$validate_inputs(S, K, T, sigma)
+      }
+      
+      d1 <- private$calculate_d1(S, K, T, sigma)
+      d2 <- private$calculate_d2(d1, sigma, T)
+      
+      put_price <- K * exp(-private$risk_free_rate * T) * stats::pnorm(-d2) - S * stats::pnorm(-d1)
+      return(put_price)
+    },
+
+    #' @description Calculate all Greeks for a call option
+    #' @param S Current stock price
+    #' @param K Strike price
+    #' @param T Time to expiration (in years)
+    #' @param sigma Volatility (annualized)
+    calculate_call_greeks = function(S, K, T, sigma) {
+      if (private$validate_params) {
+        private$validate_inputs(S, K, T, sigma)
+      }
+      
+      d1 <- private$calculate_d1(S, K, T, sigma)
+      d2 <- private$calculate_d2(d1, sigma, T)
+      
+      # Calculate Greeks
+      delta <- stats::pnorm(d1)
+      gamma <- stats::dnorm(d1) / (S * sigma * sqrt(T))
+      theta <- (-S * stats::dnorm(d1) * sigma / (2 * sqrt(T)) - 
+                private$risk_free_rate * K * exp(-private$risk_free_rate * T) * stats::pnorm(d2))
+      vega <- S * sqrt(T) * stats::dnorm(d1)
+      rho <- K * T * exp(-private$risk_free_rate * T) * stats::pnorm(d2)
+      
+      return(list(
+        delta = delta,
+        gamma = gamma,
+        theta = theta,
+        vega = vega,
+        rho = rho
+      ))
+    },
+
+    #' @description Calculate all Greeks for a put option
+    #' @param S Current stock price
+    #' @param K Strike price
+    #' @param T Time to expiration (in years)
+    #' @param sigma Volatility (annualized)
+    calculate_put_greeks = function(S, K, T, sigma) {
+      if (private$validate_params) {
+        private$validate_inputs(S, K, T, sigma)
+      }
+      
+      d1 <- private$calculate_d1(S, K, T, sigma)
+      d2 <- private$calculate_d2(d1, sigma, T)
+      
+      # Calculate Greeks
+      delta <- stats::pnorm(d1) - 1
+      gamma <- stats::dnorm(d1) / (S * sigma * sqrt(T))
+      theta <- (-S * stats::dnorm(d1) * sigma / (2 * sqrt(T)) + 
+                private$risk_free_rate * K * exp(-private$risk_free_rate * T) * stats::pnorm(-d2))
+      vega <- S * sqrt(T) * stats::dnorm(d1)
+      rho <- -K * T * exp(-private$risk_free_rate * T) * stats::pnorm(-d2)
+      
+      return(list(
+        delta = delta,
+        gamma = gamma,
+        theta = theta,
+        vega = vega,
+        rho = rho
+      ))
+    },
+
+    #' @description Estimate implied volatility using Newton-Raphson method
+    #' @param market_price Observed market price of the option
+    #' @param S Current stock price
+    #' @param K Strike price
+    #' @param T Time to expiration (in years)
+    #' @param is_call Whether the option is a call (TRUE) or put (FALSE)
+    #' @param tolerance Convergence tolerance
+    #' @param max_iter Maximum iterations
+    estimate_implied_volatility = function(market_price, S, K, T, 
+                                         is_call = TRUE, tolerance = 1e-5, max_iter = 100) {
+      if (private$validate_params) {
+        if (market_price <= 0) stop("Market price must be positive")
+        private$validate_inputs(S, K, T, 0.5)  # Initial volatility check
+      }
+      
+      # Initial guess for volatility
+      sigma <- sqrt(2 * abs(log(S/K) + private$risk_free_rate * T) / T)
+      sigma <- min(max(0.1, sigma), 5)  # Bound initial guess
+      
+      for (i in 1:max_iter) {
+        # Calculate price and vega
+        if (is_call) {
+          price <- self$calculate_call_price(S, K, T, sigma)
+          greeks <- self$calculate_call_greeks(S, K, T, sigma)
+        } else {
+          price <- self$calculate_put_price(S, K, T, sigma)
+          greeks <- self$calculate_put_greeks(S, K, T, sigma)
+        }
+        
+        diff <- price - market_price
+        
+        if (abs(diff) < tolerance) {
+          return(sigma)
+        }
+        
+        # Update volatility estimate using Newton-Raphson
+        sigma <- sigma - diff / greeks$vega
+        
+        # Bound the volatility
+        sigma <- min(max(0.001, sigma), 5)
+      }
+      
+      warning("Implied volatility did not converge")
+      return(sigma)
+    }
+  ),
+  
+  private = list(
+    risk_free_rate = NULL,
+    validate_params = NULL,
+    
+    calculate_d1 = function(S, K, T, sigma) {
+      (log(S/K) + (private$risk_free_rate + sigma^2/2) * T) / (sigma * sqrt(T))
+    },
+    
+    calculate_d2 = function(d1, sigma, T) {
+      d1 - sigma * sqrt(T)
+    },
+    
+    validate_inputs = function(S, K, T, sigma) {
+      if (S <= 0) stop("Stock price must be positive")
+      if (K <= 0) stop("Strike price must be positive")
+      if (T <= 0) stop("Time to expiration must be positive")
+      if (sigma <= 0) stop("Volatility must be positive")
+    }
+  )
+)
+
+# Demonstration
+demonstrate_black_scholes <- function() {
+  cat("=== Black-Scholes Option Pricing Demo ===\n\n")
+  
+  # Initialize calculator
+  bs <- BlackScholesCalculator$new(r = 0.05)
+  
+  # Example parameters
+  S <- 100    # Current stock price
+  K <- 100    # Strike price
+  T <- 1      # One year to expiration
+  sigma <- 0.2 # 20% volatility
+  
+  # Calculate option prices
+  call_price <- bs$calculate_call_price(S, K, T, sigma)
+  put_price <- bs$calculate_put_price(S, K, T, sigma)
+  
+  cat("Parameters:\n")
+  cat(sprintf("Stock Price: $%.2f\n", S))
+  cat(sprintf("Strike Price: $%.2f\n", K))
+  cat(sprintf("Time to Expiration: %.1f years\n", T))
+  cat(sprintf("Volatility: %.1f%%\n", sigma * 100))
+  cat(sprintf("Risk-free Rate: %.1f%%\n\n", bs$risk_free_rate * 100))
+  
+  cat("Option Prices:\n")
+  cat(sprintf("Call Option: $%.2f\n", call_price))
+  cat(sprintf("Put Option: $%.2f\n\n", put_price))
+  
+  # Calculate and display Greeks
+  call_greeks <- bs$calculate_call_greeks(S, K, T, sigma)
+  put_greeks <- bs$calculate_put_greeks(S, K, T, sigma)
+  
+  cat("Call Option Greeks:\n")
+  cat(sprintf("Delta: %.4f\n", call_greeks$delta))
+  cat(sprintf("Gamma: %.4f\n", call_greeks$gamma))
+  cat(sprintf("Theta: %.4f\n", call_greeks$theta))
+  cat(sprintf("Vega: %.4f\n", call_greeks$vega))
+  cat(sprintf("Rho: %.4f\n\n", call_greeks$rho))
+  
+  cat("Put Option Greeks:\n")
+  cat(sprintf("Delta: %.4f\n", put_greeks$delta))
+  cat(sprintf("Gamma: %.4f\n", put_greeks$gamma))
+  cat(sprintf("Theta: %.4f\n", put_greeks$theta))
+  cat(sprintf("Vega: %.4f\n", put_greeks$vega))
+  cat(sprintf("Rho: %.4f\n\n", put_greeks$rho))
+  
+  # Demonstrate implied volatility calculation
+  test_market_price <- call_price * 1.1  # Use 10% higher price for demonstration
+  implied_vol <- bs$estimate_implied_volatility(test_market_price, S, K, T, is_call = TRUE)
+  cat("Implied Volatility Estimation:\n")
+  cat(sprintf("Market Price: $%.2f\n", test_market_price))
+  cat(sprintf("Implied Volatility: %.1f%%\n", implied_vol * 100))
+  
+  cat("\n=== Demo Complete ===\n")
+}
+
+# Run demonstration if not in interactive mode
+if (!interactive()) {
+  demonstrate_black_scholes()
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/quantitative_finance/kalman_filter.r b/Desktop/open-source/R/quantitative_finance/kalman_filter.r
new file mode 100644
index 00000000..409a424d
--- /dev/null
+++ b/Desktop/open-source/R/quantitative_finance/kalman_filter.r
@@ -0,0 +1,32 @@
+library(Metrics)
+set.seed(123)
+num_obs <- 100
+true_returns <- rnorm(num_obs, mean = 0.001, sd = 0.01)
+observed_prices <- cumprod(1 + true_returns) * 100
+noise <- rnorm(num_obs, mean = 0, sd = 0.1)
+noisy_prices <- observed_prices + noise
+# Kalman filter implementation
+kalman_filter <- function(observed_prices) {
+  state <- c(observed_prices[1], 0)
+  P <- matrix(c(1, 0, 0, 1), nrow = 2)
+  Q <- matrix(c(0.0001, 0, 0, 0.0001), nrow = 2)
+  R <- 0.1
+  A <- matrix(c(1, 1, 0, 1), nrow = 2)
+  H <- matrix(c(1, 0), nrow = 1)
+  filtered_states <- matrix(0, nrow = length(observed_prices), ncol = 2)
+  for (i in 1:length(observed_prices)) {
+    state_pred <- A %*% state
+    P_pred <- A %*% P %*% t(A) + Q
+    K <- P_pred %*% t(H) %*% solve(H %*% P_pred %*% t(H) + R)
+    state <- state_pred + K %*% (observed_prices[i] - H %*% state_pred)
+    P <- (matrix(1, nrow = 2, ncol = 2) - K %*% H) %*% P_pred
+    filtered_states[i, ] <- state
+  }
+  return(list(filtered_states = filtered_states, state_pred = state_pred, P_pred = P_pred))
+}
+result <- kalman_filter(noisy_prices)
+plot(observed_prices, type = "l", col = "blue", lwd = 2, main = "Kalman Filter")
+lines(result$filtered_states[, 1], type = "l", col = "red", lwd = 2)
+lines(true_returns, type = "l", col = "green", lwd = 2)
+legend("topright", legend = c("Observed Prices", "Filtered Prices", "True Returns"),
+       col = c("blue", "red", "green"), lty = 1, lwd = 2)
diff --git a/Desktop/open-source/R/quantitative_finance/markowitz_portfolio_optimization.r b/Desktop/open-source/R/quantitative_finance/markowitz_portfolio_optimization.r
new file mode 100644
index 00000000..5e659266
--- /dev/null
+++ b/Desktop/open-source/R/quantitative_finance/markowitz_portfolio_optimization.r
@@ -0,0 +1,28 @@
+# Required libraries
+library(tidyquant)
+library(quadprog)
+# Set a seed for reproducibility
+set.seed(123)
+# Generate random data for three assets
+num_assets <- 3
+num_obs <- 100
+returns <- matrix(rnorm(num_assets * num_obs), ncol = num_assets)
+# Define the objective function for portfolio optimization
+objective_function <- function(weights, cov_matrix) {
+  portfolio_return <- sum(weights * colMeans(returns))
+  portfolio_volatility <- sqrt(t(weights) %*% cov_matrix %*% weights)
+  return(c(portfolio_return, portfolio_volatility))
+}
+cov_matrix <- cov(returns)
+constraints <- matrix(0, nrow = 2, ncol = num_assets)
+constraints[1, ] <- colMeans(returns)
+constraints[2, ] <- 1
+optimal_weights <- solve.QP(Dmat = 2 * cov_matrix,
+                            dvec = rep(0, num_assets),
+                            Amat = t(constraints),
+                            bvec = c(0.05, 1),
+                            meq = 1)$solution
+cat("Optimal Weights:", optimal_weights, "\n")
+optimal_portfolio <- objective_function(optimal_weights, cov_matrix)
+cat("Expected Return:", optimal_portfolio[1], "\n")
+cat("Volatility:", optimal_portfolio[2], "\n")
diff --git a/Desktop/open-source/R/quantitative_finance/monte_carlo_simulation.r b/Desktop/open-source/R/quantitative_finance/monte_carlo_simulation.r
new file mode 100644
index 00000000..c0c3b69d
--- /dev/null
+++ b/Desktop/open-source/R/quantitative_finance/monte_carlo_simulation.r
@@ -0,0 +1,31 @@
+# Required libraries
+library("quantmod")
+# Parameters
+S0 <- 100    # Initial stock price
+K <- 100     # Strike price
+r <- 0.05    # Risk-free rate
+sigma <- 0.2 # Volatility
+T <- 1       # Time to maturity (in years)
+n <- 252     # Number of trading days
+# Function to simulate stock prices using geometric Brownian motion
+simulate_stock_prices <- function(S0, r, sigma, T, n) {
+  dt <- T/n
+  t <- seq(0, T, by = dt)
+  W <- c(0, cumsum(sqrt(dt) * rnorm(n)))
+  S <- S0 * exp((r - 0.5 * sigma^2) * t + sigma * W)
+  return(S)
+}
+# Function to calculate option price using Monte Carlo simulation
+monte_carlo_option_price <- function(S0, K, r, sigma, T, n, num_simulations) {
+  option_prices <- numeric(num_simulations)
+  for (i in 1:num_simulations) {
+    ST <- simulate_stock_prices(S0, r, sigma, T, n)[n + 1] # Final stock price
+    option_prices[i] <- pmax(ST - K, 0) # Payoff of the option
+  }
+  option_price <- mean(option_prices) * exp(-r * T) # Discounted expected payoff
+  return(option_price)
+}
+# Number of Monte Carlo simulations
+num_simulations <- 10000
+option_price <- monte_carlo_option_price(S0, K, r, sigma, T, n, num_simulations)
+cat("Option price:", option_price, "\n")
diff --git a/Desktop/open-source/R/quantitative_finance/risk_metrics.r b/Desktop/open-source/R/quantitative_finance/risk_metrics.r
new file mode 100644
index 00000000..d09b8fc0
--- /dev/null
+++ b/Desktop/open-source/R/quantitative_finance/risk_metrics.r
@@ -0,0 +1,267 @@
+# Value at Risk (VaR) and Expected Shortfall (ES) Calculator
+# Implements multiple VaR calculation methods and Expected Shortfall
+# Features: Historical, Parametric, and Monte Carlo VaR/ES calculations
+
+library(R6)
+
+#' RiskMetrics Class
+#' @description R6 class for calculating Value at Risk and Expected Shortfall
+#' @details Implements multiple methods for VaR and ES calculation:
+#' - Historical simulation (non-parametric)
+#' - Parametric (variance-covariance)
+#' - Monte Carlo simulation
+#' Time complexity varies by method, documented per method
+RiskMetrics <- R6Class(
+  "RiskMetrics",
+  
+  public = list(
+    #' @description Initialize risk calculator
+    #' @param returns Historical returns data
+    #' @param confidence_level Confidence level for VaR/ES (default 0.95)
+    #' @param time_horizon Time horizon in days (default 1)
+    initialize = function(returns = NULL, confidence_level = 0.95, time_horizon = 1) {
+      private$validate_parameters(confidence_level, time_horizon)
+      
+      self$returns <- returns
+      self$confidence_level <- confidence_level
+      self$time_horizon <- time_horizon
+      
+      if (!is.null(returns)) {
+        private$fit_distribution()
+      }
+    },
+    
+    #' @description Calculate Historical VaR
+    #' @param portfolio_value Current portfolio value
+    #' @param method Calculation method ('historical', 'parametric', or 'monte_carlo')
+    #' @param n_simulations Number of simulations for Monte Carlo method
+    calculate_var = function(portfolio_value, method = "historical", n_simulations = 10000) {
+      if (is.null(self$returns)) {
+        stop("No returns data available. Please initialize with returns data.")
+      }
+      
+      method <- match.arg(method, c("historical", "parametric", "monte_carlo"))
+      
+      var_value <- switch(method,
+        "historical" = private$calculate_historical_var(portfolio_value),
+        "parametric" = private$calculate_parametric_var(portfolio_value),
+        "monte_carlo" = private$calculate_monte_carlo_var(portfolio_value, n_simulations)
+      )
+      
+      # Scale VaR to time horizon
+      var_value * sqrt(self$time_horizon)
+    },
+    
+    #' @description Calculate Expected Shortfall (Conditional VaR)
+    #' @param portfolio_value Current portfolio value
+    #' @param method Calculation method ('historical', 'parametric', or 'monte_carlo')
+    #' @param n_simulations Number of simulations for Monte Carlo method
+    calculate_es = function(portfolio_value, method = "historical", n_simulations = 10000) {
+      if (is.null(self$returns)) {
+        stop("No returns data available. Please initialize with returns data.")
+      }
+      
+      method <- match.arg(method, c("historical", "parametric", "monte_carlo"))
+      
+      es_value <- switch(method,
+        "historical" = private$calculate_historical_es(portfolio_value),
+        "parametric" = private$calculate_parametric_es(portfolio_value),
+        "monte_carlo" = private$calculate_monte_carlo_es(portfolio_value, n_simulations)
+      )
+      
+      # Scale ES to time horizon
+      es_value * sqrt(self$time_horizon)
+    },
+    
+    #' @description Generate risk report with multiple metrics
+    #' @param portfolio_value Current portfolio value
+    #' @param include_methods Which methods to include in report
+    generate_risk_report = function(portfolio_value, 
+                                  include_methods = c("historical", "parametric", "monte_carlo")) {
+      results <- list()
+      
+      for (method in include_methods) {
+        results[[method]] <- list(
+          var = self$calculate_var(portfolio_value, method),
+          es = self$calculate_es(portfolio_value, method)
+        )
+      }
+      
+      # Add distribution statistics
+      results$statistics <- list(
+        mean_return = mean(self$returns),
+        volatility = sd(self$returns),
+        skewness = private$calculate_skewness(),
+        kurtosis = private$calculate_kurtosis()
+      )
+      
+      return(results)
+    },
+    
+    #' @description Update returns data and recalculate distribution parameters
+    #' @param new_returns New returns data to use
+    update_returns = function(new_returns) {
+      self$returns <- new_returns
+      private$fit_distribution()
+      invisible(self)
+    },
+    
+    # Public fields
+    returns = NULL,
+    confidence_level = NULL,
+    time_horizon = NULL
+  ),
+  
+  private = list(
+    # Distribution parameters
+    mean_return = NULL,
+    volatility = NULL,
+    
+    #' @description Fit distribution to returns data
+    fit_distribution = function() {
+      private$mean_return <- mean(self$returns)
+      private$volatility <- sd(self$returns)
+    },
+    
+    #' @description Calculate Historical VaR
+    calculate_historical_var = function(portfolio_value) {
+      sorted_returns <- sort(self$returns)
+      index <- floor((1 - self$confidence_level) * length(sorted_returns))
+      -sorted_returns[index] * portfolio_value
+    },
+    
+    #' @description Calculate Parametric VaR
+    calculate_parametric_var = function(portfolio_value) {
+      z_score <- stats::qnorm(self$confidence_level)
+      portfolio_value * (z_score * private$volatility - private$mean_return)
+    },
+    
+    #' @description Calculate Monte Carlo VaR
+    calculate_monte_carlo_var = function(portfolio_value, n_simulations) {
+      simulated_returns <- stats::rnorm(
+        n_simulations, 
+        mean = private$mean_return, 
+        sd = private$volatility
+      )
+      sorted_returns <- sort(simulated_returns)
+      index <- floor((1 - self$confidence_level) * n_simulations)
+      -sorted_returns[index] * portfolio_value
+    },
+    
+    #' @description Calculate Historical Expected Shortfall
+    calculate_historical_es = function(portfolio_value) {
+      sorted_returns <- sort(self$returns)
+      var_index <- floor((1 - self$confidence_level) * length(sorted_returns))
+      tail_returns <- sorted_returns[1:var_index]
+      -mean(tail_returns) * portfolio_value
+    },
+    
+    #' @description Calculate Parametric Expected Shortfall
+    calculate_parametric_es = function(portfolio_value) {
+      z_score <- stats::qnorm(self$confidence_level)
+      phi_z <- stats::dnorm(z_score)
+      lambda <- phi_z / (1 - self$confidence_level)
+      portfolio_value * (lambda * private$volatility - private$mean_return)
+    },
+    
+    #' @description Calculate Monte Carlo Expected Shortfall
+    calculate_monte_carlo_es = function(portfolio_value, n_simulations) {
+      simulated_returns <- stats::rnorm(
+        n_simulations, 
+        mean = private$mean_return, 
+        sd = private$volatility
+      )
+      sorted_returns <- sort(simulated_returns)
+      var_index <- floor((1 - self$confidence_level) * n_simulations)
+      tail_returns <- sorted_returns[1:var_index]
+      -mean(tail_returns) * portfolio_value
+    },
+    
+    #' @description Calculate distribution skewness
+    calculate_skewness = function() {
+      r <- self$returns
+      n <- length(r)
+      m3 <- sum((r - mean(r))^3) / n
+      s3 <- sd(r)^3
+      m3 / s3
+    },
+    
+    #' @description Calculate distribution kurtosis
+    calculate_kurtosis = function() {
+      r <- self$returns
+      n <- length(r)
+      m4 <- sum((r - mean(r))^4) / n
+      s4 <- sd(r)^4
+      m4 / s4 - 3  # Excess kurtosis (normal = 0)
+    },
+    
+    #' @description Validate input parameters
+    validate_parameters = function(confidence_level, time_horizon) {
+      if (confidence_level <= 0 || confidence_level >= 1) {
+        stop("Confidence level must be between 0 and 1")
+      }
+      if (time_horizon <= 0) {
+        stop("Time horizon must be positive")
+      }
+    }
+  )
+)
+
+# Demonstration
+demonstrate_risk_metrics <- function() {
+  cat("=== Value at Risk and Expected Shortfall Demo ===\n\n")
+  
+  # Generate sample returns data
+  set.seed(42)
+  n_days <- 1000
+  returns <- rnorm(n_days, mean = 0.0001, sd = 0.01)
+  
+  # Initialize calculator
+  risk_calc <- RiskMetrics$new(
+    returns = returns,
+    confidence_level = 0.95,
+    time_horizon = 1
+  )
+  
+  # Portfolio parameters
+  portfolio_value <- 1000000  # $1 million portfolio
+  
+  cat("Portfolio Parameters:\n")
+  cat(sprintf("Value: $%d\n", portfolio_value))
+  cat(sprintf("Confidence Level: %.1f%%\n", risk_calc$confidence_level * 100))
+  cat(sprintf("Time Horizon: %d day(s)\n\n", risk_calc$time_horizon))
+  
+  # Calculate VaR using different methods
+  methods <- c("historical", "parametric", "monte_carlo")
+  
+  cat("Value at Risk (VaR) Results:\n")
+  for (method in methods) {
+    var_value <- risk_calc$calculate_var(portfolio_value, method)
+    cat(sprintf("%s VaR: $%.2f\n", tools::toTitleCase(method), var_value))
+  }
+  cat("\n")
+  
+  cat("Expected Shortfall (ES) Results:\n")
+  for (method in methods) {
+    es_value <- risk_calc$calculate_es(portfolio_value, method)
+    cat(sprintf("%s ES: $%.2f\n", tools::toTitleCase(method), es_value))
+  }
+  cat("\n")
+  
+  # Generate and display comprehensive risk report
+  cat("Comprehensive Risk Report:\n")
+  report <- risk_calc$generate_risk_report(portfolio_value)
+  
+  cat("\nDistribution Statistics:\n")
+  cat(sprintf("Mean Return: %.6f\n", report$statistics$mean_return))
+  cat(sprintf("Volatility: %.6f\n", report$statistics$volatility))
+  cat(sprintf("Skewness: %.6f\n", report$statistics$skewness))
+  cat(sprintf("Excess Kurtosis: %.6f\n", report$statistics$kurtosis))
+  
+  cat("\n=== Demo Complete ===\n")
+}
+
+# Run demonstration if not in interactive mode
+if (!interactive()) {
+  demonstrate_risk_metrics()
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/quantitative_finance/time_series_analyzer.r b/Desktop/open-source/R/quantitative_finance/time_series_analyzer.r
new file mode 100644
index 00000000..96a5e01c
--- /dev/null
+++ b/Desktop/open-source/R/quantitative_finance/time_series_analyzer.r
@@ -0,0 +1,524 @@
+# Time Series Analysis and ARIMA Modeling
+# Implements comprehensive time series analysis with ARIMA models
+# Features: Stationarity testing, model selection, forecasting, and diagnostics
+
+library(R6)
+
+#' TimeSeriesAnalyzer Class
+#' @description R6 class for time series analysis and ARIMA modeling
+#' @details Provides functionality for:
+#' - Stationarity testing (ADF test)
+#' - ACF/PACF analysis
+#' - ARIMA model fitting
+#' - Model selection using AIC/BIC
+#' - Forecasting with confidence intervals
+TimeSeriesAnalyzer <- R6Class(
+  "TimeSeriesAnalyzer",
+  
+  public = list(
+    #' @description Initialize analyzer with time series data
+    #' @param data Time series data (numeric vector)
+    #' @param frequency Frequency of the time series (default: 1)
+    initialize = function(data = NULL, frequency = 1) {
+      if (!is.null(data)) {
+        private$validate_input(data)
+        self$data <- data
+        self$frequency <- frequency
+        private$n <- length(data)
+      }
+      invisible(self)
+    },
+
+    #' @description Test for stationarity using Augmented Dickey-Fuller test
+    #' @param max_lags Maximum number of lags to consider
+    test_stationarity = function(max_lags = NULL) {
+      if (is.null(self$data)) {
+        stop("No data available. Please initialize with data first.")
+      }
+      
+      if (is.null(max_lags)) {
+        max_lags <- floor(sqrt(private$n))
+      }
+      
+      # Perform ADF test
+      result <- private$adf_test(max_lags)
+      
+      # Store results
+      private$stationarity_results <- result
+      return(result)
+    },
+
+    #' @description Calculate ACF and PACF
+    #' @param max_lag Maximum lag to consider
+    calculate_acf_pacf = function(max_lag = NULL) {
+      if (is.null(self$data)) {
+        stop("No data available. Please initialize with data first.")
+      }
+      
+      if (is.null(max_lag)) {
+        max_lag <- min(private$n - 1, floor(10 * log10(private$n)))
+      }
+      
+      # Calculate ACF
+      acf_result <- private$calculate_acf(max_lag)
+      
+      # Calculate PACF
+      pacf_result <- private$calculate_pacf(max_lag)
+      
+      return(list(
+        acf = acf_result,
+        pacf = pacf_result,
+        lags = 1:max_lag
+      ))
+    },
+
+    #' @description Fit ARIMA model to the data
+    #' @param p AR order
+    #' @param d Differencing order
+    #' @param q MA order
+    fit_arima = function(p = 1, d = 0, q = 1) {
+      if (is.null(self$data)) {
+        stop("No data available. Please initialize with data first.")
+      }
+      
+      # Validate parameters
+      if (any(c(p, d, q) < 0)) {
+        stop("ARIMA orders must be non-negative")
+      }
+      
+      # Fit ARIMA model
+      model <- private$fit_arima_model(p, d, q)
+      private$current_model <- model
+      
+      return(model)
+    },
+
+    #' @description Automatic model selection using AIC
+    #' @param max_p Maximum AR order to consider
+    #' @param max_d Maximum differencing order
+    #' @param max_q Maximum MA order
+    select_best_model = function(max_p = 3, max_d = 2, max_q = 3) {
+      if (is.null(self$data)) {
+        stop("No data available. Please initialize with data first.")
+      }
+      
+      best_aic <- Inf
+      best_order <- c(0, 0, 0)
+      
+      # Grid search over possible orders
+      for (p in 0:max_p) {
+        for (d in 0:max_d) {
+          for (q in 0:max_q) {
+            tryCatch({
+              model <- self$fit_arima(p, d, q)
+              if (model$aic < best_aic) {
+                best_aic <- model$aic
+                best_order <- c(p, d, q)
+                private$best_model <- model
+              }
+            }, error = function(e) {
+              # Skip failed models
+            })
+          }
+        }
+      }
+      
+      return(list(
+        order = best_order,
+        aic = best_aic
+      ))
+    },
+
+    #' @description Generate forecasts with confidence intervals
+    #' @param h Forecast horizon
+    #' @param level Confidence level (0-1)
+    forecast = function(h = 10, level = 0.95) {
+      if (is.null(private$current_model)) {
+        stop("No model fitted. Please fit a model first.")
+      }
+      
+      # Generate forecasts
+      forecasts <- private$generate_forecasts(h, level)
+      return(forecasts)
+    },
+
+    #' @description Perform model diagnostics
+    diagnose_model = function() {
+      if (is.null(private$current_model)) {
+        stop("No model fitted. Please fit a model first.")
+      }
+      
+      residuals <- private$current_model$residuals
+      
+      # Calculate diagnostic statistics
+      diagnostics <- list(
+        residual_mean = mean(residuals),
+        residual_sd = sd(residuals),
+        ljung_box = private$ljung_box_test(residuals),
+        normality = private$normality_test(residuals),
+        arch_effect = private$arch_test(residuals)
+      )
+      
+      return(diagnostics)
+    },
+
+    # Public fields
+    data = NULL,
+    frequency = NULL
+  ),
+  
+  private = list(
+    n = NULL,
+    current_model = NULL,
+    best_model = NULL,
+    stationarity_results = NULL,
+    
+    validate_input = function(data) {
+      if (!is.numeric(data)) {
+        stop("Input data must be numeric")
+      }
+      if (any(is.na(data))) {
+        stop("Input data contains missing values")
+      }
+      if (length(data) < 3) {
+        stop("Input data must have at least 3 observations")
+      }
+    },
+    
+    adf_test = function(max_lags) {
+      y <- self$data
+      n <- length(y)
+      
+      # Calculate first differences
+      dy <- diff(y)
+      y_1 <- y[-n]
+      
+      # Construct regression matrix
+      X <- matrix(1, n-1, 1)
+      X <- cbind(X, y_1)
+      
+      # Add lagged differences
+      if (max_lags > 0) {
+        # Add lagged differences using embed() for clarity
+        lagged_dy <- embed(dy, max_lags + 1)[, -1, drop = FALSE]
+        X <- X[(max_lags+1):nrow(X), ]  # Align X with lagged_dy rows
+        X <- cbind(X, lagged_dy)
+        dy <- dy[(max_lags+1):length(dy)]
+      }
+      
+      # Remove NA rows
+      complete_cases <- stats::complete.cases(X)
+      X <- X[complete_cases, ]
+      dy <- dy[complete_cases]
+      
+      # Fit regression
+      fit <- stats::lm(dy ~ X - 1)
+      
+      # Calculate test statistic
+      coef <- stats::coef(fit)[2]
+      se <- sqrt(diag(stats::vcov(fit)))[2]
+      t_stat <- coef / se
+      
+      # Critical values (approximate)
+      crit_values <- c(
+        "1%" = -3.43,
+        "5%" = -2.86,
+        "10%" = -2.57
+      )
+      
+      return(list(
+        statistic = t_stat,
+        critical_values = crit_values,
+        is_stationary = t_stat < -2.86  # 5% level
+      ))
+    },
+    
+    calculate_acf = function(max_lag) {
+      y <- scale(self$data)  # Standardize data
+      n <- length(y)
+      acf <- numeric(max_lag)
+      
+      for (k in 1:max_lag) {
+        acf[k] <- stats::cor(y[1:(n-k)], y[(k+1):n])
+      }
+      
+      return(acf)
+    },
+    
+    calculate_pacf = function(max_lag) {
+      acf <- private$calculate_acf(max_lag)
+      pacf <- numeric(max_lag)
+      
+      # Durbin-Levinson algorithm
+      for (k in 1:max_lag) {
+        if (k == 1) {
+          pacf[k] <- acf[1]
+        } else {
+          r <- matrix(0, k, k)
+          for (i in 1:k) {
+            for (j in 1:k) {
+              idx <- abs(i-j)+1
+              if (idx <= length(acf)) {
+                r[i,j] <- acf[idx]
+              } else {
+                r[i,j] <- 0
+              }
+            }
+          }
+          b <- acf[1:k]
+          pacf[k] <- solve(r, b)[k]
+        }
+      }
+      
+      return(pacf)
+    },
+    
+    fit_arima_model = function(p, d, q) {
+      # Difference data
+      y <- self$data
+      for (i in 1:d) {
+        y <- diff(y)
+      }
+      
+      # Construct and solve Yule-Walker equations for AR part
+      if (p > 0) {
+        r <- private$calculate_acf(p + 1)
+        phi <- solve(stats::toeplitz(r[1:p]), r[2:(p+1)])
+      } else {
+        phi <- numeric(0)
+      }
+      
+      # Estimate MA parameters using innovation algorithm
+      if (q > 0) {
+        theta <- numeric(q)
+        e <- y
+        for (i in 1:10) {  # Iterate to improve estimates
+          r <- private$calculate_acf(q)
+          psi <- numeric(q)
+          for (j in 1:q) {
+            if (j > 1) {
+              psi[j] <- sum(theta[1:(j-1)] * rev(psi[1:(j-1)])) + theta[j]
+            } else {
+              psi[j] <- theta[j]
+            }
+          }
+          if (q == 1) {
+            theta <- solve(stats::toeplitz(1), r[1])
+          } else {
+            theta <- solve(stats::toeplitz(c(1, psi[1:(q-1)])), r[1:q])
+          }
+        }
+      } else {
+        theta <- numeric(0)
+      }
+      
+      # Calculate residuals and AIC
+      resid <- private$calculate_residuals(y, phi, theta)
+      n_params <- p + q
+      aic <- length(resid) * log(var(resid)) + 2 * n_params
+      
+      return(list(
+        coefficients = list(ar = phi, ma = theta),
+        residuals = resid,
+        aic = aic,
+        order = c(p, d, q)
+      ))
+    },
+    
+    calculate_residuals = function(y, phi, theta) {
+      n <- length(y)
+      p <- length(phi)
+      q <- length(theta)
+      resid <- numeric(n)
+      
+      for (t in (max(p,q)+1):n) {
+        pred <- 0
+        if (p > 0) {
+          pred <- pred + sum(phi * y[(t-1):(t-p)])
+        }
+        if (q > 0) {
+          pred <- pred + sum(theta * resid[(t-1):(t-q)])
+        }
+        resid[t] <- y[t] - pred
+      }
+      
+      return(resid[(max(p,q)+1):n])
+    },
+    
+    generate_forecasts = function(h, level) {
+      model <- private$current_model
+      y <- self$data
+      n <- length(y)
+      
+      # Get model orders
+      p <- length(model$coefficients$ar)
+      d <- model$order[2]
+      q <- length(model$coefficients$ma)
+      
+      # Generate point forecasts
+      forecasts <- numeric(h)
+      for (i in 1:h) {
+        pred <- 0
+        if (p > 0) {
+          # Use the most recent p values (from original data and previous forecasts)
+          if (i <= p) {
+            ar_terms <- y[(n-p+i):(n+i-1)]
+          } else {
+            # Combine tail of y and head of forecasts as needed
+            num_from_y <- max(0, p - (i-1))
+            num_from_forecasts <- p - num_from_y
+            if (num_from_y > 0) {
+              ar_terms <- c(
+                y[(n - p + i):(n)],
+                forecasts[1:num_from_forecasts]
+              )
+            } else {
+              ar_terms <- forecasts[(i-p):(i-1)]
+            }
+          }
+          pred <- pred + sum(model$coefficients$ar * ar_terms)
+        }
+        forecasts[i] <- pred
+      }
+      
+      # Calculate prediction intervals
+      sigma <- sd(model$residuals)
+      z <- stats::qnorm((1 + level) / 2)
+      se <- sigma * sqrt(cumsum(rep(1, h)))
+      lower <- forecasts - z * se
+      upper <- forecasts + z * se
+      
+      return(list(
+        mean = forecasts,
+        lower = lower,
+        upper = upper,
+        level = level
+      ))
+    },
+    
+    ljung_box_test = function(residuals) {
+      max_lag <- min(20, length(residuals) - 1)
+      acf_vals <- stats::acf(residuals, plot = FALSE, lag.max = max_lag)$acf[-1]
+      n <- length(residuals)
+      
+      Q <- n * (n + 2) * sum((acf_vals^2) / (n - 1:max_lag))
+      p_value <- 1 - stats::pchisq(Q, max_lag)
+      
+      return(list(
+        statistic = Q,
+        p_value = p_value
+      ))
+    },
+    
+    normality_test = function(residuals) {
+      # Jarque-Bera test
+      n <- length(residuals)
+      s <- sum((residuals - mean(residuals))^3) / (n * sd(residuals)^3)  # skewness
+      k <- sum((residuals - mean(residuals))^4) / (n * sd(residuals)^4) - 3  # excess kurtosis
+      JB <- n * (s^2/6 + k^2/24)
+      p_value <- 1 - stats::pchisq(JB, df = 2)
+      
+      return(list(
+        statistic = JB,
+        p_value = p_value
+      ))
+    },
+    
+    arch_test = function(residuals) {
+      # ARCH LM test
+      sq_resid <- residuals^2
+      n <- length(sq_resid)
+      lags <- 5
+      
+      # Use embed to construct lagged matrix (current and past lags)
+      # embed(sq_resid, lags + 1) returns a matrix with columns: t, t-1, ..., t-lags
+      if (n <= lags) {
+        stop("Not enough observations for ARCH test lags.")
+      }
+      lagged_mat <- stats::embed(sq_resid, lags + 1)
+      y <- lagged_mat[, 1]  # current squared residuals
+      X <- lagged_mat[, -1] # lagged squared residuals
+      fit <- stats::lm(y ~ X)
+      R2 <- summary(fit)$r.squared
+      LM <- nrow(lagged_mat) * R2
+      p_value <- 1 - stats::pchisq(LM, lags)
+      
+      return(list(
+        statistic = LM,
+        p_value = p_value
+      ))
+    }
+  )
+)
+
+# Demonstration
+demonstrate_time_series_analysis <- function() {
+  cat("=== Time Series Analysis Demo ===\n\n")
+  
+  # Generate sample time series
+  set.seed(42)
+  n <- 500
+  
+  # AR(1) process with trend and seasonality
+  t <- 1:n
+  trend <- 0.01 * t
+  seasonal <- 2 * sin(2 * pi * t / 12)
+  ar_process <- stats::arima.sim(list(ar = 0.7), n = n)
+  y <- trend + seasonal + ar_process
+  
+  # Initialize analyzer
+  ts_analyzer <- TimeSeriesAnalyzer$new(y, frequency = 12)
+  
+  # Test stationarity
+  cat("Testing for stationarity...\n")
+  stat_test <- ts_analyzer$test_stationarity()
+  cat(sprintf("ADF test statistic: %.3f\n", stat_test$statistic))
+  cat("Critical values:\n")
+  print(stat_test$critical_values)
+  cat(sprintf("Series is %sstationary at 5%% level\n\n",
+              ifelse(stat_test$is_stationary, "", "non-")))
+  
+  # Analyze ACF/PACF
+  cat("Calculating ACF and PACF...\n")
+  corr <- ts_analyzer$calculate_acf_pacf(20)
+  cat("First 5 lags:\n")
+  cat("ACF:  ")
+  cat(sprintf("%.3f ", corr$acf[1:5]))
+  cat("\nPACF: ")
+  cat(sprintf("%.3f ", corr$pacf[1:5]))
+  cat("\n\n")
+  
+  # Select best model
+  cat("Selecting best ARIMA model...\n")
+  best <- ts_analyzer$select_best_model(max_p = 2, max_d = 1, max_q = 2)
+  cat(sprintf("Best model: ARIMA(%d,%d,%d)\n", 
+              best$order[1], best$order[2], best$order[3]))
+  cat(sprintf("AIC: %.2f\n\n", best$aic))
+  
+  # Generate forecasts
+  cat("Generating forecasts...\n")
+  h <- 12  # Forecast horizon
+  forecasts <- ts_analyzer$forecast(h = h, level = 0.95)
+  
+  cat("Point forecasts for next 12 periods:\n")
+  cat(sprintf("%.2f ", forecasts$mean))
+  cat("\n\n")
+  
+  # Model diagnostics
+  cat("Performing model diagnostics...\n")
+  diagnostics <- ts_analyzer$diagnose_model()
+  
+  cat("Residual diagnostics:\n")
+  cat(sprintf("Mean: %.3f\n", diagnostics$residual_mean))
+  cat(sprintf("Standard deviation: %.3f\n", diagnostics$residual_sd))
+  cat(sprintf("Ljung-Box test p-value: %.3f\n", diagnostics$ljung_box$p_value))
+  cat(sprintf("Normality test p-value: %.3f\n", diagnostics$normality$p_value))
+  cat(sprintf("ARCH test p-value: %.3f\n", diagnostics$arch_effect$p_value))
+  
+  cat("\n=== Demo Complete ===\n")
+}
+
+# Run demonstration if not in interactive mode
+if (!interactive()) {
+  demonstrate_time_series_analysis()
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/regression_algorithms/ann.r b/Desktop/open-source/R/regression_algorithms/ann.r
new file mode 100644
index 00000000..233ac47a
--- /dev/null
+++ b/Desktop/open-source/R/regression_algorithms/ann.r
@@ -0,0 +1,14 @@
+library(neuralnet)
+concrete<-read.csv(file = "concrete.txt",stringsAsFactors = F)#get the data
+normalize<-function(x){
+  return((x-min(x))/(max(x)-min(x)))
+}
+concrete<-as.data.frame(lapply(concrete, normalize))
+concrete_train<-concrete[1:773,]
+concrete_test<-concrete[774:1030,]
+concrete_model<-neuralnet(strength~cement+slag+ash+water+superplastic+coarseagg+fineagg+age,data = concrete_train,hidden = 5)
+model_res<-compute(concrete_model,concrete_test[,1:8])
+x=model_res$net.result
+y=concrete_test$strength
+cor(x,y)
+plot(concrete_model)
diff --git a/Desktop/open-source/R/regression_algorithms/anova_oneway.r b/Desktop/open-source/R/regression_algorithms/anova_oneway.r
new file mode 100644
index 00000000..3184d52b
--- /dev/null
+++ b/Desktop/open-source/R/regression_algorithms/anova_oneway.r
@@ -0,0 +1,81 @@
+#' One-way ANOVA (from scratch)
+#'
+#' @description
+#' Computes a one-way Analysis of Variance (ANOVA) to test whether k group means
+#' are equal. Implements sums of squares, F statistic, and p-value without using \code{aov()}.
+#'
+#' @param x Numeric vector of observations.
+#' @param g Factor or character vector of group labels (same length as \code{x}).
+#'
+#' @return A list with:
+#' \item{df_between}{Degrees of freedom between groups (k - 1).}
+#' \item{df_within}{Degrees of freedom within groups (n - k).}
+#' \item{ss_between}{Between-group sum of squares.}
+#' \item{ss_within}{Within-group sum of squares.}
+#' \item{ms_between}{Between-group mean square.}
+#' \item{ms_within}{Within-group mean square.}
+#' \item{F}{F-statistic.}
+#' \item{p_value}{Right-tail p-value from F distribution.}
+#'
+#' @details
+#' One-way ANOVA partitions total variance into between-group and within-group components:
+#' \deqn{SS_T = SS_B + SS_W.}
+#' The test statistic \eqn{F = MS_B / MS_W} follows an F distribution under H0 (equal means).
+#'
+#' @examples
+#' set.seed(0)
+#' x <- c(rnorm(20, 0, 1), rnorm(22, 0.2, 1), rnorm(18, -0.1, 1))
+#' g <- factor(rep(c("A", "B", "C"), times = c(20, 22, 18)))
+#' res <- anova_oneway(x, g)
+#' res$F; res$p_value
+#'
+#' @export
+anova_oneway <- function(x, g) {
+  if (!is.numeric(x)) stop("`x` must be numeric.")
+  if (length(x) != length(g)) stop("`x` and `g` must have the same length.")
+  if (!is.factor(g)) g <- factor(g)
+
+  n <- length(x)
+  k <- nlevels(g)
+  if (k < 2L) stop("Need at least 2 groups.")
+  if (n <= k) stop("Total observations must exceed number of groups.")
+
+  grand_mean <- mean(x)
+
+  # group stats
+  group_means <- tapply(x, g, mean)
+  group_sizes <- tapply(x, g, length)
+
+  # SS_between = sum_{groups} n_j * (mean_j - grand_mean)^2
+  ss_between <- sum(group_sizes * (group_means - grand_mean)^2)
+
+  # SS_within = sum over groups of sum (x_ij - mean_j)^2
+  ss_within <- sum(unlist(tapply(x, g, function(v) sum((v - mean(v))^2))))
+
+  df_between <- k - 1L
+  df_within  <- n - k
+
+  ms_between <- ss_between / df_between
+  ms_within  <- ss_within  / df_within
+
+  F_stat <- ms_between / ms_within
+  p_val  <- stats::pf(F_stat, df_between, df_within, lower.tail = FALSE)
+
+  list(
+    df_between = df_between,
+    df_within  = df_within,
+    ss_between = ss_between,
+    ss_within  = ss_within,
+    ms_between = ms_between,
+    ms_within  = ms_within,
+    F = F_stat,
+    p_value = p_val
+  )
+}
+
+# --- Simple self-test (uncomment to run locally) ---
+# set.seed(1)
+# x <- c(rnorm(15, 0, 1), rnorm(15, 0.5, 1), rnorm(15, 1, 1))
+# g <- factor(rep(c("A","B","C"), each = 15))
+# res <- anova_oneway(x, g)
+# stopifnot(res$F > 0, res$p_value >= 0, res$p_value <= 1)
diff --git a/Desktop/open-source/R/regression_algorithms/linear_regression.r b/Desktop/open-source/R/regression_algorithms/linear_regression.r
new file mode 100644
index 00000000..753a0e30
--- /dev/null
+++ b/Desktop/open-source/R/regression_algorithms/linear_regression.r
@@ -0,0 +1,11 @@
+# Load Train and Test datasets
+# Identify feature and response variable(s) and values must be numeric and numpy arrays
+x_train <- input_variables_values_training_datasets
+y_train <- target_variables_values_training_datasets
+x_test <- input_variables_values_test_datasets
+x <- cbind(x_train,y_train)
+# Train the model using the training sets and check score
+linear <- lm(y_train ~ ., data = x)
+summary(linear)
+# Predict Output
+predicted= predict(linear,x_test) 
diff --git a/Desktop/open-source/R/regression_algorithms/linearregressionrawr.r b/Desktop/open-source/R/regression_algorithms/linearregressionrawr.r
new file mode 100644
index 00000000..4844ad66
--- /dev/null
+++ b/Desktop/open-source/R/regression_algorithms/linearregressionrawr.r
@@ -0,0 +1,10 @@
+ols<-function(y,x){
+    data<-model.matrix(y ~ ., data = x)
+    decomp <- svd(data)
+    return(decomp$v %*% diag(1 / decomp$d) %*% t(decomp$u) %*% y)
+  }
+
+set.seed(1)
+x <- rnorm(1000)
+y <- 4 * x + rnorm(1000, sd = .5)
+ols(y=y,x=matrix(x, ncol = 1))
diff --git a/Desktop/open-source/R/regression_algorithms/multiple_linear_regression.r b/Desktop/open-source/R/regression_algorithms/multiple_linear_regression.r
new file mode 100644
index 00000000..68a61cd4
--- /dev/null
+++ b/Desktop/open-source/R/regression_algorithms/multiple_linear_regression.r
@@ -0,0 +1,11 @@
+# Introduction to multiple linear regression
+
+# lm stands for Linear Model
+# y_data are modeled as a.x1 + b.x2 + c.x3 + d.x4 + e
+mod3 <- lm(y_data~x1_data+x2_data+x3_data+x4_data, data=name_of_the_dataframe)
+
+# displays the output of the model computed by the previous line
+summary(mod3)
+
+# modeled data : it predicts the output for x_test_data as input information for the model
+predicted <- predict(mod3, x1_test_data, x2_test_data, x3_test_data, x4_test_data)
diff --git a/Desktop/open-source/R/searches/binary_search.r b/Desktop/open-source/R/searches/binary_search.r
new file mode 100644
index 00000000..60217af8
--- /dev/null
+++ b/Desktop/open-source/R/searches/binary_search.r
@@ -0,0 +1,28 @@
+binary_search <- function(arr, target) { #function for finding position of value 
+  low <- 1
+  high <- length(arr) 
+  
+  while (low <= high) {
+    mid <- low + (high - low) %/% 2 #finding mid of array
+    
+    if (arr[mid] == target) { #comapring the mis value with the value to search
+      return(mid)  # Target found, return its index
+    } else if (arr[mid] < target) {
+      low <- mid + 1  # Search in the right half
+    } else {
+      high <- mid - 1  # Search in the left half
+    }
+  }
+  return(-1)  # Target not found in the array
+}
+
+arr <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) #input array (hard code)
+target <- 7 #input value to be searched (hard code)
+
+result <- binary_search(arr, target) #binary_seach function calling
+
+if (result == -1) {
+  cat("Element", target, "not found in the array.\n")
+} else {
+  cat("Element", target, "found at position", result, ".\n")
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/searches/jump_search.r b/Desktop/open-source/R/searches/jump_search.r
new file mode 100644
index 00000000..1c687304
--- /dev/null
+++ b/Desktop/open-source/R/searches/jump_search.r
@@ -0,0 +1,287 @@
+# Jump Search Algorithm Implementation in R
+# An efficient search algorithm for sorted arrays
+# Works by jumping ahead by fixed steps then performing linear search
+# Time complexity: O(√n) where n is the array length
+# Space complexity: O(1)
+
+library(R6)
+
+#' JumpSearch Class
+#' @description R6 class implementing the Jump Search algorithm
+#' @details Jump Search is a searching algorithm for sorted arrays that works by:
+#' 1. Dividing the array into blocks of size √n
+#' 2. Jumping ahead by √n steps until finding a block where target might be
+#' 3. Performing linear search within that block
+#' Advantages:
+#' - Better than linear search: O(√n) vs O(n)
+#' - Better for systems with slow backward iteration compared to binary search
+#' - Simple implementation
+#' Limitations:
+#' - Requires sorted array
+#' - Slower than binary search: O(√n) vs O(log n)
+JumpSearch <- R6Class(
+  "JumpSearch",
+  
+  public = list(
+    #' @description Initialize Jump Search
+    #' @param data Sorted array to search in
+    #' @param validate_sorted Whether to validate if array is sorted
+    initialize = function(data = NULL, validate_sorted = TRUE) {
+      if (!is.null(data)) {
+        private$validate_input(data, validate_sorted)
+        self$data <- data
+        private$n <- length(data)
+        private$optimal_jump <- floor(sqrt(private$n))
+      }
+      invisible(self)
+    },
+    
+    #' @description Search for a target value in the array
+    #' @param target Value to search for
+    #' @param jump_size Optional custom jump size (default: √n)
+    #' @return List containing index, number of comparisons, and success status
+    search = function(target, jump_size = NULL) {
+      if (is.null(self$data)) {
+        stop("No data available. Please initialize with data first.")
+      }
+      
+      # Use custom jump size or optimal jump size
+      step <- if (is.null(jump_size)) private$optimal_jump else jump_size
+      
+      if (step <= 0 || step != round(step)) {
+        stop("Jump size must be a positive integer")
+      }
+      
+      prev <- 0
+      comparisons <- 0
+      
+      # Jump through array to find the block where target might be
+      while (step <= private$n && self$data[step] < target) {
+        comparisons <- comparisons + 1
+        prev <- step
+        step <- step + private$optimal_jump
+      }
+      
+      # If we've jumped past the end, adjust step to not exceed n
+      if (prev >= private$n) {
+        return(list(
+          index = -1,
+          comparisons = comparisons,
+          found = FALSE
+        ))
+      }
+      
+      # Linear search in the identified block
+      while ((prev + 1) <= private$n && self$data[prev + 1] <= target) {
+        comparisons <- comparisons + 1
+        prev <- prev + 1
+        
+        if (self$data[prev] == target) {
+          return(list(
+            index = prev,
+            comparisons = comparisons,
+            found = TRUE
+          ))
+        }
+      }
+      
+      # Target not found
+      return(list(
+        index = -1,
+        comparisons = comparisons,
+        found = FALSE
+      ))
+    },
+    
+    #' @description Search for multiple targets
+    #' @param targets Vector of values to search for
+    #' @return List of search results for each target
+    search_multiple = function(targets) {
+      if (!is.numeric(targets)) {
+        stop("Targets must be numeric")
+      }
+      
+      results <- list()
+      for (i in seq_along(targets)) {
+        results[[i]] <- self$search(targets[i])
+        results[[i]]$target <- targets[i]
+      }
+      return(results)
+    },
+    
+    #' @description Find the optimal jump size for the current data
+    #' @return Optimal jump size (√n)
+    get_optimal_jump_size = function() {
+      if (is.null(self$data)) {
+        stop("No data available. Please initialize with data first.")
+      }
+      return(private$optimal_jump)
+    },
+    
+    #' @description Compare performance with different jump sizes
+    #' @param target Value to search for
+    #' @param jump_sizes Vector of jump sizes to test
+    #' @return Data frame with performance comparison
+    compare_jump_sizes = function(target, jump_sizes = NULL) {
+      if (is.null(self$data)) {
+        stop("No data available. Please initialize with data first.")
+      }
+      
+      if (is.null(jump_sizes)) {
+        jump_sizes <- c(
+          floor(sqrt(private$n) / 2),
+          private$optimal_jump,
+          floor(sqrt(private$n) * 2)
+        )
+      }
+      
+      results <- data.frame(
+        jump_size = numeric(),
+        comparisons = numeric(),
+        found = logical(),
+        stringsAsFactors = FALSE
+      )
+      
+      for (size in jump_sizes) {
+        if (size > 0 && size <= private$n) {
+          result <- self$search(target, jump_size = size)
+          results <- rbind(results, data.frame(
+            jump_size = size,
+            comparisons = result$comparisons,
+            found = result$found
+          ))
+        }
+      }
+      
+      return(results)
+    },
+    
+    #' @description Update the data array
+    #' @param new_data New sorted array
+    #' @param validate_sorted Whether to validate if array is sorted
+    update_data = function(new_data, validate_sorted = TRUE) {
+      private$validate_input(new_data, validate_sorted)
+      self$data <- new_data
+      private$n <- length(new_data)
+      private$optimal_jump <- floor(sqrt(private$n))
+      invisible(self)
+    },
+    
+    # Public fields
+    data = NULL
+  ),
+  
+  private = list(
+    n = NULL,
+    optimal_jump = NULL,
+    
+    validate_input = function(data, check_sorted) {
+      if (!is.numeric(data)) {
+        stop("Input data must be numeric")
+      }
+      if (any(is.na(data))) {
+        stop("Input data contains missing values")
+      }
+      if (length(data) == 0) {
+        stop("Input data cannot be empty")
+      }
+      if (check_sorted && !private$is_sorted(data)) {
+        stop("Input data must be sorted in ascending order")
+      }
+    },
+    
+    is_sorted = function(data) {
+      all(diff(data) >= 0)
+    }
+  )
+)
+
+# Demonstration
+demonstrate_jump_search <- function() {
+  cat("=== Jump Search Algorithm Demo ===\n\n")
+  
+  # Example 1: Basic usage
+  cat("Example 1: Basic jump search\n")
+  data <- c(1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29)
+  cat("Sorted array:", paste(data, collapse = ", "), "\n")
+  
+  js <- JumpSearch$new(data)
+  cat(sprintf("Array size: %d, Optimal jump size: %d\n\n", 
+              length(data), js$get_optimal_jump_size()))
+  
+  targets <- c(7, 19, 30)
+  for (target in targets) {
+    result <- js$search(target)
+    if (result$found) {
+      cat(sprintf("Target %d found at index %d (comparisons: %d)\n", 
+                  target, result$index, result$comparisons))
+    } else {
+      cat(sprintf("Target %d not found (comparisons: %d)\n", 
+                  target, result$comparisons))
+    }
+  }
+  
+  # Example 2: Larger dataset
+  cat("\nExample 2: Larger dataset\n")
+  set.seed(42)
+  large_data <- sort(sample(1:1000, 100))
+  js2 <- JumpSearch$new(large_data)
+  
+  cat(sprintf("Array size: %d, Optimal jump size: %d\n", 
+              length(large_data), js2$get_optimal_jump_size()))
+  
+  search_targets <- c(large_data[25], large_data[75], 999)
+  results <- js2$search_multiple(search_targets)
+  
+  cat("\nMultiple search results:\n")
+  for (i in seq_along(results)) {
+    res <- results[[i]]
+    cat(sprintf("Target %d: %s (index: %d, comparisons: %d)\n",
+                res$target,
+                ifelse(res$found, "Found", "Not found"),
+                res$index,
+                res$comparisons))
+  }
+  
+  # Example 3: Jump size comparison
+  cat("\nExample 3: Comparing different jump sizes\n")
+  test_data <- 1:100
+  js3 <- JumpSearch$new(test_data)
+  target <- 87
+  
+  comparison <- js3$compare_jump_sizes(target)
+  cat(sprintf("Searching for %d in array of size %d:\n\n", target, length(test_data)))
+  print(comparison)
+  
+  # Example 4: Performance analysis
+  cat("\nExample 4: Performance analysis\n")
+  sizes <- c(100, 1000, 10000)
+  
+  cat("Average comparisons for different array sizes:\n")
+  for (n in sizes) {
+    test_array <- 1:n
+    js_test <- JumpSearch$new(test_array)
+    
+    # Test multiple searches
+    num_tests <- 20
+    total_comps <- 0
+    for (i in 1:num_tests) {
+      target <- sample(test_array, 1)
+      result <- js_test$search(target)
+      total_comps <- total_comps + result$comparisons
+    }
+    
+    avg_comps <- total_comps / num_tests
+    theoretical_bound <- sqrt(n)
+    
+    cat(sprintf("n = %5d: Avg comparisons = %.1f, Theoretical O(√n) = %.1f\n",
+                n, avg_comps, theoretical_bound))
+  }
+  
+  cat("\n=== Demo Complete ===\n")
+}
+
+# Run demonstration if not in interactive mode
+if (!interactive()) {
+  demonstrate_jump_search()
+}
\ No newline at end of file
diff --git a/Desktop/open-source/R/searches/linear_search.r b/Desktop/open-source/R/searches/linear_search.r
new file mode 100644
index 00000000..735107d6
--- /dev/null
+++ b/Desktop/open-source/R/searches/linear_search.r
@@ -0,0 +1,19 @@
+linear_search<-function(vector, search_value){ #made a function named linear_search having two parameters that are an array and a value to be searched
+  for(i in 1:length(vector)){ 
+    if(vector[i]==search_value){ #comparing each value of array with the value to be searched
+      return (i)
+    }
+  }
+  return (-1)
+}
+
+user_vec<- c(10,20,30,40,50,60) #input array (hard code)
+user_val<-30 #input value to be searched (hard code)
+
+result<-linear_search(user_vec,user_val) #linear_seach function calling
+
+if(result!=-1){
+  cat("Searched value", user_val, "found at index", result-1) #displaying the index at which value is found (if any)
+}else{
+  cat("Searched value does not exist in array")
+}
diff --git a/Desktop/open-source/R/searches/rabin.karp.string.search.r b/Desktop/open-source/R/searches/rabin.karp.string.search.r
new file mode 100644
index 00000000..86fdcc62
--- /dev/null
+++ b/Desktop/open-source/R/searches/rabin.karp.string.search.r
@@ -0,0 +1,76 @@
+# Rabin–Karp String Search Algorithm in R
+# Author: sgindeed
+# Description: Finds all occurrences of a pattern in a given text using a rolling hash technique.
+
+# Ask user for input
+text <- readline(prompt = "Enter the text: ")
+pattern <- readline(prompt = "Enter the pattern to search: ")
+
+# Convert both to lowercase for case-insensitive matching
+text <- tolower(text)
+pattern <- tolower(pattern)
+
+# Get lengths
+n <- nchar(text)
+m <- nchar(pattern)
+
+# Handle empty or invalid inputs
+if (m == 0) {
+  cat("Empty pattern. Nothing to search.\n")
+  quit(save = "no")
+}
+
+if (m > n) {
+  cat("Pattern is longer than text. Pattern not found in text.\n")
+  quit(save = "no")
+}
+
+# Constants
+base <- 256   # Number of possible characters
+mod <- 101    # A prime number for hashing
+
+# Initialize variables
+p_hash <- 0  # hash for pattern
+t_hash <- 0  # hash for text window
+h <- 1       # base^(m-1)
+matches <- c()
+
+# Compute (base^(m-1)) % mod safely
+for (i in seq_len(m - 1)) {
+  h <- (h * base) %% mod
+}
+
+# Convert characters to ASCII values
+pattern_chars <- utf8ToInt(pattern)
+text_chars <- utf8ToInt(text)
+
+# Compute initial hash values for pattern and first window of text
+for (i in 1:m) {
+  p_hash <- (base * p_hash + pattern_chars[i]) %% mod
+  t_hash <- (base * t_hash + text_chars[i]) %% mod
+}
+
+# Rabin–Karp main search
+for (i in 0:(n - m)) {
+  # If hash matches, verify actual substring
+  if (p_hash == t_hash) {
+    if (substr(text, i + 1, i + m) == pattern) {
+      matches <- c(matches, i + 1)
+    }
+  }
+  
+  # Slide window: remove first char, add next char
+  if (i < n - m) {
+    t_hash <- (base * (t_hash - text_chars[i + 1] * h) + text_chars[i + m + 1]) %% mod
+    if (t_hash < 0) {
+      t_hash <- t_hash + mod
+    }
+  }
+}
+
+# Display results
+if (length(matches) > 0) {
+  cat("Pattern found at positions:", paste(matches, collapse = ", "), "\n")
+} else {
+  cat("Pattern not found in the given text.\n")
+}
diff --git a/Desktop/open-source/R/searches/ternary.search.r b/Desktop/open-source/R/searches/ternary.search.r
new file mode 100644
index 00000000..0c2e16a0
--- /dev/null
+++ b/Desktop/open-source/R/searches/ternary.search.r
@@ -0,0 +1,53 @@
+#' Performs ternary search on a sorted integer array.
+#'
+#' @param arr Integer vector. Must be sorted in ascending order.
+#' @param target Integer value to search for in arr.
+#' @return The index (1-based) of the target in arr if found, otherwise -1.
+#' @details The input array must be sorted in ascending order for correct results.
+# Ternary Search in R – works on sorted arrays
+
+ternary_search <- function(arr, target) {
+  l <- 1
+  r <- length(arr)
+  while (l <= r) {
+    mid1 <- l + (r - l) %/% 3
+    mid2 <- r - (r - l) %/% 3
+
+    if (arr[mid1] == target) return(mid1)
+    if (arr[mid2] == target) return(mid2)
+
+    if (target < arr[mid1]) {
+      r <- mid1 - 1
+    } else if (target > arr[mid2]) {
+      l <- mid2 + 1
+    } else {
+      l <- mid1 + 1
+      r <- mid2 - 1
+    }
+  }
+  return(-1)
+}
+
+# --- User Input Section with Validation ---
+arr_input <- readline("Enter sorted integers: ")
+arr_split <- strsplit(arr_input, " ")[[1]]
+arr <- as.integer(arr_split)
+if (length(arr) == 0 || any(is.na(arr))) {
+  cat("Error: Please enter a non-empty list of valid integers separated by spaces.\n")
+  quit(status = 1)
+}
+
+target_input <- readline("Enter target to search: ")
+target <- suppressWarnings(as.integer(target_input))
+if (is.na(target_input) || is.na(target)) {
+  cat("Error: Please enter a valid integer for the target.\n")
+  quit(status = 1)
+}
+
+# --- Execute Search ---
+index <- ternary_search(arr, target)
+
+if (index != -1)
+  cat("Element found at position:", index, "\n")
+else
+  cat("Element not found.\n")
diff --git a/Desktop/open-source/R/searches/z.algorithm.search.r b/Desktop/open-source/R/searches/z.algorithm.search.r
new file mode 100644
index 00000000..9e3b51f2
--- /dev/null
+++ b/Desktop/open-source/R/searches/z.algorithm.search.r
@@ -0,0 +1,37 @@
+# Z-Algorithm for Pattern Searching in R
+# Finds all occurrences of a pattern in a text efficiently in O(n + m).
+
+z_algorithm_search <- function(text, pattern) {
+  concat <- paste0(pattern, "$", text)
+  n <- nchar(concat)
+  Z <- integer(n)
+  
+  L <- 0
+  R <- 0
+  for (i in 2:n) {
+    if (i <= R)
+      Z[i] <- min(R - i + 1, Z[i - L + 1])
+    
+    while (i + Z[i] <= n && substr(concat, Z[i] + 1, Z[i] + 1) ==
+           substr(concat, i + Z[i], i + Z[i]))
+      Z[i] <- Z[i] + 1
+    
+    if (i + Z[i] - 1 > R) {
+      L <- i
+      R <- i + Z[i] - 1
+    }
+  }
+  
+  positions <- which(Z > nchar(pattern))
+  matches <- positions - nchar(pattern) - 1
+  return(matches)
+}
+
+text <- tolower(readline("Enter text: "))
+pattern <- tolower(readline("Enter pattern: "))
+
+matches <- z_algorithm_search(text, pattern)
+if (length(matches) > 0)
+  cat("Pattern found at positions:", matches, "\n")
+else
+  cat("Pattern not found.\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/sorting_algorithms/binary_insertion_sort.r b/Desktop/open-source/R/sorting_algorithms/binary_insertion_sort.r
new file mode 100644
index 00000000..4497c777
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/binary_insertion_sort.r
@@ -0,0 +1,43 @@
+# Binary Insertion Sort Function
+# Sorts an input vector using the Binary Insertion Sort algorithm.
+# Parameters:
+# - arr: Input vector to be sorted.
+# Returns:
+# - Sorted vector.
+binary_insertion_sort <- function(arr) {
+  # Loop through the input vector starting from the second element.
+  for (i in 2:length(arr)) {
+    # Store the current element in a variable.
+    key <- arr[i]
+    # Initialize left and right pointers for binary search.
+    left <- 1
+    right <- i - 1
+    
+    # Binary search to find the correct position to insert the key.
+    while (left <= right) {
+      mid <- left + (right - left) %/% 2
+      
+      if (key < arr[mid]) {
+        right <- mid - 1
+      } else {
+        left <- mid + 1
+      }
+    }
+    
+    # Shift elements to the right to make space for the key.
+    for (j in i: (left + 1)) {
+      arr[j] <- arr[j - 1]
+    }
+    
+    # Insert the key into its correct position.
+    arr[left] <- key
+  }
+  
+  # Return the sorted vector.
+  return(arr)
+}
+
+# Example usage:
+elements_vec <- c(64, 34, 25, 12, 22, 11, 90)
+sorted_vec <- binary_insertion_sort(elements_vec)
+print(sorted_vec)
diff --git a/Desktop/open-source/R/sorting_algorithms/bubble_sort.r b/Desktop/open-source/R/sorting_algorithms/bubble_sort.r
new file mode 100644
index 00000000..7f064c05
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/bubble_sort.r
@@ -0,0 +1,19 @@
+# Bubble sort in R:
+
+bubble.sort <- function(elements.vec) { 
+  n <- length(elements.vec)
+  for(i in 1:(n-1)) {
+    for(j in 1:(n-i)) {
+      if(elements.vec[j+1] < elements.vec[j]) { 
+        temp <- elements.vec[j]
+        elements.vec[j] <- elements.vec[j+1]
+        elements.vec[j+1] <- temp
+      }
+    }
+  }
+  return(elements.vec)
+}
+
+# Example:
+# bubble.sort(c(5, 2, 3, 1, 4))
+# [1] 1 2 3 4 5
diff --git a/Desktop/open-source/R/sorting_algorithms/bucket_sort.r b/Desktop/open-source/R/sorting_algorithms/bucket_sort.r
new file mode 100644
index 00000000..4596725b
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/bucket_sort.r
@@ -0,0 +1,43 @@
+# Bucket Sort Function
+# Sorts an input vector using the Bucket Sort algorithm.
+# Parameters:
+# - arr: Input vector to be sorted.
+# Returns:
+# - Sorted vector.
+bucket_sort <- function(arr) {
+  if (length(arr) == 0) {
+    return(arr)
+  }
+  
+  # Find the maximum and minimum values in the input vector
+  max_val <- max(arr)
+  min_val <- min(arr)
+  
+  # Create an array of buckets
+  num_buckets <- max_val - min_val + 1
+  buckets <- vector("list", length = num_buckets)
+  
+  # Initialize the buckets
+  for (i in 1:num_buckets) {
+    buckets[[i]] <- numeric(0)
+  }
+  
+  # Place elements into buckets
+  for (val in arr) {
+    bucket_index <- val - min_val + 1
+    buckets[[bucket_index]] <- c(buckets[[bucket_index]], val)
+  }
+  
+  # Sort each bucket (using any sorting algorithm, e.g., Bubble Sort)
+  sorted_buckets <- lapply(buckets, bubble.sort)
+  
+  # Concatenate the sorted buckets to obtain the final sorted array
+  sorted_arr <- unlist(sorted_buckets)
+  
+  return(sorted_arr)
+}
+
+# Example usage:
+elements_vec <- c(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)
+bucket_sorted_vec <- bucket_sort(elements_vec)
+print(bucket_sorted_vec)
diff --git a/Desktop/open-source/R/sorting_algorithms/cocktail_sort.r b/Desktop/open-source/R/sorting_algorithms/cocktail_sort.r
new file mode 100644
index 00000000..694f97af
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/cocktail_sort.r
@@ -0,0 +1,56 @@
+cocktailSort <- function(arr) {
+  n <- length(arr)
+  swapped <- TRUE
+  beg <- 1
+  end <- n - 1
+
+  while (swapped) {
+    swapped <- FALSE
+    
+    # Forward pass (left to right)
+    for (i in seq(beg, end)) {
+      if (arr[i] > arr[i + 1]) {
+        # Swap arr[i] and arr[i + 1]
+        temp <- arr[i]
+        arr[i] <- arr[i + 1]
+        arr[i + 1] <- temp
+        swapped <- TRUE
+      }
+    }
+
+    # If no swaps occurred in the forward pass, the array is sorted
+    if (!swapped) {
+      break
+    }
+
+    swapped <- FALSE
+    end <- end - 1
+
+    # Backward pass (right to left)
+    for (i in seq(end, beg, by = -1)) {
+      if (arr[i] > arr[i + 1]) {
+        # Swap arr[i] and arr[i + 1]
+        temp <- arr[i]
+        arr[i] <- arr[i + 1]
+        arr[i + 1] <- temp
+        swapped <- TRUE
+      }
+    }
+
+    beg <- beg + 1
+  }
+  
+  return(arr)
+}
+
+# Example Usage
+unsorted_array <- c(38, 27, 43, 3, 9, 82, 10)
+cat("Unsorted Array: ", unsorted_array, "\n")
+
+# Call the Cocktail Sort function to sort the array
+sorted_array <- cocktailSort(unsorted_array)
+
+cat("Sorted Array: ", sorted_array, "\n")
+
+# Example: The 'unsorted_array' is sorted using Cocktail Sort
+
diff --git a/Desktop/open-source/R/sorting_algorithms/comb_sort.r b/Desktop/open-source/R/sorting_algorithms/comb_sort.r
new file mode 100644
index 00000000..ee4e8af4
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/comb_sort.r
@@ -0,0 +1,26 @@
+# Comb sort in R:
+
+comb.sort <- function(elements.vec) {
+  gap <- length(elements.vec)
+  swaps <- 1
+  while (gap > 1 && swaps == 1) {
+    gap = floor(gap / 1.3)
+    if (gap < 1) {
+      gap = 1
+    }
+    swaps = 0
+    i = 1
+    while (i + gap <= length(a)) {
+      if (elements.vec[i] > elements.vec[i + gap]) {
+        elements.vec[c(i, i + gap)] <- elements.vec[c(i + gap, i)]
+        swaps = 1
+      }
+      i <- i + 1
+    }
+  }  
+  return(elements.vec) 
+}
+
+# Example:
+# comb.sort(sample(1:100,10))
+# [1] 9 49 50 51 56 60 61 71 86 95
diff --git a/Desktop/open-source/R/sorting_algorithms/counting_sort.r b/Desktop/open-source/R/sorting_algorithms/counting_sort.r
new file mode 100644
index 00000000..2cc2028f
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/counting_sort.r
@@ -0,0 +1,26 @@
+# Counting sort in R:
+
+counting.sort <- function(elements.vec){  
+  min <- min(elements.vec)
+  max <- max(elements.vec)  
+  count <- rep(0,(max - min + 1))
+  for(i in 1:length(elements.vec)){
+    x <- 1 - min + elements.vec[i]
+    count[x] <- count[x] + 1
+  } 
+  for(i in 2:length(count)){
+    count[i] <- count[i] + count[i-1]
+  }  
+  result <- rep(0,length(elements.vec))
+  for(i in 1:length(elements.vec)){
+    x <- 1 - min + elements.vec[i]
+    index <- count[x]
+    result[index] <- elements.vec[i]
+    count[x] = count[x] - 1
+  } 
+  return(result)  
+}
+
+# Example:
+# counting.sort(c(5, 2, 3, 1, 4))
+# [1] 1 2 3 4 5
diff --git a/Desktop/open-source/R/sorting_algorithms/cycle_sort.r b/Desktop/open-source/R/sorting_algorithms/cycle_sort.r
new file mode 100644
index 00000000..536bfabc
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/cycle_sort.r
@@ -0,0 +1,59 @@
+# Cycle Sort Function
+# Sorts an input vector in-place using the Cycle Sort algorithm.
+# Parameters:
+# - arr: Input vector to be sorted.
+# Returns:
+# - Sorted vector.
+cycle_sort <- function(arr) {
+  n <- length(arr)
+  for (cycle_start in 1:(n - 1)) {
+    item <- arr[cycle_start]
+    pos <- cycle_start
+    
+    # Find the correct position for the current item
+    for (i in (cycle_start + 1):n) {
+      if (arr[i] < item) {
+        pos <- pos + 1
+      }
+    }
+    
+    # Skip if the item is already in the correct position
+    if (pos == cycle_start) {
+      next
+    }
+    
+    # Move the item to its correct position
+    while (item == arr[pos]) {
+      pos <- pos + 1
+    }
+    temp <- arr[pos]
+    arr[pos] <- item
+    item <- temp
+    
+    # Rotate the remaining cycle
+    while (pos != cycle_start) {
+      pos <- cycle_start
+      for (i in (cycle_start + 1):n) {
+        if (arr[i] < item) {
+          pos <- pos + 1
+        }
+      }
+      
+      # Skip if the item is already in the correct position
+      while (item == arr[pos]) {
+        pos <- pos + 1
+      }
+      
+      # Move the item to its correct position
+      temp <- arr[pos]
+      arr[pos] <- item
+      item <- temp
+    }
+  }
+  return(arr)
+}
+
+# Example usage:
+elements_vec <- c(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)
+cycle_sorted_vec <- cycle_sort(elements_vec)
+print(cycle_sorted_vec)
diff --git a/Desktop/open-source/R/sorting_algorithms/gnome_sort.r b/Desktop/open-source/R/sorting_algorithms/gnome_sort.r
new file mode 100644
index 00000000..c4ded37a
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/gnome_sort.r
@@ -0,0 +1,30 @@
+# Gnome Sort Function
+# Sorts an input vector using the Gnome Sort algorithm.
+# Parameters:
+# - arr: Input vector to be sorted.
+# Returns:
+# - Sorted vector.
+
+gnome_sort <- function(arr) {
+  index <- 1
+  n <- length(arr)
+  
+  while (index <= n) {
+    if (index == 1 || arr[index] >= arr[index - 1]) {
+      index <- index + 1
+    } else {
+      # Swap arr[index] and arr[index - 1]
+      temp <- arr[index]
+      arr[index] <- arr[index - 1]
+      arr[index - 1] <- temp
+      index <- index - 1
+    }
+  }
+  
+  return(arr)
+}
+
+# Example usage:
+elements_vec <- c(34, 2, 10, -9)
+gnome_sorted_vec <- gnome_sort(elements_vec)
+print(gnome_sorted_vec)
diff --git a/Desktop/open-source/R/sorting_algorithms/heap_sort.r b/Desktop/open-source/R/sorting_algorithms/heap_sort.r
new file mode 100644
index 00000000..c2378798
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/heap_sort.r
@@ -0,0 +1,63 @@
+# Heap sort in R:
+
+build.heap <- function(elements.vec) {
+  l = length(elements.vec)
+  heap = elements.vec
+  for (i in l:1) {
+    heap = modify.heap(heap, i)
+  }
+  return(heap)
+}
+
+is.heap <- function(heap, rootIndex) {
+  i = rootIndex
+  res = T
+  while(2 * i <= length(heap) & res) {
+    child = c(heap[2 * i], heap[2 * i + 1])
+    child = child[!is.na(child)]
+    result.bool = all(heap[i] <= child)
+    i = i + 1
+  }
+  return(result.bool)
+}
+
+modify.heap <- function(heap, rootIndex) {
+  l = length(heap)
+  flag = 1  
+  while (rootIndex * 2 <= l && flag == 1) {
+    leftIndex = rootIndex * 2
+    rightIndex = rootIndex * 2 + 1
+    flag = 0
+    child = c(heap[leftIndex], heap[rightIndex])
+    child = child[!is.na(child)]
+    minIndex = which.min(child)
+    if (heap[rootIndex] > child[minIndex]) {
+      flag = 1
+      heapIndex = c(leftIndex, rightIndex)[minIndex]
+      temp = heap[heapIndex]
+      heap[heapIndex] = heap[rootIndex]
+      heap[rootIndex] = temp
+      rootIndex = heapIndex
+    }
+  }
+  return(heap)
+}
+
+heap.sort <- function(heap) {
+  sorted.elements = NULL
+  l = length(heap)
+  while(l > 0)
+  {
+    sorted.elements = c(sorted.elements, heap[1])
+    l = length(heap)
+    heap[1] = heap[l]
+    heap = heap[1:(l - 1)]
+    heap = modify.heap(heap, rootIndex = 1)
+    l = l - 1
+  }
+  return(sorted.elements)
+}
+
+# Example:
+# heap.sort(build.heap(c(5, 2, 3, 1, 4))) 
+# [1] 1 2 3 4 5
diff --git a/Desktop/open-source/R/sorting_algorithms/insertion_sort.r b/Desktop/open-source/R/sorting_algorithms/insertion_sort.r
new file mode 100644
index 00000000..4830e69a
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/insertion_sort.r
@@ -0,0 +1,18 @@
+# Insertion sort in R:
+
+insertion.sort <- function(elements.vec) { 
+  for (j in 2:length(elements.vec)) {
+    key = elements.vec[j] 
+    i = j - 1
+    while (i > 0 && elements.vec[i] > key) {
+      elements.vec[(i + 1)] = elements.vec[i]
+      i = i - 1
+    }
+    elements.vec[(i + 1)] = key
+  }
+  return(elements.vec)
+}
+
+# Example:
+# insertion.sort(c(5, 2, 3, 1, 4))
+# [1] 1 2 3 4 5
diff --git a/Desktop/open-source/R/sorting_algorithms/merge_sort.r b/Desktop/open-source/R/sorting_algorithms/merge_sort.r
new file mode 100644
index 00000000..731a5da0
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/merge_sort.r
@@ -0,0 +1,32 @@
+# Merge sort in R:
+
+merge.func <-function(leftArray, rightArray) {
+    l <- numeric(length(leftArray) + length(rightArray))
+    leftIndex <- 1; rightIndex <- 1; i <- 1;
+    for(i in 1:length(l)) {
+        if((leftIndex <= length(leftArray) && leftArray[leftIndex] < rightArray[rightIndex]) || rightIndex > length(rightArray)) {
+            l[i] <- leftArray[leftIndex]
+            leftIndex <- leftIndex + 1
+        } else {
+            l[i] <- rightArray[rightIndex]
+            rightIndex <- rightIndex + 1
+        }
+    }
+    return(l)
+}
+
+merge.sort <- function(elements.vec) {
+    if(length(elements.vec) > 1) { 
+        m <- ceiling(length(elements.vec) / 2)
+        leftArray <- merge.sort(elements.vec[1:m])
+        rightArray <- merge.sort(elements.vec[(m + 1):length(elements.vec)])
+        merge.func(leftArray, rightArray)
+    } 
+    else {
+        return(elements.vec)
+    }
+}
+
+# Example:
+# merge.sort(c(5, 2, 3, 1, 4)) 
+# [1] 1 2 3 4 5
diff --git a/Desktop/open-source/R/sorting_algorithms/odd_even_sort.r b/Desktop/open-source/R/sorting_algorithms/odd_even_sort.r
new file mode 100644
index 00000000..61a1e00a
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/odd_even_sort.r
@@ -0,0 +1,39 @@
+# Odd-Even Sort Function
+# Sorts an input vector in-place using the Odd-Even Sort algorithm.
+# Parameters:
+# - arr: Input vector to be sorted.
+# Returns:
+# - Sorted vector.
+odd_even_sort <- function(arr) {
+  n <- length(arr)
+  sorted <- FALSE
+  while (!sorted) {
+    sorted <- TRUE
+    
+    # Odd-Even Sort (Phase 1 - Odd)
+    for (i in seq(1, n - 1, by = 2)) {
+      if (arr[i] > arr[i + 1]) {
+        temp <- arr[i]
+        arr[i] <- arr[i + 1]
+        arr[i + 1] <- temp
+        sorted <- FALSE
+      }
+    }
+    
+    # Odd-Even Sort (Phase 2 - Even)
+    for (i in seq(2, n - 1, by = 2)) {
+      if (arr[i] > arr[i + 1]) {
+        temp <- arr[i]
+        arr[i] <- arr[i + 1]
+        arr[i + 1] <- temp
+        sorted <- FALSE
+      }
+    }
+  }
+  return(arr)
+}
+
+# Example usage:
+elements_vec <- c(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)
+odd_even_sorted_vec <- odd_even_sort(elements_vec)
+print(odd_even_sorted_vec)
diff --git a/Desktop/open-source/R/sorting_algorithms/pancake_sort.r b/Desktop/open-source/R/sorting_algorithms/pancake_sort.r
new file mode 100644
index 00000000..2826f5fd
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/pancake_sort.r
@@ -0,0 +1,45 @@
+# Function to flip the first 'k' elements of an array
+flip <- function(arr, k) {
+  arr[1:k] <- rev(arr[1:k])  # Reverse the first 'k' elements
+  return(arr)
+}
+
+# Function to find the index of the maximum element in an array
+findMaxIndex <- function(arr, n) {
+  maxIndex <- 1
+  for (i in 2:n) {
+    if (arr[i] > arr[maxIndex]) {
+      maxIndex <- i
+    }
+  }
+  return(maxIndex)
+}
+
+# Function to perform Pancake Sort
+pancakeSort <- function(arr) {
+  n <- length(arr)
+  
+  for (currentSize in n:2) {
+    # Find the index of the maximum element in the unsorted part of the array
+    maxIndex <- findMaxIndex(arr, currentSize)
+    
+    # If the maximum element is not at the end of the unsorted part, flip it
+    if (maxIndex != currentSize) {
+      # Flip the maximum element to the beginning of the array
+      arr <- flip(arr, maxIndex)
+      
+      # Flip the maximum element to its correct position
+      arr <- flip(arr, currentSize)
+    }
+  }
+  
+  return(arr)
+}
+
+# Example usage:
+arr <- c(3, 1, 5, 2, 4)
+cat("Original Array:", arr, "\n")
+
+# Call the Pancake Sort function to sort the array
+sortedArr <- pancakeSort(arr)
+cat("Sorted Array:", sortedArr, "\n")
diff --git a/Desktop/open-source/R/sorting_algorithms/patience_sort.r b/Desktop/open-source/R/sorting_algorithms/patience_sort.r
new file mode 100644
index 00000000..992debfc
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/patience_sort.r
@@ -0,0 +1,56 @@
+# Patience Sort Function
+# Sorts an input vector using the Patience Sort algorithm.
+# Parameters:
+# - arr: Input vector to be sorted.
+# Returns:
+# - Sorted vector.
+
+patience_sort <- function(arr) {
+  if (length(arr) == 0) {
+    return(arr)
+  }
+  
+  piles <- list()
+  
+  # Build piles
+  for (x in arr) {
+    placed <- FALSE
+    for (i in seq_along(piles)) {
+      if (x < tail(piles[[i]], n=1)) {
+        piles[[i]] <- c(piles[[i]], x)
+        placed <- TRUE
+        break
+      }
+    }
+    if (!placed) {
+      piles[[length(piles) + 1]] <- c(x)
+    }
+  }
+  
+  # Collect sorted elements
+  sorted_arr <- c()
+  while (length(piles) > 0) {
+    # Find the pile with the smallest top element
+    min_top <- Inf
+    min_index <- -1
+    for (i in seq_along(piles)) {
+      if (tail(piles[[i]], n=1) < min_top) {
+        min_top <- tail(piles[[i]], n=1)
+        min_index <- i
+      }
+    }
+    # Remove the smallest top element and add it to the sorted array
+    sorted_arr <- c(sorted_arr, min_top)
+    piles[[min_index]] <- head(piles[[min_index]], -1)
+    if (length(piles[[min_index]]) == 0) {
+      piles[[min_index]] <- NULL
+    }
+  }
+  
+  return(sorted_arr)
+}
+
+# Example usage:
+elements_vec <- c(4, 3, 2, 1)
+patience_sorted_vec <- patience_sort(elements_vec)
+print(patience_sorted_vec)
diff --git a/Desktop/open-source/R/sorting_algorithms/quick_sort.r b/Desktop/open-source/R/sorting_algorithms/quick_sort.r
new file mode 100644
index 00000000..ac0ff113
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/quick_sort.r
@@ -0,0 +1,22 @@
+# Quick sort in R:
+
+quick.sort <- function(elements.vec) {
+  if(length(elements.vec) <= 1) {
+    return(elements.vec)
+  }
+  pivot <- elements.vec[1]
+  non.pivot  <- elements.vec[-1]
+  pivot_less    <- quick.sort(non.pivot[non.pivot < pivot])
+  pivot_greater <- quick.sort(non.pivot[non.pivot >= pivot])
+  return(c(pivot_less, pivot, pivot_greater))
+}
+
+# Example:
+# quick.sort(c(5, 2, 3, 1, 1, 4)) 
+# [1] 1 1 2 3 4 5
+
+# Notes:
+# 1. Quick sort is not a stable sorting algorithm.
+# 2. It is implemented in the 'sort' function of base R:
+# sort(c(5, 2, 3, 1, 1, 4), method = "quick" , index.return = FALSE)
+# [1] 1 1 2 3 4 5
diff --git a/Desktop/open-source/R/sorting_algorithms/radix_sort.r b/Desktop/open-source/R/sorting_algorithms/radix_sort.r
new file mode 100644
index 00000000..4d71467e
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/radix_sort.r
@@ -0,0 +1,17 @@
+# Radix sort in R:
+
+radix.sort <- function(elements.vec) {
+    x <- nchar(max(elements.vec))
+    for (i in 1:x)
+        elements.vec <- elements.vec[order(elements.vec %% (10 ^ i))]
+    return(elements.vec)
+}
+
+# Example:
+# radix.sort(c(50, 3200, 27, 976, 820)) 
+# [1] 27 50 820 976 3200
+
+# Note:
+# It is implemented in the 'sort' function of base R:
+# sort(c(50, 3200, 27, 976, 820), method = "radix" , index.return = FALSE)
+# [1] 27 50 820 976 3200
diff --git a/Desktop/open-source/R/sorting_algorithms/selection_sort.r b/Desktop/open-source/R/sorting_algorithms/selection_sort.r
new file mode 100644
index 00000000..87391037
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/selection_sort.r
@@ -0,0 +1,23 @@
+# Selection sort in R:
+
+selection.sort <- function(elements.vec, ascending = TRUE) {
+  max <- length(elements.vec)
+  for (j in 1:(max - 1)) {
+    m <- elements.vec[j]
+    p <- j
+    for(k in (j + 1):max) {
+      if(ascending && elements.vec[k] < m || !ascending && elements.vec[k] > m) {
+        m <- elements.vec[k]
+        p <- k
+      }
+    } 
+    elements.vec[p] <- elements.vec[j]
+    elements.vec[j] <- m
+  } 
+  return(elements.vec)
+}
+
+# Example:
+# selection.sort(c(5, 2, 3, 1, 1, 4)) 
+# [1] 1 1 2 3 4 5
+# Note that selection sort is not a stable sorting algorithm.
diff --git a/Desktop/open-source/R/sorting_algorithms/shell_sort.r b/Desktop/open-source/R/sorting_algorithms/shell_sort.r
new file mode 100644
index 00000000..9c39f777
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/shell_sort.r
@@ -0,0 +1,37 @@
+# Function to perform Shell Sort
+shellSort <- function(arr) {
+  n <- length(arr)
+  
+  # Start with a large gap and reduce it
+  gap <- n %/% 2  # Initial gap
+  
+  while (gap > 0) {
+    for (i in (gap + 1):n) {
+      # Store the current element to be compared
+      temp <- arr[i]
+      
+      # Compare the current element with elements at positions 'i - gap', 'i - 2 * gap', ...
+      j <- i
+      while (j > gap && arr[j - gap] > temp) {
+        arr[j] <- arr[j - gap]
+        j <- j - gap
+      }
+      
+      # Place the current element in its correct position
+      arr[j] <- temp
+    }
+    
+    # Reduce the gap for the next iteration
+    gap <- gap %/% 2
+  }
+  
+  return(arr)
+}
+
+# Example usage:
+arr <- c(12, 34, 54, 2, 3)
+cat("Original Array:", arr, "\n")
+
+# Call the Shell Sort function to sort the array
+sortedArr <- shellSort(arr)
+cat("Sorted Array:", sortedArr, "\n")
diff --git a/Desktop/open-source/R/sorting_algorithms/stooge_sort.r b/Desktop/open-source/R/sorting_algorithms/stooge_sort.r
new file mode 100644
index 00000000..f9bdceef
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/stooge_sort.r
@@ -0,0 +1,18 @@
+# Stooge sort in R:
+
+stooge.sort <- function(elements.vec) {
+	i = 1
+	j = length(elements.vec)
+	if (elements.vec[j] < elements.vec[i]) elements.vec[c(j, i)] = elements.vec[c(i, j)]
+	if (j - i > 1) {
+		t = (j - i + 1) %/% 3
+		elements.vec[i:(j - t)] = stooge.sort(elements.vec[i:(j - t)])
+		elements.vec[(i + t):j] = stooge.sort(elements.vec[(i + t):j])
+		elements.vec[i:(j - t)] = stooge.sort(elements.vec[i:(j - t)])
+	}
+	elements.vec
+}
+ 
+# Example:
+# stooge.sort(sample(21, 20))
+# [1] 1  2  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21
diff --git a/Desktop/open-source/R/sorting_algorithms/strand_sort.r b/Desktop/open-source/R/sorting_algorithms/strand_sort.r
new file mode 100644
index 00000000..25272674
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/strand_sort.r
@@ -0,0 +1,63 @@
+# Strand Sort Function
+# Sorts an input vector using the Strand Sort algorithm.
+# Parameters:
+# - arr: Input vector to be sorted.
+# Returns:
+# - Sorted vector.
+
+strand_sort <- function(arr) {
+  if (length(arr) <= 1) {
+    return(arr)
+  }
+  
+  output <- c()
+  
+  while (length(arr) > 0) {
+    sublist <- c(arr[1])
+    arr <- arr[-1]
+    i <- 1
+    while (i <= length(arr)) {
+      if (arr[i] >= tail(sublist, n=1)) {
+        sublist <- c(sublist, arr[i])
+        arr <- arr[-i]
+      } else {
+        i <- i + 1
+      }
+    }
+    output <- merge_sorted_lists(output, sublist)
+  }
+  
+  return(output)
+}
+
+# Helper function to merge two sorted lists
+merge_sorted_lists <- function(list1, list2) {
+  result <- c()
+  i <- 1
+  j <- 1
+  
+  while (i <= length(list1) && j <= length(list2)) {
+    if (list1[i] <= list2[j]) {
+      result <- c(result, list1[i])
+      i <- i + 1
+    } else {
+      result <- c(result, list2[j])
+      j <- j + 1
+    }
+  }
+  
+  if (i <= length(list1)) {
+    result <- c(result, list1[i:length(list1)])
+  }
+  
+  if (j <= length(list2)) {
+    result <- c(result, list2[j:length(list2)])
+  }
+  
+  return(result)
+}
+
+# Example usage:
+elements_vec <- c(4, 2, 5, 3, 1)
+strand_sorted_vec <- strand_sort(elements_vec)
+print(strand_sorted_vec)
diff --git a/Desktop/open-source/R/sorting_algorithms/tim_sort.r b/Desktop/open-source/R/sorting_algorithms/tim_sort.r
new file mode 100644
index 00000000..db4835d9
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/tim_sort.r
@@ -0,0 +1,90 @@
+# Insertion Sort: Sort small subarrays (runs)
+insertion_sort <- function(arr, left, right) {
+  for (i in (left + 1):right) {
+    key <- arr[i]
+    j <- i - 1
+    while (j >= left && arr[j] > key) {
+      arr[j + 1] <- arr[j]
+      j <- j - 1
+    }
+    arr[j + 1] <- key
+  }
+  return(arr)
+}
+
+# Merge two sorted subarrays
+merge <- function(arr, left, mid, right) {
+  n1 <- mid - left + 1
+  n2 <- right - mid
+
+  left_part <- arr[left:(mid)]
+  right_part <- arr[(mid + 1):right]
+
+  i <- 1
+  j <- 1
+  k <- left
+
+  # Merge left_part and right_part into arr
+  while (i <= n1 && j <= n2) {
+    if (left_part[i] <= right_part[j]) {
+      arr[k] <- left_part[i]
+      i <- i + 1
+    } else {
+      arr[k] <- right_part[j]
+      j <- j + 1
+    }
+    k <- k + 1
+  }
+
+  # Copy remaining elements of left_part, if any
+  while (i <= n1) {
+    arr[k] <- left_part[i]
+    i <- i + 1
+    k <- k + 1
+  }
+
+  # Copy remaining elements of right_part, if any
+  while (j <= n2) {
+    arr[k] <- right_part[j]
+    j <- j + 1
+    k <- k + 1
+  }
+
+  return(arr)
+}
+
+# TimSort function
+tim_sort <- function(arr) {
+  n <- length(arr)
+  min_run <- 32
+  
+  # Sort individual subarrays of size min_run using insertion sort
+  for (start in seq(1, n, by = min_run)) {
+    end <- min(start + min_run - 1, n)
+    arr <- insertion_sort(arr, start, end)
+  }
+  
+  # Merge sorted subarrays
+  size <- min_run
+  while (size < n) {
+    for (left in seq(1, n, by = 2 * size)) {
+      mid <- min(left + size - 1, n)
+      right <- min(left + 2 * size - 1, n)
+      if (mid < right) {
+        arr <- merge(arr, left, mid, right)
+      }
+    }
+    size <- 2 * size
+  }
+  
+  return(arr)
+}
+
+# Example usage:
+# -------------------
+# Input: c(5, 21, 7, 23, 19, 11, 16, 13)
+# Expected Output: c(5, 7, 11, 13, 16, 19, 21, 23)
+
+elements_vec <- c(5, 21, 7, 23, 19, 11, 16, 13)
+tim_sorted_vec <- tim_sort(elements_vec)
+print(tim_sorted_vec)
diff --git a/Desktop/open-source/R/sorting_algorithms/topological_sort.r b/Desktop/open-source/R/sorting_algorithms/topological_sort.r
new file mode 100644
index 00000000..3db79a7e
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/topological_sort.r
@@ -0,0 +1,49 @@
+# Function to perform topological sort
+topological_sort <- function(graph) {
+  # Number of vertices in the graph
+  num_vertices <- length(graph)
+  
+  # Helper function to perform DFS
+  dfs <- function(node, visited, stack) {
+    visited[node] <- TRUE
+    
+    # Visit all adjacent vertices
+    for (neighbor in graph[[node]]) {
+      if (!visited[neighbor]) {
+        dfs(neighbor, visited, stack)
+      }
+    }
+    
+    # Push the current node onto the stack
+    stack <<- c(stack, node)
+  }
+  
+  # Initialize data structures
+  visited <- rep(FALSE, num_vertices)
+  stack <- c()
+  
+  # Perform DFS for each unvisited vertex
+  for (node in 1:num_vertices) {
+    if (!visited[node]) {
+      dfs(node, visited, stack)
+    }
+  }
+  
+  # Reverse the stack to get the topological order
+  topological_order <- rev(stack)
+  return(topological_order)
+}
+
+# Example usage
+# Define a sample DAG as an adjacency list
+# Here, we represent the graph as a list of vectors, where each vector contains the neighbors of the corresponding node.
+graph <- list(
+  c(2, 3),    # Node 1 points to nodes 2 and 3
+  c(3, 4),    # Node 2 points to nodes 3 and 4
+  c(5),       # Node 3 points to node 5
+  c(5),       # Node 4 points to node 5
+  numeric(0)  # Node 5 has no outgoing edges
+)
+
+topological_order <- topological_sort(graph)
+cat("Topological Order:", topological_order, "\n")
diff --git a/Desktop/open-source/R/sorting_algorithms/wiggle_sort.r b/Desktop/open-source/R/sorting_algorithms/wiggle_sort.r
new file mode 100644
index 00000000..808dcc1e
--- /dev/null
+++ b/Desktop/open-source/R/sorting_algorithms/wiggle_sort.r
@@ -0,0 +1,24 @@
+# Wiggle Sort Function
+# Rearranges the elements in the input vector into a wiggle pattern.
+# Parameters:
+# - arr: Input vector to be rearranged.
+# Returns:
+# - Wiggle sorted vector.
+wiggle_sort <- function(arr) {
+  n <- length(arr)
+  for (i in 2:n) {
+    if ((i %% 2 == 0 && arr[i] < arr[i - 1]) || (i %% 2 != 0 && arr[i] > arr[i - 1])) {
+      # Swap elements at odd positions if they are greater
+      # or at even positions if they are smaller.
+      temp <- arr[i]
+      arr[i] <- arr[i - 1]
+      arr[i - 1] <- temp
+    }
+  }
+  return(arr)
+}
+
+# Example usage:
+elements_vec <- c(3, 5, 2, 1, 6, 4)
+wiggle_sorted_vec <- wiggle_sort(elements_vec)
+print(wiggle_sorted_vec)
diff --git a/Desktop/open-source/R/string_manipulation/burrows.r b/Desktop/open-source/R/string_manipulation/burrows.r
new file mode 100644
index 00000000..b94f45f0
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/burrows.r
@@ -0,0 +1,31 @@
+# Burrows-Wheeler Transform (BWT) in R
+# Computes the Burrows-Wheeler Transform of a string
+# Useful in compression and efficient substring searching
+
+burrows_wheeler_transform <- function(s) {
+  s <- paste0(s, "$")  # Append unique end-of-string character
+  n <- nchar(s)
+  
+  # Generate all rotations of the string
+  rotations <- character(n)
+  for (i in 1:n) {
+    rotations[i] <- paste0(substr(s, i, n), substr(s, 1, i - 1))
+  }
+  
+  # Sort the rotations lexicographically
+  rotations_sorted <- sort(rotations)
+  
+  # Build BWT by taking the last character of each sorted rotation
+  bwt <- paste0(sapply(rotations_sorted, function(x) substr(x, n, n)), collapse = "")
+  
+  return(list(original = s, rotations_sorted = rotations_sorted, bwt = bwt))
+}
+
+# Interactive input
+s <- readline(prompt = "Enter a string: ")
+result <- burrows_wheeler_transform(s)
+
+cat("Original string with end marker: ", result$original, "\n")
+cat("Sorted rotations:\n")
+print(result$rotations_sorted)
+cat("Burrows-Wheeler Transform: ", result$bwt, "\n")
diff --git a/Desktop/open-source/R/string_manipulation/findpalindrome.r b/Desktop/open-source/R/string_manipulation/findpalindrome.r
new file mode 100644
index 00000000..e6572cac
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/findpalindrome.r
@@ -0,0 +1,93 @@
+findPalindrome <- function(input) {
+  
+  is.palindrome <- function(input) {
+    if (is.numeric(input)) { # checks if input is numeric
+      # convert the numeric input value to character
+      input_con <- as.character(input)
+      # split the string into characters
+      input_split <- c(unlist(strsplit(input_con, split = "")))
+      # reverse the characters
+      input_rev <- rev(input_split)
+      # conditional statement to compare split string
+      # with the reversed string
+      if (all(input_split == input_rev) != TRUE) {
+        return(FALSE)
+      } else {
+        return(TRUE)
+      }
+    } else if (is.character(input)) { # checks if input is character
+      # split the string into characters
+      input_split <- c(unlist(strsplit(tolower(input), split = "")))
+      # reverse the characters
+      input_rev <- rev(input_split)
+      # conditional statement to compare split string
+      # with the reversed string
+      if (all(input_split == input_rev) != TRUE) {
+        return(FALSE)
+      } else {
+        return(TRUE)
+      }
+    }
+  }
+
+  if(is.character(input)) {
+    # clean out punctuation
+    input_clean <- tm::removePunctuation(input)
+    
+    # split the sentence into individual words
+    input_split <- c(unlist(strsplit(input_clean, split = " ")))
+    
+    # loop every word in the text through the is.palindrome() function
+    # and return their boolean values
+    check_palin <- c()
+    for (i in input_split) {
+      result <- is.palindrome(i)
+      check_palin <- append(check_palin, result)
+    }
+    
+    # check and return index positions of TRUE
+    indx <- which(check_palin == TRUE)
+    
+    # use the index positions to filter input_split
+    palindromes <- input_split[indx]
+    
+    # filter out words that contain less than one character
+    palin <- palindromes[nchar(palindromes) > 1]
+    
+    return(noquote(palin))
+    
+  } else if(is.numeric(input)) {
+    # convert numeric input to character
+    num_con <- as.character(input)
+    
+    # clean out punctuation
+    input_clean <- tm::removePunctuation(num_con)
+    
+    # split the sentence into individual words
+    input_split <- c(unlist(strsplit(input_clean, split = " ")))
+    
+    # loop every word in the text through the is.palindrome() function
+    # and return their boolean values
+    check_palin <- c()
+    for (i in input_split) {
+      result <- is.palindrome(i)
+      check_palin <- append(check_palin, result)
+    }
+    
+    # check and return index positions of TRUE
+    indx <- which(check_palin == TRUE)
+    
+    # use the index positions to filter input_split
+    palindromes <- input_split[indx]
+    
+    # filter out numbers that contain less than one character
+    palin <- palindromes[nchar(palindromes) > 1]
+    
+    return(noquote(palin))
+    
+  }
+}
+
+my_text <- "Bob works in a shop on a street called Pop. His work ID is 444, and his manager owns a racecar."
+
+findPalindrome(my_text)
diff --git a/Desktop/open-source/R/string_manipulation/hamming_distance.r b/Desktop/open-source/R/string_manipulation/hamming_distance.r
new file mode 100644
index 00000000..03bb8225
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/hamming_distance.r
@@ -0,0 +1,30 @@
+# Hamming distance
+library(roxygen2)
+library(docstring)
+
+
+hamming_distance <- function(input1, input2) {
+  #' Find the hamming distance between two strings
+  #' 
+  #' @description Finds the hamming distance between two strings
+  #' @param input1 String
+  #' @param input2 String
+  #' @usage hamming_distance(input1, input2)
+  #' @details In information theory, the Hamming distance between two strings of equal length is the number of positions at which the corresponding symbols are different.
+  #' In other words, it measures the minimum number of substitutions required to change one string into the other, or the minimum number of errors that could have transformed one string into the other. 
+  #' In a more general context, the Hamming distance is one of several string metrics for measuring the edit distance between two sequences. It is named after the American mathematician Richard Hamming.
+  #' @references https://en.wikipedia.org/wiki/Hamming_distance 
+  
+  if (length(input1) != length(input2)) stop("String lengths must be the same")
+  
+  sum(input1 != input2)
+}
+
+
+x1 = strsplit("karolin", "")[[1]]
+y1 = strsplit("kathrin", "")[[1]]
+print(hamming_distance(x1, y1) == 3) # returns TRUE
+
+x2 = strsplit("0000", "")[[1]]
+y2 = strsplit("1111", "")[[1]]
+print(hamming_distance(x2, y2) == 4) # returns TRUE
diff --git a/Desktop/open-source/R/string_manipulation/is.anagram.r b/Desktop/open-source/R/string_manipulation/is.anagram.r
new file mode 100644
index 00000000..84196674
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/is.anagram.r
@@ -0,0 +1,22 @@
+is.anagram <- function(word1, word2) {
+  # Convert words to lowercase
+  word1 <- tolower(word1)
+  word2 <- tolower(word2)
+  
+  # Check if the words have the same length
+  if (nchar(word1) != nchar(word2)) {
+    return(FALSE)
+  }
+  
+  # Check if the sorted characters of the words are the same
+  sorted_word1 <- sort(strsplit(word1, "")[[1]])
+  sorted_word2 <- sort(strsplit(word2, "")[[1]])
+  
+  if (identical(sorted_word1, sorted_word2)) {
+    return(TRUE)
+  } else {
+    return(FALSE)
+  }
+}
+
+is.anagram(word1 = "rats",word2 = "star")
diff --git a/Desktop/open-source/R/string_manipulation/is.lower.r b/Desktop/open-source/R/string_manipulation/is.lower.r
new file mode 100644
index 00000000..c48699ac
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/is.lower.r
@@ -0,0 +1,12 @@
+is.lowercase <- function(string) {
+  # split the string at character level
+  string_split <- c(unlist(strsplit(string, split = "")))
+  # check if the split string exactly matches its lowercase version
+  check_case <- string_split == tolower(string_split)
+  # return a boolean value based on the outcome of the check
+  return(all(check_case))
+}
+
+is.lowercase("social")
+
+
diff --git a/Desktop/open-source/R/string_manipulation/is.uppercase.r b/Desktop/open-source/R/string_manipulation/is.uppercase.r
new file mode 100644
index 00000000..acc8926d
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/is.uppercase.r
@@ -0,0 +1,10 @@
+is.uppercase <- function(string) {
+  # split the string at character level
+  string_split <- c(unlist(strsplit(string, split = "")))
+  # check if the split string exactly matches its uppercase version
+  check_case <- string_split == toupper(string_split)
+  # return a boolean value based on the outcome of the check
+  return(all(check_case))
+}
+
+is.uppercase("BUSINESS")
diff --git a/Desktop/open-source/R/string_manipulation/kmp_string_matching.r b/Desktop/open-source/R/string_manipulation/kmp_string_matching.r
new file mode 100644
index 00000000..bde4bb07
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/kmp_string_matching.r
@@ -0,0 +1,343 @@
+# Knuth-Morris-Pratt (KMP) String Matching Algorithm
+#
+# The KMP algorithm efficiently finds all occurrences of a pattern in a text
+# by preprocessing the pattern to avoid unnecessary character comparisons.
+# It uses a "failure function" (also called "prefix function") to skip characters
+# intelligently when a mismatch occurs.
+#
+# Time Complexity: O(n + m) where n = text length, m = pattern length
+# Space Complexity: O(m) for the failure function array
+# 
+# This is a significant improvement over naive string matching O(n*m)
+#
+# Applications:
+# - Text editors (find/replace functionality)
+# - DNA sequence analysis in bioinformatics  
+# - Plagiarism detection systems
+# - Web search engines
+
+# Function to compute the failure function (prefix function)
+compute_failure_function <- function(pattern) {
+  #' Compute the failure function for KMP algorithm
+  #' @param pattern: Pattern string to preprocess
+  #' @return: Vector of failure function values
+  
+  m <- nchar(pattern)
+  failure <- rep(0, m)
+  
+  # failure[1] is always 0 (single character has no proper prefix/suffix)
+  if (m == 0) return(integer(0))
+  if (m == 1) return(0)
+  
+  j <- 0  # Length of previous longest prefix suffix
+  
+  for (i in 2:m) {
+    # Get current character
+    curr_char <- substr(pattern, i, i)
+    
+    # Handle mismatches by following failure links
+    while (j > 0 && substr(pattern, j + 1, j + 1) != curr_char) {
+      j <- failure[j]
+    }
+    
+    # If characters match, increment j
+    if (substr(pattern, j + 1, j + 1) == curr_char) {
+      j <- j + 1
+    }
+    
+    failure[i] <- j
+  }
+  
+  return(failure)
+}
+
+# Main KMP string matching algorithm
+kmp_search <- function(text, pattern) {
+  #' Find all occurrences of pattern in text using KMP algorithm
+  #' @param text: Text string to search in
+  #' @param pattern: Pattern string to search for
+  #' @return: Vector of starting positions (1-indexed) where pattern occurs
+  
+  n <- nchar(text)
+  m <- nchar(pattern)
+  
+  # Handle edge cases
+  if (m == 0) return(integer(0))
+  if (n == 0 || m > n) return(integer(0))
+  
+  # Precompute failure function
+  failure <- compute_failure_function(pattern)
+  
+  matches <- c()
+  j <- 0  # Index for pattern
+  
+  for (i in 1:n) {
+    # Get current character from text
+    curr_char <- substr(text, i, i)
+    
+    # Handle mismatches using failure function
+    while (j > 0 && substr(pattern, j + 1, j + 1) != curr_char) {
+      j <- failure[j]
+    }
+    
+    # If characters match, advance pattern index
+    if (substr(pattern, j + 1, j + 1) == curr_char) {
+      j <- j + 1
+    }
+    
+    # Check for complete pattern match
+    if (j == m) {
+      matches <- c(matches, i - m + 1)  # 1-indexed position
+      j <- failure[j]  # Prepare for next potential match
+    }
+  }
+  
+  return(matches)
+}
+
+# Function to find first occurrence only (more efficient)
+kmp_search_first <- function(text, pattern) {
+  #' Find first occurrence of pattern in text using KMP algorithm
+  #' @param text: Text string to search in
+  #' @param pattern: Pattern string to search for  
+  #' @return: Starting position (1-indexed) of first match, or -1 if not found
+  
+  n <- nchar(text)
+  m <- nchar(pattern)
+  
+  # Handle edge cases
+  if (m == 0) return(-1)
+  if (n == 0 || m > n) return(-1)
+  
+  # Precompute failure function
+  failure <- compute_failure_function(pattern)
+  
+  j <- 0  # Index for pattern
+  
+  for (i in 1:n) {
+    # Get current character from text
+    curr_char <- substr(text, i, i)
+    
+    # Handle mismatches using failure function
+    while (j > 0 && substr(pattern, j + 1, j + 1) != curr_char) {
+      j <- failure[j]
+    }
+    
+    # If characters match, advance pattern index
+    if (substr(pattern, j + 1, j + 1) == curr_char) {
+      j <- j + 1
+    }
+    
+    # Check for complete pattern match
+    if (j == m) {
+      return(i - m + 1)  # Return 1-indexed position
+    }
+  }
+  
+  return(-1)  # Pattern not found
+}
+
+# Function to count occurrences without storing positions
+kmp_count <- function(text, pattern) {
+  #' Count occurrences of pattern in text using KMP algorithm
+  #' @param text: Text string to search in
+  #' @param pattern: Pattern string to search for
+  #' @return: Number of occurrences
+  
+  n <- nchar(text)
+  m <- nchar(pattern)
+  
+  # Handle edge cases
+  if (m == 0) return(0)
+  if (n == 0 || m > n) return(0)
+  
+  # Precompute failure function
+  failure <- compute_failure_function(pattern)
+  
+  count <- 0
+  j <- 0  # Index for pattern
+  
+  for (i in 1:n) {
+    # Get current character from text
+    curr_char <- substr(text, i, i)
+    
+    # Handle mismatches using failure function
+    while (j > 0 && substr(pattern, j + 1, j + 1) != curr_char) {
+      j <- failure[j]
+    }
+    
+    # If characters match, advance pattern index
+    if (substr(pattern, j + 1, j + 1) == curr_char) {
+      j <- j + 1
+    }
+    
+    # Check for complete pattern match
+    if (j == m) {
+      count <- count + 1
+      j <- failure[j]  # Prepare for next potential match
+    }
+  }
+  
+  return(count)
+}
+
+# Naive string matching for comparison
+naive_search <- function(text, pattern) {
+  #' Naive string matching algorithm for performance comparison
+  #' @param text: Text string to search in
+  #' @param pattern: Pattern string to search for
+  #' @return: Vector of starting positions where pattern occurs
+  
+  n <- nchar(text)
+  m <- nchar(pattern)
+  matches <- c()
+  
+  if (m == 0 || n == 0 || m > n) return(matches)
+  
+  for (i in 1:(n - m + 1)) {
+    if (substr(text, i, i + m - 1) == pattern) {
+      matches <- c(matches, i)
+    }
+  }
+  
+  return(matches)
+}
+
+# Function to visualize the failure function
+visualize_failure_function <- function(pattern) {
+  #' Print a visual representation of the failure function
+  #' @param pattern: Pattern to analyze
+  
+  failure <- compute_failure_function(pattern)
+  m <- nchar(pattern)
+  
+  cat("Pattern:  ")
+  for (i in 1:m) {
+    cat(sprintf("%2s ", substr(pattern, i, i)))
+  }
+  cat("\n")
+  
+  cat("Index:    ")
+  for (i in 1:m) {
+    cat(sprintf("%2d ", i))
+  }
+  cat("\n")
+  
+  cat("Failure:  ")
+  for (i in 1:m) {
+    cat(sprintf("%2d ", failure[i]))
+  }
+  cat("\n\n")
+}
+
+# Example usage and testing
+cat("=== Knuth-Morris-Pratt (KMP) String Matching Algorithm ===\n\n")
+
+# Test 1: Basic pattern matching
+cat("1. Basic Pattern Matching\n")
+text1 <- "ABABDABACDABABCABCABCABCABC"
+pattern1 <- "ABC"
+
+cat("Text:    ", text1, "\n")
+cat("Pattern: ", pattern1, "\n")
+
+matches1 <- kmp_search(text1, pattern1)
+cat("KMP matches at positions:", paste(matches1, collapse = ", "), "\n")
+
+# Verify with naive approach
+naive_matches1 <- naive_search(text1, pattern1)
+cat("Naive matches at positions:", paste(naive_matches1, collapse = ", "), "\n")
+cat("Results match:", identical(matches1, naive_matches1), "\n\n")
+
+# Test 2: Pattern with repeating characters
+cat("2. Pattern with Repeating Characters\n")
+text2 <- "AABAACAADAABAABA"
+pattern2 <- "AABA"
+
+cat("Text:    ", text2, "\n")
+cat("Pattern: ", pattern2, "\n")
+
+visualize_failure_function(pattern2)
+
+matches2 <- kmp_search(text2, pattern2)
+cat("Matches at positions:", paste(matches2, collapse = ", "), "\n")
+
+# Show the actual matches
+for (pos in matches2) {
+  match_str <- substr(text2, pos, pos + nchar(pattern2) - 1)
+  cat("Position", pos, ":", match_str, "\n")
+}
+cat("\n")
+
+# Test 3: Edge cases
+cat("3. Edge Cases\n")
+cat("Empty pattern:", length(kmp_search("hello", "")), "matches\n")
+cat("Empty text:", length(kmp_search("", "hello")), "matches\n") 
+cat("Pattern longer than text:", length(kmp_search("hi", "hello")), "matches\n")
+cat("Single character pattern:", paste(kmp_search("abcabc", "a"), collapse = ", "), "\n")
+cat("Pattern not in text:", paste(kmp_search("hello world", "xyz"), collapse = ", "), "\n")
+cat("Identical strings:", paste(kmp_search("hello", "hello"), collapse = ", "), "\n")
+cat("Pattern at start:", paste(kmp_search("hello world", "hello"), collapse = ", "), "\n")
+cat("Pattern at end:", paste(kmp_search("world hello", "hello"), collapse = ", "), "\n\n")
+
+# Test 4: Performance comparison
+cat("4. Performance Comparison\n")
+# Create a text with many potential false matches
+repeated_text <- paste(rep("AAAAB", 200), collapse = "")
+repeated_pattern <- "AAAAB"
+
+cat("Text length:", nchar(repeated_text), "\n")
+cat("Pattern:", repeated_pattern, "\n")
+
+# Time the KMP algorithm
+start_time <- Sys.time()
+kmp_result <- kmp_search(repeated_text, repeated_pattern)
+kmp_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+# Time the naive algorithm
+start_time <- Sys.time()
+naive_result <- naive_search(repeated_text, repeated_pattern)
+naive_time <- as.numeric(Sys.time() - start_time, units = "secs")
+
+cat("KMP found", length(kmp_result), "matches in", sprintf("%.6f", kmp_time), "seconds\n")
+cat("Naive found", length(naive_result), "matches in", sprintf("%.6f", naive_time), "seconds\n")
+
+if (naive_time > 0 && kmp_time > 0) {
+  speedup <- naive_time / kmp_time
+  cat("KMP speedup:", sprintf("%.2f", speedup), "x faster\n")
+}
+cat("\n")
+
+# Test 5: Real-world example - DNA sequence matching
+cat("5. DNA Sequence Matching Example\n")
+dna_sequence <- "ATCGATCGATCGAATCGATCGATCGAATCGATCG"
+dna_pattern <- "ATCG"
+
+cat("DNA Sequence:", dna_sequence, "\n")
+cat("Pattern:     ", dna_pattern, "\n")
+
+dna_matches <- kmp_search(dna_sequence, dna_pattern)
+cat("Pattern occurs at positions:", paste(dna_matches, collapse = ", "), "\n")
+cat("Total occurrences:", length(dna_matches), "\n\n")
+
+# Test 6: Failure function examples
+cat("6. Failure Function Examples\n")
+patterns <- c("ABCABCAB", "AAAA", "ABCDE", "ABABABAB")
+
+for (pattern in patterns) {
+  cat("Pattern:", pattern, "\n")
+  visualize_failure_function(pattern)
+}
+
+# Test 7: Case sensitivity
+cat("7. Case Sensitivity\n")
+text_case <- "Hello World Hello"
+pattern_case <- "hello"
+matches_case <- kmp_search(text_case, pattern_case)
+cat("Text:", text_case, "\n")
+cat("Pattern:", pattern_case, "\n")
+cat("Matches (case-sensitive):", paste(matches_case, collapse = ", "), "\n")
+
+# Case-insensitive version
+matches_insensitive <- kmp_search(tolower(text_case), tolower(pattern_case))
+cat("Matches (case-insensitive):", paste(matches_insensitive, collapse = ", "), "\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/string_manipulation/levenshtein.r b/Desktop/open-source/R/string_manipulation/levenshtein.r
new file mode 100644
index 00000000..73ac2bd3
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/levenshtein.r
@@ -0,0 +1,38 @@
+# Levenshtein Distance in R
+# Calculates minimum number of edits (insert, delete, replace)
+# to convert one string into another and prints the distance.
+
+levenshtein_distance <- function(s1, s2) {
+  n <- nchar(s1)
+  m <- nchar(s2)
+  
+  # Initialize DP matrix
+  dp <- matrix(0, nrow = n + 1, ncol = m + 1)
+  
+  for (i in 0:n) dp[i + 1, 1] <- i
+  for (j in 0:m) dp[1, j + 1] <- j
+  
+  # Fill DP table
+  for (i in 1:n) {
+    for (j in 1:m) {
+      if (substr(s1, i, i) == substr(s2, j, j)) {
+        dp[i + 1, j + 1] <- dp[i, j]
+      } else {
+        dp[i + 1, j + 1] <- min(
+          dp[i, j + 1] + 1,   # Deletion
+          dp[i + 1, j] + 1,   # Insertion
+          dp[i, j] + 1        # Substitution
+        )
+      }
+    }
+  }
+  
+  return(dp[n + 1, m + 1])
+}
+
+# Interactive input
+s1 <- tolower(readline("Enter first string: "))
+s2 <- tolower(readline("Enter second string: "))
+
+distance <- levenshtein_distance(s1, s2)
+cat("Levenshtein distance between '", s1, "' and '", s2, "' is:", distance, "\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/string_manipulation/longest.palindromic.subsequence.r b/Desktop/open-source/R/string_manipulation/longest.palindromic.subsequence.r
new file mode 100644
index 00000000..7ee8236d
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/longest.palindromic.subsequence.r
@@ -0,0 +1,62 @@
+# Longest Palindromic Subsequence in R
+# Author: sgindeed
+# Description: Finds and prints the longest palindromic subsequence and its length
+
+# Ask for user input
+input.string <- readline(prompt = "Enter a string: ")
+
+# Convert string to lowercase for consistency
+clean.string <- tolower(input.string)
+
+# Get length of string
+n <- nchar(clean.string)
+
+# Split string into characters
+chars <- strsplit(clean.string, "")[[1]]
+
+# Initialize DP table for lengths
+dp <- matrix(0, nrow = n, ncol = n)
+
+# Each single character is a palindrome of length 1
+for (i in seq_len(n)) {
+  dp[i, i] <- 1
+}
+
+# Fill the DP table
+for (cl in 2:n) {
+  for (i in 1:(n - cl + 1)) {
+    j <- i + cl - 1
+    if (chars[i] == chars[j] && cl == 2) {
+      dp[i, j] <- 2
+    } else if (chars[i] == chars[j]) {
+      dp[i, j] <- dp[i + 1, j - 1] + 2
+    } else {
+      dp[i, j] <- max(dp[i + 1, j], dp[i, j - 1])
+    }
+  }
+}
+
+# Function to reconstruct the subsequence
+reconstructLPS <- function(chars, dp, i, j) {
+  if (i > j) {
+    return("")
+  }
+  if (i == j) {
+    return(chars[i])
+  }
+  if (chars[i] == chars[j]) {
+    return(paste0(chars[i], reconstructLPS(chars, dp, i + 1, j - 1), chars[j]))
+  }
+  if (dp[i + 1, j] > dp[i, j - 1]) {
+    return(reconstructLPS(chars, dp, i + 1, j))
+  } else {
+    return(reconstructLPS(chars, dp, i, j - 1))
+  }
+}
+
+# Get the longest palindromic subsequence
+lps <- reconstructLPS(chars, dp, 1, n)
+
+# Display the result
+cat("Longest Palindromic Subsequence:", lps, "\n")
+cat("Length:", nchar(lps), "\n")
diff --git a/Desktop/open-source/R/string_manipulation/longest.substring.no.repeat.r b/Desktop/open-source/R/string_manipulation/longest.substring.no.repeat.r
new file mode 100644
index 00000000..b4898ba4
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/longest.substring.no.repeat.r
@@ -0,0 +1,39 @@
+# Longest Substring Without Repeating Characters in R
+# Author: sgindeed
+# Description: Finds the length of the longest substring without repeating characters
+
+# Ask for user input
+input.string <- readline(prompt = "Enter a string: ")
+
+# Convert the string to lowercase for case-insensitive processing (optional)
+clean.string <- tolower(input.string)
+
+# Split string into characters
+chars <- strsplit(clean.string, "")[[1]]
+
+# Initialize variables
+hash.table <- list()  # stores last index of characters
+max.length <- 0
+start <- 1  # start of current window
+
+# Iterate over characters
+for (i in seq_along(chars)) {
+  char <- chars[i]
+  
+  # If character was seen before and is inside current window
+  if (!is.null(hash.table[[char]]) && hash.table[[char]] >= start) {
+    start <- hash.table[[char]] + 1  # move start to one after previous occurrence
+  }
+  
+  # Update last seen index of the character
+  hash.table[[char]] <- i
+  
+  # Update max length
+  current.length <- i - start + 1
+  if (current.length > max.length) {
+    max.length <- current.length
+  }
+}
+
+# Display the result
+cat("Length of the longest substring without repeating characters:", max.length, "\n")
diff --git a/Desktop/open-source/R/string_manipulation/manacher.longest.palindrome.r b/Desktop/open-source/R/string_manipulation/manacher.longest.palindrome.r
new file mode 100644
index 00000000..29b1bc69
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/manacher.longest.palindrome.r
@@ -0,0 +1,34 @@
+# Manacher's Algorithm – Longest Palindromic Substring in R
+
+longest_palindrome <- function(s) {
+  T <- paste0("^#", paste(unlist(strsplit(s, "")), collapse = "#"), "#$")
+  n <- nchar(T)
+  P <- integer(n)
+  center <- 0
+  right <- 0
+  
+  for (i in 2:(n - 1)) {
+    mirror <- 2 * center - i
+    if (i < right)
+      P[i] <- min(right - i, P[mirror])
+    
+    while (substr(T, i + (1 + P[i]), i + (1 + P[i])) ==
+           substr(T, i - (1 + P[i]), i - (1 + P[i])))
+      P[i] <- P[i] + 1
+    
+    if (i + P[i] > right) {
+      center <- i
+      right <- i + P[i]
+    }
+  }
+  
+  max_len <- max(P)
+  center_index <- which.max(P)
+  start <- (center_index - max_len) / 2
+  palindrome <- substr(s, start + 1, start + max_len)
+  return(palindrome)
+}
+
+s <- tolower(readline("Enter a string: "))
+result <- longest_palindrome(s)
+cat("Longest Palindromic Substring:", result, "\n")
\ No newline at end of file
diff --git a/Desktop/open-source/R/string_manipulation/maskwords.r b/Desktop/open-source/R/string_manipulation/maskwords.r
new file mode 100644
index 00000000..24488def
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/maskwords.r
@@ -0,0 +1,35 @@
+maskWords <- function(text, mask) {
+  text_split <- c(unlist(strsplit(text, split = " ")))
+
+  post_n <- c()
+  for (i in text_split) {
+    post_n <- c(
+      post_n,
+      if (i %in% c(
+        "birds",
+        "BIRDS",
+        "Birds",
+        "market",
+        "Market",
+        "MARKET",
+        "street",
+        "STREET",
+        "Street"
+      )) {
+        tolower(i)
+      } else {
+        i
+      }
+    )
+  }
+
+  clean_text <- gsub("\\b(birds|street|market)\\b", mask, post_n)
+
+  clean_text <- gsub("\n", "", clean_text)
+
+  return(paste(clean_text, collapse = " "))
+}
+
+post <- "The lady bought groceries from the market, but some of them spilled on the street, and the birds helped themselves."
+
+maskWords(text = post,mask = "$$$")
diff --git a/Desktop/open-source/R/string_manipulation/min.palindromic.insert.r b/Desktop/open-source/R/string_manipulation/min.palindromic.insert.r
new file mode 100644
index 00000000..8afdbbd9
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/min.palindromic.insert.r
@@ -0,0 +1,72 @@
+#' Computes the minimum number of characters to insert to make a string a palindrome.
+#'
+#' @param s A character string (case-insensitive).
+#' @return A list containing:
+#'   \item{min_insertions}{Minimum number of insertions required.}
+#'   \item{palindrome}{One possible resulting palindrome.}
+#' @details
+#' Uses dynamic programming to compute the minimum insertions in O(n^2) time and space.
+#' Also reconstructs one possible palindrome.
+#'
+#' @examples
+#' min_palindrome_insertion("race")
+#' # Returns 3 insertions and palindrome "ecarace"
+# Minimum Palindrome Insertion in R
+# Computes the minimum number of characters to insert to make a string a palindrome
+# Also prints one possible resulting palindrome.
+
+min_palindrome_insertion <- function(s) {
+  n <- nchar(s)
+  chars <- strsplit(s, "")[[1]]
+  
+  # DP table to store minimum insertions for substring s[i..j]
+  dp <- matrix(0, nrow = n, ncol = n)
+  
+  # Fill the table
+  for (length_sub in 2:n) {
+    for (i in 1:(n - length_sub + 1)) {
+      j <- i + length_sub - 1
+      if (chars[i] == chars[j]) {
+        dp[i, j] <- dp[i + 1, j - 1]
+      } else {
+        dp[i, j] <- min(dp[i + 1, j], dp[i, j - 1]) + 1
+      }
+    }
+  }
+  
+  # Reconstruct one possible palindrome
+  i <- 1
+  j <- n
+  length_sub <- dp[1, n] + n
+  res <- character(length_sub)
+  left <- 1
+  right <- length(res)
+  
+  while (i <= j) {
+    if (chars[i] == chars[j]) {
+      res[left] <- chars[i]
+      res[right] <- chars[j]
+      i <- i + 1
+      j <- j - 1
+    } else if (dp[i + 1, j] < dp[i, j - 1]) {
+      res[left] <- chars[i]
+      res[right] <- chars[i]
+      i <- i + 1
+    } else {
+      res[left] <- chars[j]
+      res[right] <- chars[j]
+      j <- j - 1
+    }
+    left <- left + 1
+    right <- right - 1
+  }
+  
+  list(min_insertions = dp[1, n], palindrome = paste(res, collapse = ""))
+}
+
+# --- Interactive input ---
+s <- tolower(readline("Enter a string: "))
+
+result <- min_palindrome_insertion(s)
+cat("Minimum insertions required:", result$min_insertions, "\n")
+cat("One possible resulting palindrome:", result$palindrome, "\n")
diff --git a/Desktop/open-source/R/string_manipulation/minimum.window.substring.r b/Desktop/open-source/R/string_manipulation/minimum.window.substring.r
new file mode 100644
index 00000000..c220ecc3
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/minimum.window.substring.r
@@ -0,0 +1,66 @@
+# Minimum Window Substring in R
+# Author: sgindeed
+# Description: Finds the smallest substring of s that contains all characters of t
+
+# Ask for inputs
+s <- readline(prompt = "Enter main string: ")
+t <- readline(prompt = "Enter target characters: ")
+
+# Convert to lowercase for case-insensitivity
+s <- tolower(s)
+t <- tolower(t)
+
+# Edge case
+if (nchar(s) == 0 || nchar(t) == 0) {
+  cat("Empty input. Exiting.\n")
+  quit(save = "no")
+}
+
+# Convert to char arrays
+s_chars <- strsplit(s, "")[[1]]
+t_chars <- strsplit(t, "")[[1]]
+
+# Frequency of characters in t
+t_count <- table(t_chars)
+window_count <- list()
+
+required <- length(t_count)
+formed <- 0
+
+left <- 1
+right <- 0
+min_len <- Inf
+min_window <- ""
+
+# Sliding window
+while (right < length(s_chars)) {
+  right <- right + 1
+  char <- s_chars[right]
+  window_count[[char]] <- (window_count[[char]] %||% 0) + 1
+  
+  if (!is.na(t_count[char]) && window_count[[char]] == t_count[char]) {
+    formed <- formed + 1
+  }
+  
+  # Try to contract the window
+  while (left <= right && formed == required) {
+    if ((right - left + 1) < min_len) {
+      min_len <- right - left + 1
+      min_window <- paste0(s_chars[left:right], collapse = "")
+    }
+    
+    left_char <- s_chars[left]
+    window_count[[left_char]] <- window_count[[left_char]] - 1
+    if (!is.na(t_count[left_char]) && window_count[[left_char]] < t_count[left_char]) {
+      formed <- formed - 1
+    }
+    left <- left + 1
+  }
+}
+
+if (is.infinite(min_len)) {
+  cat("No valid window found.\n")
+} else {
+  cat("Minimum window substring:", min_window, "\n")
+  cat("Length:", min_len, "\n")
+}
diff --git a/Desktop/open-source/R/string_manipulation/rearrangeways.r b/Desktop/open-source/R/string_manipulation/rearrangeways.r
new file mode 100644
index 00000000..c2e1636c
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/rearrangeways.r
@@ -0,0 +1,33 @@
+rearrangeWays <- function(string, as_report = TRUE){
+  
+  if(as_report){ # conditional statement
+    
+    # split the string into letters
+    string_split <- c(unlist(strsplit(string,split = "")))
+    
+    # get the factorial of the letters vector
+    possible_ways <- factorial(length(string_split))
+    
+    # create the answer text
+    answer <- paste(string, "can be rearranged in", possible_ways, "possible ways")
+    
+    
+    return(noquote(answer))
+    
+    
+  }else{
+    
+    # split the string into letters
+    string_split <- c(unlist(strsplit(string,split = "")))
+    
+    # get the factorial of the letters vector
+    possible_ways <- factorial(length(string_split))
+    
+    return(possible_ways)
+    
+  }
+  
+  
+}
+
+rearrangeWays(string = "straight")
diff --git a/Desktop/open-source/R/string_manipulation/shortest.common.supersequence.r b/Desktop/open-source/R/string_manipulation/shortest.common.supersequence.r
new file mode 100644
index 00000000..712a0aa7
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/shortest.common.supersequence.r
@@ -0,0 +1,57 @@
+# Shortest Common Supersequence (SCS) in R
+# Finds the shortest string that contains both input strings as subsequences.
+
+shortest_common_supersequence <- function(X, Y) {
+  m <- nchar(X)
+  n <- nchar(Y)
+  
+  # Initialize DP table for Longest Common Subsequence (LCS)
+  dp <- matrix(0, nrow = m + 1, ncol = n + 1)
+  
+  for (i in 1:m) {
+    for (j in 1:n) {
+      if (substr(X, i, i) == substr(Y, j, j)) {
+        dp[i + 1, j + 1] <- dp[i, j] + 1
+      } else {
+        dp[i + 1, j + 1] <- max(dp[i, j + 1], dp[i + 1, j])
+      }
+    }
+  }
+  
+  # Backtrack to build the SCS
+  i <- m; j <- n
+  scs <- ""
+  while (i > 0 && j > 0) {
+    if (substr(X, i, i) == substr(Y, j, j)) {
+      scs <- paste0(substr(X, i, i), scs)
+      i <- i - 1
+      j <- j - 1
+    } else if (dp[i, j + 1] > dp[i + 1, j]) {
+      scs <- paste0(substr(X, i, i), scs)
+      i <- i - 1
+    } else {
+      scs <- paste0(substr(Y, j, j), scs)
+      j <- j - 1
+    }
+  }
+  
+  # Add remaining characters from X or Y
+  while (i > 0) {
+    scs <- paste0(substr(X, i, i), scs)
+    i <- i - 1
+  }
+  while (j > 0) {
+    scs <- paste0(substr(Y, j, j), scs)
+    j <- j - 1
+  }
+  
+  return(list(length = nchar(scs), supersequence = scs))
+}
+
+# Interactive input
+X <- tolower(readline("Enter first string: "))
+Y <- tolower(readline("Enter second string: "))
+
+result <- shortest_common_supersequence(X, Y)
+cat("Length of SCS:", result$length, "\n")
+cat("Shortest Common Supersequence:", result$supersequence, "\n")
diff --git a/Desktop/open-source/R/string_manipulation/unique.letters.count.r b/Desktop/open-source/R/string_manipulation/unique.letters.count.r
new file mode 100644
index 00000000..8083ec3f
--- /dev/null
+++ b/Desktop/open-source/R/string_manipulation/unique.letters.count.r
@@ -0,0 +1,21 @@
+# Ask for user input
+input.string <- readline(prompt = "Enter a string: ")
+
+# Convert to lowercase and remove non-letter characters
+# [^a-zA-Z] ensures both uppercase and lowercase letters are kept before conversion
+clean.string <- tolower(gsub("[^a-zA-Z]", "", input.string))
+
+# Split string into individual letters
+letters.vec <- strsplit(clean.string, "")[[1]]
+
+# Get unique letters
+unique.letters <- unique(letters.vec)
+
+# Count occurrences of each unique letter (only for unique ones)
+letter.counts <- table(letters.vec)[unique.letters]
+
+# Display results
+cat("Unique letters and their counts:\n")
+for (letter in unique.letters) {
+  cat(letter, ":", letter.counts[letter], "\n")
+}