OpenLLM-France/wikimedia huggingface dataset:
# Partage de fichiers sur Internet/Direct Connect/Se connecter
## Choisir un client

comparatif ; mise à jour
| Client | Windows | Mac OS X | GNU/Linux | Autres plate-formes | Licence |
| DC++ | oui | non | oui | non | Libre |
| ShakesPeer | non | oui | non | non | Libre |
* ↑ Il s'agit en fait d'un portage appelé LinuxDC++
* 1 2 GPL

## Trouver des hubs

La première façon de trouver des hubs et de chercher sur le Web. Beaucoup de hubs ont un site qui explique comment le rejoindre.
Un autre façon est d'aller sur des sites spécialisés dans le référencement des hubs et qui proposents des fichiers hublist, il suffit de fournir l'adresse à Direct Connect qui pourra charger toutes les informations. Exemple de sites :
* http://www.openhublist.org/
* http://www.dchublist.com/
# Partage de fichiers sur Internet/Les sites d'hébergement de fichiers en un clic

Vous pouvez souhaiter mettre à la disposition d'autres internautes des fichiers que vous avez sur votre ordinateur. Qu'il s'agisse de partager des fichiers avec les membres d'un forum que vous fréquentez ou de mettre des fichiers sur le Web afin d'en faire profiter vos amis ou votre famille : ce supplément vous expliquera tout.
Pour cela, vous allez envoyer un fichier depuis votre ordinateur vers Internet. C'est le contraire du téléchargement qui consiste à transférer un fichier depuis le réseau sur votre ordinateur : on parle alors de « téleverser » un fichier ou de l'« upload » d'un fichier (c'est le terme anglais).
# Mathc complexes/a207

Déterminant

## Produit en croix dans C$^3$ par le déterminant

u x v :
* Valeurs aléatoires
* Valeurs aléatoires avec la fonction : UxV_mZ;
u x v == - v x u :
* Valeurs aléatoires
* Valeurs aléatoires avec la fonction : UxV_mZ;
u x (v+w) == (uxv) + (uxw) :
* Valeurs aléatoires
* Valeurs aléatoires avec la fonction : UxV_mZ;
(v+w) x u == (vxu) + (wxu):
* Valeurs aléatoires
* Valeurs aléatoires avec la fonction : UxV_mZ;
u.(u x v) == det(A) == 0 :
* Valeurs aléatoires
* Valeurs aléatoires avec la fonction : UxV_mZ;
w.(u x v) == det(A) :
* Valeurs aléatoires
* Valeurs aléatoires avec la fonction : UxV_mZ;
# Programmation C-C++/Notion de pointeur

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/online/cours_cpp/ qui le fournit sous licence GFDL.
Cours de C/C++ :
| Pointeurs et références ||
| | Notion d'adresse |
| | Notion de pointeur |
| | Référencement, indirection |
| | Notion de référence |
| | Lien entre les pointeurs et les références |
| | Passage de paramètres par variable ou par valeur |
| | Références et pointeurs constants et volatiles |
| | Arithmétique des pointeurs |
| | Utilisation des pointeurs avec les tableaux |
| | Les chaînes de caractères : pointeurs et tableaux à la fois ! |
| | Allocation dynamique de mémoire |
| | Pointeurs et références de fonctions |
| | Paramètres de la fonction main - ligne de commande |
| | DANGER |
| Livre original de C. Casteyde ||

## Notion de pointeur

Une adresse est une valeur. On peut donc stocker cette valeur dans une variable. Les pointeurs sont justement des variables qui contiennent l'adresse d'autres objets, par exemple l'adresse d'une autre variable. On dit que le pointeur pointe sur la variable pointée. Ici, pointer signifie « faire référence à ». Les adresses sont généralement des valeurs constantes, car en général un objet ne se déplace pas en mémoire. Toutefois, la valeur d'un pointeur peut changer. Cela ne signifie pas que la variable pointée est déplacée en mémoire, mais plutôt que le pointeur pointe sur autre chose.
Afin de savoir ce qui est pointé par un pointeur, les pointeurs disposent d'un type. Ce type est construit à partir du type de l'objet pointé. Cela permet au compilateur de vérifier que les manipulations réalisées en mémoire par l'intermédiaire du pointeur sont valides. Le type des pointeur se lit « pointeur de ... », où les points de suspension représentent le nom du type de l'objet pointé.
Les pointeurs se déclarent en donnant le type de l'objet qu'ils devront pointer, suivi de leur identificateur précédé d'une étoile :
Note : Si plusieurs pointeurs doivent être déclarés, l'étoile doit être répétée :
Ici, pi1, pi2 et pi3 sont des pointeurs d'entiers et j est un entier.
Exemple pour une architecture 32 bits où sizeof(int) == 4 && sizeof(int*) == 4 :
| Adresse | Mémoire (par mots de 32-bits) | Variable |
| 0 | 0 | |
| 4 | 0 | |
| 40804 | 45 | i |
| 40808 | 361 | j |
| 41004 | 40808 | pi1 |
* Le pointeur pi1 contient l'adresse de j : pi1 = &j; // 40808.
* La valeur pointée est celle de j : *pi1 == j // Toujours vrai tant que pi1 == &j.
Il est possible de faire un pointeur sur une structure dans une structure en indiquant le nom de la structure comme type du pointeur :
Ce type de construction permet de créer des listes de structures, dans lesquelles chaque structure contient l'adresse de la structure suivante dans la liste. Nous verrons plus loin un exemple d'utilisation de ce genre de structure.
Il est également possible de créer des pointeurs sur des fonctions, et d'utiliser ces pointeurs pour paramétrer un algorithme, dont le comportement dépendra des fonctions ainsi pointées. Nous détaillerons plus loin ce type d'utilisation des pointeurs.
# Programmation C-C++/Notion de référence

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/online/cours_cpp/ qui le fournit sous licence GFDL.
Cours de C/C++ :
| Pointeurs et références ||
| | Notion d'adresse |
| | Notion de pointeur |
| | Référencement, indirection |
| | Notion de référence |
| | Lien entre les pointeurs et les références |
| | Passage de paramètres par variable ou par valeur |
| | Références et pointeurs constants et volatiles |
| | Arithmétique des pointeurs |
| | Utilisation des pointeurs avec les tableaux |
| | Les chaînes de caractères : pointeurs et tableaux à la fois ! |
| | Allocation dynamique de mémoire |
| | Pointeurs et références de fonctions |
| | Paramètres de la fonction main - ligne de commande |
| | DANGER |
| Livre original de C. Casteyde ||

## Notion de référence

En plus des pointeurs, le C++ permet de créer des références. Les références sont des synonymes d'identificateurs. Elles permettent de manipuler une variable sous un autre nom que celui sous laquelle cette dernière a été déclarée.
Note : Les références n'existent qu'en C++. Le C ne permet pas de créer des références.
Par exemple, si « id » est le nom d'une variable, il est possible de créer une référence « ref » de cette variable. Les deux identificateurs id et ref représentent alors la même variable, et celle-ci peut être accédée et modifiée à l'aide de ces deux identificateurs indistinctement.
Toute référence doit se référer à un identificateur : il est donc impossible de déclarer une référence sans l'initialiser. De plus, la déclaration d'une référence ne crée pas un nouvel objet comme c'est le cas pour la déclaration d'une variable par exemple. En effet, les références se rapportent à des identificateurs déjà existants.
La syntaxe de la déclaration d'une référence est la suivante :
Après cette déclaration, référence peut être utilisé partout où identificateur peut l'être. Ce sont des synonymes.

### Exemple - Déclaration de références

Il est possible de faire des références sur des valeurs numériques. Dans ce cas, les références doivent être déclarées comme étant constantes, puisqu'une valeur est une constante :
# Programmation C-C++/Modularité et compilation

Cours de C/C++ :
| Modularité et compilation ||
| | Pourquoi faire une programmation modulaire ? |
| | Les différentes phases du processus de génération des exécutables |
| | Compilation séparée en C/C++ |
| | Syntaxe des outils de compilation |
| | Problèmes syntaxiques relatifs à la compilation séparée |
| Livre original de C. Casteyde ||
La modularité est le fait, pour un programme, d'être écrit en plusieurs morceaux relativement indépendants les uns des autres. La modularité a d'énormes avantages lors du développement d'un programme. Cependant, elle implique un processus de génération de l'exécutable assez complexe. Dans ce chapitre, nous allons voir l'intérêt de la modularité, les différentes étapes qui permettent la génération de l'exécutable et l'influence de ces étapes sur la syntaxe du langage.
# Programmation C-C++/Notion d'adresse

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/online/cours_cpp/ qui le fournit sous licence GFDL.
Cours de C/C++ :
| Pointeurs et références ||
| | Notion d'adresse |
| | Notion de pointeur |
| | Référencement, indirection |
| | Notion de référence |
| | Lien entre les pointeurs et les références |
| | Passage de paramètres par variable ou par valeur |
| | Références et pointeurs constants et volatiles |
| | Arithmétique des pointeurs |
| | Utilisation des pointeurs avec les tableaux |
| | Les chaînes de caractères : pointeurs et tableaux à la fois ! |
| | Allocation dynamique de mémoire |
| | Pointeurs et références de fonctions |
| | Paramètres de la fonction main - ligne de commande |
| | DANGER |
| Livre original de C. Casteyde ||

## Notion d'adresse

Tout objet manipulé par l'ordinateur est stocké dans sa mémoire. On peut considérer que cette mémoire est constituée d'une série de « cases », cases dans lesquelles sont stockées les valeurs des variables ou les instructions du programme. Pour pouvoir accéder à un objet (la valeur d'une variable ou les instructions à exécuter par exemple), c'est-à-dire au contenu de la case mémoire dans laquelle cet objet est enregistré, il faut connaître le numéro de cette case. Autrement dit, il faut connaître l'emplacement en mémoire de l'objet à manipuler. Cet emplacement est appelé l'adresse de la case mémoire, et par extension, l'adresse de la variable ou l'adresse de la fonction stockée dans cette case et celles qui la suivent.
Toute case mémoire a une adresse unique. Lorsqu'on utilise une variable ou une fonction, le compilateur manipule l'adresse de cette dernière pour y accéder. C'est lui qui connaît cette adresse, le programmeur n'a pas à s'en soucier.
# Programmation C-C++/Paramètres de la fonction main - ligne de commande

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/online/cours_cpp/ qui le fournit sous licence GFDL.
Cours de C/C++ :
| Pointeurs et références ||
| | Notion d'adresse |
| | Notion de pointeur |
| | Référencement, indirection |
| | Notion de référence |
| | Lien entre les pointeurs et les références |
| | Passage de paramètres par variable ou par valeur |
| | Références et pointeurs constants et volatiles |
| | Arithmétique des pointeurs |
| | Utilisation des pointeurs avec les tableaux |
| | Les chaînes de caractères : pointeurs et tableaux à la fois ! |
| | Allocation dynamique de mémoire |
| | Pointeurs et références de fonctions |
| | Paramètres de la fonction main - ligne de commande |
| | DANGER |
| Livre original de C. Casteyde ||
L'appel d'un programme se fait normalement avec la syntaxe suivante :
où nom est le nom du programme à appeler et param1, etc. sont les paramètres de la ligne de commande. De plus, le programme appelé peut renvoyer un code d'erreur au programme appelant (soit le système d'exploitation, soit un autre programme). Ce code d'erreur est en général 0 quand le programme s'est déroulé correctement. Toute autre valeur indique qu'une erreur s'est produite en cours d'exécution.
La valeur du code d'erreur est renvoyée par la fonction main. Le code d'erreur doit toujours être un entier. La fonction main peut donc (et même normalement doit) être de type entier :
Les paramètres de la ligne de commandes peuvent être récupérés par la fonction main. Si vous désirez les récupérer, la fonction main doit attendre deux paramètres :
* le premier est un entier, qui représente le nombre de paramètres ;
* le deuxième est un tableau de chaînes de caractères (donc en fait un tableau de pointeurs, ou encore un pointeur de pointeurs de caractères).
Les paramètres se récupèrent avec ce tableau. Le premier élément pointe toujours sur la chaîne donnant le nom du programme. Les autres éléments pointent sur les paramètres de la ligne de commande.
# Programmation C-C++/Pourquoi faire une programmation modulaire ?

Cours de C/C++ :
| Modularité et compilation ||
| | Pourquoi faire une programmation modulaire ? |
| | Les différentes phases du processus de génération des exécutables |
| | Compilation séparée en C/C++ |
| | Syntaxe des outils de compilation |
| | Problèmes syntaxiques relatifs à la compilation séparée |
| Livre original de C. Casteyde ||
Ce qui coûte le plus cher en informatique, c'est le développement de logiciel, pas le matériel. En effet, développer un logiciel demande du temps, de la main d’œuvre qualifiée, et n'est pas facile (il y a toujours des erreurs). De plus, les logiciels développés sont souvent spécifiques à un type de problème donné. Pour chaque problème, il faut tout refaire.
Ce n'est pas un très bon bilan. Pour éviter tous ces inconvénients, une branche de l'informatique a été développée : le génie logiciel. Le génie logiciel donne les grands principes à appliquer lors de la réalisation d'un programme, de la conception à la distribution, et sur toute la durée de vie du projet. Ce sujet dépasse largement le cadre de ce cours, aussi je ne parlerais que de l'aspect codage seul, c'est-à-dire ce qui concerne le C/C++.
Au niveau du codage, le plus important est la programmation modulaire. Les idées qui en sont à la base sont les suivantes :
* diviser le travail en plusieurs équipes ;
* créer des morceaux de programme indépendants de la problématique globale, donc réutilisables pour d'autres logiciels ;
* supprimer les risques d'erreurs qu'on avait en reprogrammant ces morceaux à chaque fois.
Je tiens à préciser que les principes de la programmation modulaire ne s'appliquent pas qu'aux programmes développés par des équipes de programmeurs. Ils s'appliquent aussi aux programmeurs individuels. En effet il est plus facile de décomposer un problème en ses éléments, forcément plus simples, que de le traiter dans sa totalité (dixit Descartes).
Pour parvenir à ce but, il est indispensable de pouvoir découper un programme en sous-programmes indépendants, ou presque indépendants. Pour que chacun puisse travailler sur sa partie de programme, il faut que ces morceaux de programme soient dans des fichiers séparés.
Pour pouvoir vérifier ces morceaux de programme, il faut que les compilateurs puissent les compiler indépendamment, sans avoir les autres fichiers du programme. Ainsi, le développement de chaque fichier peut se faire relativement indépendamment de celui des autres. Cependant, cette division du travail implique des opérations assez complexes pour générer l'exécutable.
# Programmation C-C++/Pointeurs et références

Ce livre est en cours de copie depuis le site http://casteyde.christian.free.fr/online/cours_cpp/ qui le fournit sous licence GFDL.
Cours de C/C++ :
| Pointeurs et références ||
| | Notion d'adresse |
| | Notion de pointeur |
| | Référencement, indirection |
| | Notion de référence |
| | Lien entre les pointeurs et les références |
| | Passage de paramètres par variable ou par valeur |
| | Références et pointeurs constants et volatiles |
| | Arithmétique des pointeurs |
| | Utilisation des pointeurs avec les tableaux |
| | Les chaînes de caractères : pointeurs et tableaux à la fois ! |
| | Allocation dynamique de mémoire |
| | Pointeurs et références de fonctions |
| | Paramètres de la fonction main - ligne de commande |
| | DANGER |
| Livre original de C. Casteyde ||
Les pointeurs sont des variables très utilisées en C et en C++. Ils doivent être considérés comme des variables, il n'y a rien de sorcier derrière les pointeurs. Cependant, les pointeurs ont un domaine d'application très vaste.
Les références sont des identificateurs synonymes d'autres identificateurs, qui permettent de manipuler certaines notions introduites avec les pointeurs plus souplement. Elles n'existent qu'en C++.
# Mathématiques du traitement du signal/Exercices : Suites et séries
## Convergence numérique
### Suite

En définissant la suite $a_{n}$ ainsi : $a_{0}={60 \over 11},\,a_{1}={11 \over 2},\,a_{n}=111-{1130-{3000 \over a_{n-2}} \over a_{n-1}}$
alors $\lim _{n\rightarrow \infty }a_{n}=6$ (essayer des simulations)

## Série entière

Soit:
$f_{K}(\alpha )=\sum _{k=0}^{K}{\frac {\alpha ^{2k+1}}{\mathbf {E} (X^{2k})}},\,X\sim {N}(0,1)$
Alors $f_{\infty }$ vérifie l'équation différentielle:
$f'_{\infty }(x)=1+x\,f_{\infty }(x)$
et donc:
$f_{\infty }(x)=e^{-x^{2}/2}\left(1+\int _{-\infty }^{x}e^{-t^{2}/2}dt\right)$
# Mathématiques du traitement du signal/Finances : cac-date.txt

voici le contenu du fichier
# Mathématiques niveau 2nde-Conforme aux nouveaux programmes

Ceci, est un manuel de mathématiques, conforme, aux programmes, promulgué le 22 janvier 2019, destiné, aux classes, de 2nde.
Il se divise, en plusieurs parties, elles-mêmes, divisées, en chapitres :
Partie I : Algorithmique :
Chapitre I : Les variables en Python
Chapitre II : Les conditions en Python
Chapitre III : Les boucles en Python
Chapitre IV : Les fonctions en Python
Partie II : Arithmétique :
Chapitre I : Vocabulaire ensembliste
Chapitre II : Opérations, sur les nombres réels
Chapitre III : Les multiples, les diviseurs et les nombres premiers
Chapitre IV : Calcul littéral
Partie III : Géométrie :
Chapitre I : Les vecteurs
Chapitre II : Les droites d'un plan
Chapitre III : Problèmes géométriques
Partie IV : Fonctions :
Chapitre I : Représentation algébrique et représentation graphique, de fonctions
Chapitre II : Variations et extremus d'une fonction
Partie V : Statistiques :
Chapitre I : Proportion et pourcentages
Chapitre II : Moyennes
Chapitre III : Indicateurs de dispersion
Chapitre IV : Évolution
Partie VI : Probabilités :
Chapitre I : Probabilités et intervalles
Chapitre II : Expression de la probabilité d'un événement
Chapitre III : Échantillonnage
# Mathématiques niveau 2nde-Conforme aux nouveaux programmes/Les variables en Python
## Les variables

Au collège, vous avez appris, à utiliser, le logiciel Scratch, afin, de créer des algorithmes. Ces algorithmes, contenaient des variables.

### Concept de variable

Le terme, de variable, peut renvoyer, à des choses fort diverses, par exemple, à :
-Un nombre entier ;
-Un nombre à virgule, que l'on appellera, un nombre flottant ;
-Une phrase, un mot, etc., c'est-à-dire, une chaîne de caractères ;
-Une variable booléenne, c'est-à-dire, une variable, pouvant avoir deux valeurs : soit vrai, soit faux.
Néanmoins, si divers, que puissent être les variables, les variables, ont des caractéristiques en commun :
On peut :
-Entrer la valeur de la variable ;
-Demander, à l'utilisateur, d'entrer cette valeur ;
-Changer la valeur de cette variable ;
-Ne pas changer la valeur de la variable ;
-L'utiliser dans une condition ( nous verrons plus tard, de quoi est-ce qu'il s'agit ) ;
-L'utiliser dans une boucle ( nous verrons plus tard, de quoi est-ce qu'il s'agit ) ;
-L'utiliser dans une fonction ( nous verrons plus tard, de quoi est-ce qu'il s'agit ).
# Mathématiques du traitement du signal/Fonctions de permutation
## Fonctions de permutation en informatique

Un petit camarade informaticien me demandait récemment par mail comment comment construire une fonction de permutation (qu'il a appelé valeur complémentaire):
C'est une question suffisamment générique en informatique pour que cela vaille le coup d'y consacrer un peu de place ici.
pour un ensemble de N nombres (ici 3), il te faut N-1 (ici 2) fonctions. Elles doivent toutes être construites sur le même modèle, qui vient du fait que si tu as N-1 nombres $a_{1},a_{2},\dots ,a_{N-1}$ la fonction (c'est un polynôme de degré N-2) :
$F(x)=(x-a_{1})(x-a_{2})\cdots (x-a_{N-1})$ vaut zéro pour tous ces nombres
Pour construire une fonction qui envoie aN sur a1 et tous les autres nombres $(a1,\dots ,a_{N-1})$ sur zéro, il faut prendre la fonction :
$G(x)={F(x) \over F(a_{N})}\,a_{1}$
je vais noter cette fonction $G[a_{N}](x)$ pour nous rappeler qu'elle vaut zéro partout sauf pour $a_{N}$.
de même, la fonction qui envoie a1 sur a2 et tous les autres nombres $(a_{3},\dots ,a_{N})$ sur zéro est :
$G[a_{1}](x)=F[a_{3},\dots ,a_{N}](x)/F[a_{3},\dots ,a_{N}](a_{1})a_{2}$
où j'ai noté $F[a_{3},\dots ,a_{N}](x)=(x-a_{3})(x-a_{4})\ldots (x-a_{N})$ ; maintenant, tu peux remarquer que :
$H(x)=G[a_{1}](x)+G[a_{N}](x)$
vaut zéro partout sauf en $a_{1}$ et en $a_{N}$ (où elle vaut $a_{2}$ et $a_{1}$), voila que ça commence à prendre forme. La formule finale est :
$K(x)=G[a_{1}](x)+G[a_{2}](x)+\ldots +G[a_{N}](x)=\sum _{n=1}^{N}G[a_{n}](x)$
qui vaut $a_{n+1}$ en $a_{n}$ pour tous les n (elle décale tout le monde d'un indice).
si on applique cela à ton problème (mais comme ça tu pourras résoudre n'importe quel problème du genre) :
$\{a_{1},a_{2},a_{3}\}=\{0,1,2\}$
$\left\{{\begin{matrix}F[1,2](x)&=&(x-1)(x-2)\\F[0,2](x)&=&x\,(x-2)\\F[0,1](x)&=&x\,(x-1)\end{matrix}}\right.$
et donc
$\left\{{\begin{matrix}G[0](x)&=&\displaystyle {F[1,2](x) \over F[1,2](0)}\,1&=&{(x-1)\,(x-2) \over 2}\\G[1](x)&=&\displaystyle {F[0,2](x) \over F[0,2](1)}\,2&=&-x\,(x-2)\,2\\G[2](x)&=&\displaystyle {F[0,1](x) \over F[0,1](2)}\,0&=&0\end{matrix}}\right.$
ce qui permet d'écrire :
$K(x)={(x-1)\,(x-2) \over 2}-x\,(x-2)\,2+0$
que tu peux simpifier en $K(x)=(x-2)\,({x-1 \over 2}-2x)$
Cette fonction a bien la propriété d'envoyer 0 sur 1, 1 sur 2 et 2 sur 0.
tu peux obtenir de la même façon une seconde fonction qui envoie 0 sur 2, 1 sur 0 et 2 sur 1, il s'agit de :
$L(x)={F[1,2](x) \over F[1,2](0)}\,2+{F[0,2](x) \over F[0,2](1)}\,0+{F[0,1](x) \over F[0,1](2)}\,1$
et voilà, j'espère que cela répond à ta question et surtout que cela va te permettre de calculer toi même toutes les fonctions de ce genre dont tu auras besoin.