feat: add algorithm interpolation

JournalDeBord.md

@@ -6,6 +6,6 @@
 | 11.11.2024-18.11.2024 | Récupérer les données (200000) et tester la librairie pour faire des graphes | J'ai créer un projet spring boot qui permet de récupérer les données en faisant plusieurs appels à l'api Binance | Problème avec la librairie des graphiques : le graphique s'affiche mais pas les candles |  |
 | 18.11.2024-26.11.2024 | Afficher les données avec la librairie + Voir le temps que prends le programme pour récupérer 1 an de données + Mise en cache des données si récupération trop longue | Affichage des données avec la librairie. Il faut environ 1 minute pour récupérer 1 an de données. L'utilisateur peut choisir les dates qu'il veut. | Affichage des données pour plus de 10 jours : problème de chevauchement des timestamp de la 1ère requête et de la 2ème |  |
 | 26.11.2024-02.12.2024 | Commencer à implémenter le simulateur et commencer l'introduction | Début d'une introduction et implémentation d'un ticker (déclencher un évènement toutes les $x$ secondes) |  |  |
-
+| 02.12.2024-09.12.2024 | Continuer de faire la doc et avancement du simulateur | Développement de l'introduction + ajout des choix technologiques + debut d'algo pour approximation du prix | On connait que les x et y de 2 points et les y des 2 autres points -> problème fonction 1er degré -> droite | Tester algo d'approximation du prix avec des données que l'on connait pour être sûr d'avoir la bonne approximation |
 
 <!-- |  |  |  |  |  | -->
\ No newline at end of file

documentation.md

 # Projet de semestre 
+
+- [ ] [Ajouter la structure de la documentation](#structure_doc)
+- [ ] [Description des routes de l'API](#description_routes_API)
+
 ## Introduction
-Le trading de cryptomonnaies se démocratise de plus en plus notamment grâce à la multiplication des plateformes de trading comme Binance, Coinbase ou encore Crypto\.com. Ces plateformes permettent d'acheter et de vendre des cryptomonnaies assez facilement notamment grâce à leurs applictions sur smartphone. De plus, beaucoup de personnes remarquent la grande volatilité des prix des cryptomonnaies et font du profit grâce à ces variations de prix. Cependant, bien que certains fassent effectivement des bénéfices, d'autres font de grosses pertes. Et c'est pourquoi les simulateurs de trading de cryptomonnaies sont utiles. Ces simulateurs permettent de s'entrainer avec les stratégies existantes sans pour autant avoir à réellement investir dans une cryptomonnaie et risquer de tout perdre.
 
-Les simulateurs de trading de cryptomonnaies sont très utiles pour tester et améliorer les différents outils et stratégies de trading de cryptomonnaies. Ce projet a pour but de refactoriser un simulateur de trading de cryptomonnaies existant, développé en Python, dans un langage orienté objet.
+Le trading de cryptomonnaies se démocratise de plus en plus notamment grâce à la multiplication des plateformes de trading comme Binance, Coinbase ou encore Crypto\.com. Ces plateformes permettent d'acheter et de vendre des cryptomonnaies assez facilement notamment grâce à leurs applictions sur smartphone. Cette accessibilité et cette simplification de l'achat et revente de cryptomonnaies permet à un plus grand public, même débutant, d'utiliser et de posséder des cryptomonnaies.
+
+Avec une augmentation de 33% sur un an, le nombre de personnes détennant des cryptomonnaies dans le monde atteint 562 millions en 2024 contre 420 millions en 2023.
+(https://journalducoin.com/actualites/bilan-adoption-cryptos-monde-2024-rapport-triple-a/)
+Cette augmentation de l'utilisation des cryptomonnaies montre que l'intérêt pour les cryptomonnaies augmentent que ce soit pour un simple investissement en vue de faire un profit ou même, pour certains, d'avoir une alternative aux monnaies fiduciaires.
+
+Beaucoup de personnes remarquent la grande volatilité des prix des cryptomonnaies et font du profit grâce à ces variations de prix. Cependant, bien que certains fassent effectivement des bénéfices, d'autres font de grosses pertes. Et c'est pourquoi les simulateurs de trading de cryptomonnaies sont utiles. Ces simulateurs permettent de s'entrainer avec les stratégies existantes et de mieux comprendre le marché des cryptomonnaies sans pour autant avoir à réellement investir dans une cryptomonnaie et risquer de perdre leur capital investit. Ces simulateurs reproduisent les fluctuations des différentes cryptomonnaies soit en temps réel soit sur les données passées. S'entrainer sur une période passée peut paraître à première vue pas vraiment utile, mais en réalité cela peut permettre de s'entrainer sur une situation passée qui pourrait se reproduire à l'avenir.
+Les simulateurs sont donc aussi utiles à des débutants, pour leur faire découvrir le trading de cryptomonnaies sans leur faire perdre d'argent, ils peuvent y découvrir ce qu'est un ordre d'achat ou de vente et comment en placer, qu'à des traders plus experimentés en leur permettant de revenir sur des périodes passées, ils peuvent y tester de nouvelles stratégies en utilisant les différents indicateurs à disposition. En réalisant ces tests sur un simulateur, il pourra par la suite voir les résultats obtenus et les appliquer dans le vrai trading de cryptomonnaies. 
+Les simulateurs de trading de cryptomonnaies sont donc très utiles pour découvrir le trading de cryptomonnaies, pour tester et améliorer les différents outils et stratégies de trading de cryptomonnaies.
 
-Ce projet est la suite de projets déjà réalisés par Mr. Pighini, Mr. Toniutt et Mr. SouzaLuz. Il est réalisé dans le cadre des projets de semestre et de Bachelor à HEPIA et a pour objectif d'améliorer le simulateur de trading de cryptomonnaies existant, notamment grâce à des notions de développement logicielle comme la programmation orientée objet. 
+Ce projet est la suite de projets déjà réalisés par Mr. Pighini, Mr. Toniutt et Mr. SouzaLuz. Il est réalisé dans le cadre des projets de semestre et de Bachelor à HEPIA et a pour objectif d'améliorer le simulateur de trading de cryptomonnaies existant, notamment grâce à des notions de développement logiciel comme la programmation orientée objet. Ces méthodes de développement permettront de modulariser le code pour plusieurs raisons comme une meilleure maintanabilité, un code plus intuitif et de meilleures performances. En plus de la réimplémentation du projet dans un langage orienté objet, les données seront récupérer d'une API et plus d'une base de données. Ce changement de source de données nous permet d'avoir les données les plus récentes et plus d'être restreint à des données fixes sur une certaine durée comme avoir les données de l'année 2022 seulement.
+
+
+<a id="structure_doc" style="color: inherit; text-decoration: none;">Structure de la documentation</a>
 
 ## Cahier des charges
 
@@ -13,3 +27,74 @@ Ce projet est la suite de projets déjà réalisés par Mr. Pighini, Mr. Toniutt
 - Créer le simulateur permettant de simuler l'évolution du prix d'une cryptomonnaie toutes les $x$ secondes
 - Implémenter les différents indicateurs
 - Créer et gérer un système de cache pour les données (moins important pour le moment)
+
+## Simulateurs de trading de cryptomonnaies existants
+
+Voici certains simulateurs de trading de cryptomonnaies déjà existant :
+BitGasp :
+https://app.bitsgap.com/
+Avatrade :
+https://webtrader6.avatrade.com/
+
+
+## Choix technologiques
+
+### Frontend
+Pour faire l'affichage d'un graphe pour l'affichage des bougies, j'utilise la librairie lightweight-charts open-source de TradingView.
+Pour l'instant, je fais un frontend simple HTML-CSS-JS et plus tard je ferai un frontend plus complexe et plus réactif en utilisant soit Angular soit Vue.js ou soit React.
+### Backend 
+
+#### Java/Spring Boot
+Avantages :
+  - Configuration du projet simplifiée
+  - Spring Boot utilise Maven ou Gradle pour la gestion des dépendances  et de la compatibilité entre elles
+  - Gestion des objets et de leur cycle de vie
+  - Plusieurs fonctionnalités simplifiées comme la connexion à une base de données ou l'implémentation d'une API
+
+Désavantages :
+  - La prise en main peut être compliquée notamment si l'on ne connait pas les différentes annotations et à quoi elles servent
+
+#### C#
+Avantages :
+  - Accès au framework .NET
+  
+Désavantages :
+  - Moins de librairies open-source
+  - Implémentation d'une API plus compliqué qu'avec Spring Boot
+
+#### Python
+Avantages :
+  - Prise en main facile pour les débutants avec de nombreuses fonctions et librairies déjà implémentées qui ne le sont pas forcément dans d'autres langages
+  - Implémentation d'une API assez simple grâce à FastAPI ou Flask
+
+Désavantages :
+  - Langage interprété, moins bonnes performances
+  - Pas réellement orienté objet
+
+#### Node.js/Typescript
+Avantages :
+  - Gestionnaire de package NPM
+
+Désavantages :
+  - Temps de transpilation
+
+### Récupération des données
+
+Listes de plusieurs API :
+- Binance
+- HitBTC
+- Kraken
+- CryptoCompare
+- Poloniex
+
+Pour récupérer les bougies (candles) nécessaires pour pouvoir faire l'interpolation du prix toutes les X secondes, nous récupérons les bougies à intervalles de 15 minutes depuis l'API de Binance.
+
+La transmission des donnéees depuis le backend vers le frontend se fait via une API dont les routes seront décrites plus tard.
+
+
+<a id="description_routes_API" style="color: inherit; text-decoration: none;">Description des routes de l'API</a>
+
+Lien sur Spring Boot https://www.ibm.com/topics/java-spring-boot
+Lien sur C# https://dyma.fr/blog/csharp/
+
+

testApi/src/main/java/com/example/testapi/controller/ApiController.java

@@ -2,6 +2,7 @@ package com.example.testapi.controller;
 
 import com.example.testapi.model.DateRange;
 import com.example.testapi.service.ApiService;
+import com.example.testapi.service.SimulateurService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
@@ -14,11 +15,14 @@ public class ApiController {
 
     private final ApiService apiService;
 
+    private final SimulateurService simulateur;
+
     private DateRange dateRange;
 
     @Autowired
-    public ApiController(ApiService apiService) {
+    public ApiController(ApiService apiService, SimulateurService simulateur) {
         this.apiService = apiService;
+        this.simulateur = simulateur;
     }
 
     @GetMapping("/btcusdt")
@@ -35,6 +39,22 @@ public class ApiController {
         return Collections.emptyMap();
     }
 
+    @GetMapping("/startSimu")
+    public void testSomeFonctionnalities() {
+        this.simulateur.startSimulation();
+        long[] x_tab = {};
+        float[] y = new float[4];
+        this.simulateur.approximatePrice(x_tab, y, 3);
+    }
+
+    @GetMapping("/stopSimu")
+    public void stopSimulation() {
+        this.simulateur.stopSimulation();
+    }
+
+
+
+
 
 }
 

testApi/src/main/java/com/example/testapi/model/DateRange.java

 package com.example.testapi.model;
 
+import org.springframework.stereotype.Component;
+
 import java.time.LocalDate;
 import java.time.ZoneId;
 

testApi/src/main/java/com/example/testapi/service/SimulateurService.java

 package com.example.testapi.service;
 
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.util.function.LongConsumer;
+
+@Service
 public class SimulateurService {
     private Ticker ticker;
     private int periodApproximationSec;
 
-    public SimulateurService(int periodApproximationSec) {
+    public SimulateurService(@Value("${simulateur.ApproximationPeriod}") int periodApproximationSec) {
         this.periodApproximationSec = periodApproximationSec;
-//        this.ticker = new Ticker(this.);
+        Runnable task = () -> System.out.println("Print après " + this.periodApproximationSec + " sec");
+        this.ticker = new Ticker(task);
     }
 
-    public void pricesApproximations() {
-        ticker.start(this.periodApproximationSec);
+    public void startSimulation() {
+        this.ticker.start(this.periodApproximationSec);
+    }
+
+    public void stopSimulation() {
+        this.ticker.stop();
+    }
 
-        ticker.stop();
+    public void approximatePrice(long[] x_tab, float[] y, int n) {
+        LongConsumer funcApproxPrice = (long x) -> {
+            double[] poly_pts = new double[n];
+            for (int i = 0; i < x_tab.length; i++) {
+                double res = 1;
+                for (int j = 0; j < n; j++) {
+                    if (i != j) {
+                        res *= (double) (x - x_tab[j]) / (x_tab[i] - x_tab[j]);
+                    }
+                }
+                poly_pts[i] = res;
+            }
+            double poly = 0;
+            for (int i = 0; i < n; i++) {
+                poly += y[i] * poly_pts[i];
+            }
+        };
     }
 }

testApi/src/main/java/com/example/testapi/service/Ticker.java

@@ -18,7 +18,6 @@ public class Ticker {
     }
 
     public void stop() {
-        executorService.shutdown();
+        executorService.shutdownNow();
     }
-
 }

testApi/src/main/resources/application.properties

@@ -2,5 +2,5 @@ spring.application.name=testApi
 server.port=8080
 spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
 
-
+simulateur.ApproximationPeriod=1