{"id":1624,"date":"2014-11-12T16:25:45","date_gmt":"2014-11-12T16:25:45","guid":{"rendered":"http:\/\/ellignostage.test\/?p=1624"},"modified":"2021-05-26T13:06:05","modified_gmt":"2021-05-26T18:06:05","slug":"exemple-dun-algorithme-numeric-de-la-stl","status":"publish","type":"post","link":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/","title":{"rendered":"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL"},"content":{"rendered":"\n

STL contient plusieurs librairies, parmi une de celles-ci la librairie num\u00e9rique offre plusieurs algorithmes pour le calcul num\u00e9rique.  Nous pr\u00e9sentons un exemple simple afin de calculer la moyenne en utilisant l\u2019algorithme  \u201caccumulate<\/em>\u201d de cette librairie.  Supposons que nous ayons \u00e0 notre disposition un ensemble de donn\u00e9es pour lesquelles nous voulons calculer la moyenne. Celles-ci peuvent \u00eatre sous un format d\u2019un vecteur, d\u2019une list, d\u2019un map, hash table, tableau pour nommer que ceux-ci. La moyenne pourrait \u00eatre calcul\u00e9e de la mani\u00e8re suivante :<\/p>\n\n\n\n

double<\/span> mean( const<\/span> std<\/span>::vector<\/span><double<\/span>>& vec)
{
\/\/ calculate the sum using another function; this is good practice<\/span>
\/\/ and divide by the size of the vector<\/span>
\/\/ vec.size() != 0<\/span>
return sum(vec) \/ vec.size();
}\n

 <\/p>\n

d<\/span>ouble<\/span> sum( const<\/span> std<\/span>::vector<\/span><double<\/span>>& vec)
{
\/\/ use range-for (C++11 style code)<\/span>
double result = 0.0;
for (auto i : vec)
result += i;return result;
}<\/p>\n<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Pour plusieurs programmeurs utiliser des boucles est plus naturel que d\u2019appeler un algorithme. Le pain et le beurre des algorithmes de la  STL c\u2019est que plusieurs lignes de code qui sont faites  avec des boucles explicites du type \u2018for\u2019, \u2018while\u2019, pourraient aussi bien \u00eatre \u00e9crites en utilisant les algorithmes. Regardons une nouvelle approche en utilisant l\u2019algorithme num\u00e9rique \u201caccumulate<\/em>\u201d de la STL. <\/span><\/p>\n\n\n\n

Prototype<\/strong>
\u201cAccumulate\u201d est surcharg\u00e9 et poss\u00e8de 2 prototypes:<\/p>\n\n\n\n

template <class InputIterator, class T>
T accumulate<\/strong>( InputIterator first, InputIterator last, T init);<\/p>\n\n\n\n

template <class InputIterator, class T, class BinaryFunction>
T accumulate<\/strong>( InputIterator first, InputIterator last, T init, BinaryFunction binary_op);<\/p>\n\n\n\n

Fonction template \u201caccumulate\u201d est une version g\u00e9n\u00e9ralis\u00e9 de la sommation. L\u2019algorithme initialise d\u2019abord le r\u00e9sultat \u00e0 \u2018init\u2019<\/em>. Puis pour chacun des \u00e9l\u00e9ments (it\u00e9rateur i) de l’ensemble [first,last[, en commen\u00e7ant par le d\u00e9but jusqu\u2019\u00e0 la fin, modifie celui-ci en utilisant \u2018operator+\u2019 result=result+*i<\/em> (premi\u00e8re version,) ou par une operation binaire ( result = binary_op (result, *i<\/em>) (deuxi\u00e8me version). Cet algorithme a une complexit\u00e9 lin\u00e9aire. Comme tous les algorithmes de la STL, \u201caccumulate\u201d prend comme arguments des it\u00e9rateur pour sp\u00e9cifier la portion du containeur ou la totalit\u00e9 de celui-ci. Les algorithmes op\u00e8rent sur les conteneurs uniquement via les it\u00e9rateurs. De cette fa\u00e7on les algorithmes peuvent \u00eatre utilis\u00e9s  par plusieurs types de containers. Ci-dessous la liste des fichiers d\u2019en-t\u00eate pour notre exemple:<\/p>\n\n\n\n

\/\/ C++ 11 include<\/span>
#include <\/span><tuple>                       \/\/ std::tuple<\/span>
\/\/ Stl includes<\/span>
#include<\/span> <vector>
#include<\/span> <numeric>                     \/\/ std::accumulate<\/span>
\/\/ boost include<\/span>
#include<\/span> <boost\/assign\/std\/vector.hpp> \/\/ for ‘operator+=()’<\/span>
}<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Le premier fichier d\u2019en-t\u00eate  provient du nouveau C++11 pour le type \u201ctuple\u201d. Depuis C++11 un nouveau type a \u00e9t\u00e9 introduit (une nouvelle fonctionnalit\u00e9) appel\u00e9 \u201ctuple\u201d.  Le type \u201ctuple\u201d est tr\u00e8s similaire \u00e0 celui de \u201cpair \u201d, la principale diff\u00e9rence entre les deux, \u201cpair \u201d repr\u00e9sente deux valeurs comme une seule. \u201cTuple\u201d \u00e9tend ce concept \u00e0 un nombre arbitraire d\u2019\u00e9l\u00e9ments (au minimum dix). Puis les deux fichiers d\u2019en-t\u00eate suivant, \u2018vector\u2019 et \u2018num\u00e9rique\u2019, correspondent \u00e0 la collection (STL) que nous utilisons pour stocker le data et l\u2019algorithme \u201caccumulate\u201d respectivement. Finalement nous utilisons des op\u00e9rateurs d\u2019initialisations de la librairie \u2018Boost Assign Library\u2019. Dans bien des cas, nous voulons tester sans avoir \u00e0 utiliser un tr\u00e8s grand nombre de donn\u00e9es et \u00eatre en mesure d\u2019initialiser la collection rapidement. La STL ne  nous facilite pas la t\u00e2che pour ceci, Boost Assign Library fournit un ensemble d\u2019outils ou d\u2019op\u00e9rateurs pour accomplir cette t\u00e2che. Nous allons \u00e9crire la fonction binaire qui a comme responsabilit\u00e9 de calculer les statistiques. D\u2018abord  nous d\u00e9finissons un \u201c typedef \u201d pour la lisibilit\u00e9 (un synonyme, pas un nouveau type).<\/p>\n\n\n\n

\/\/ C++11 new features<\/span>
typedef<\/span> std<\/span>::tuple<\/span><std<\/span>::size_t<\/span>\/*N*\/,double<\/span>\/*X*\/,double<\/span>\/*X^2*\/> statsVar;\n

 <\/p>\n

\/<\/span>\/ Use get<>() utility to retrieve component of a tuple<\/span>
statsVar computeStats( statsVar aVar, double<\/span> aXi)
{
using<\/span> namespace<\/span> std<\/span>;<\/p>\n

++get<0>(aVar);             \/\/ count the number of entry<\/span>
get<1>(aVar)+=aXi;         \/\/ add value<\/span>
get<2>(aVar)+=aXi*aXi;  \/\/ square summation<\/span><\/p>\n

\/\/ return the statics compilation<\/span><\/p>\n

return<\/span> aVar;<\/p>\n

}<\/p>\n<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Le premier argument de la fonction binaire est le \u201ctuple\u201d (type statsVar), celui-ci tient toute l\u2019information pour compiler les statistiques et le second est l\u2019\u00e9l\u00e9ment que nous traversons (valeur de l’it\u00e9rateur). Il est important de remarquer que le type \u2018statsVar\u2019 est retourn\u00e9 par la fonction, pr\u00eat pour le prochain \u00e9l\u00e9ment (accumule l\u2019information). Le corps de cette fonction est assez simple, d\u2019abord on sp\u00e9cifie que nous utilisons le \u2018namespace std\u2019, ceci \u00e9vite d\u2019avoir \u00e0 \u00e9crire le scope continuellement. Ensuite on utilise le \u2018getter\u2019, nouvelle fonctionnalit\u00e9 de C++11 pour mettre \u00e0 jour les composantes du \u2018tuple\u2019 (\u2018typedef\u2019 contient trois arguments). D\u2019abord on incr\u00e9mente le compteur \u00e0 chaque \u00e9l\u00e9ment visit\u00e9, puis on ajoute l\u2019\u00e9l\u00e9ment courant \u00e0 la somme compil\u00e9e (pour faire la moyenne) et finalement la somme du carr\u00e9 pour \u00e9ventuellement calculer la variance. Maintenant nous allons tester notre algorithme de statistique sur un ensemble de valeurs arbitraires.<\/p>\n\n\n\n

\/\/ calcul des statistiques<\/span>
void testStatistics()
{
using<\/span> namespace<\/span> std<\/span>;
using<\/span> namespace<\/span> boost<\/span>::assign<\/span>; \/\/ bring ‘operator+=()’ into scope<\/span>\n

 <\/p>\n

\/\/ create a vector of data to compute statistics<\/span><\/p>\n

vector<\/span><double<\/span>> w_dataStats;
w_dataStats.reserve(10);  \/\/ memory allocation (good practice)<\/span><\/p>\n

\/\/ initialize the vector (Boost assign library)<\/span>
w_dataStats+=1.,2.,3.,4.,5.,6.,7.,8.,9.,10.;<\/p>\n

\/\/ compute the statistics (average, \u2026)<\/span><\/p>\n

statsVar res= accumulate( w_dataStats.begin(), w_dataStats.end(), \/\/ range<\/span>
make_tuple(0u,0.,0.)\/*initialization*\/,computeStats\/*function*\/);<\/p>\n

\/\/ print the statistics that we have computed<\/span>
cout<\/span> << \u00ab\u00a0Number of elements is: \u00a0\u00bb << get<0>(res) << endl;
cout<\/span> << \u00ab\u00a0Average computed is:   \u00a0\u00bb << get<1>(res)\/get<0>(res) << endl;
}<\/p>\n<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

D\u2019abord on cr\u00e9e un vecteur de la STL de dix \u00e9l\u00e9ments que nous initialisons avec la m\u00e9thode \u2018reserve()\u2019. Cette m\u00e9thode alloue la m\u00e9moire pour le nombre d\u2019\u00e9l\u00e9ments, on \u00e9vite ainsi de faire des r\u00e9allocations quand des \u00e9l\u00e9ments sont ajoutes dans le vecteur (couteux x quand  le vecteur est de grande taille), c\u2019est une bonne pratique. Ensuite on assigne des valeurs num\u00e9riques en utilisant l\u2019op\u00e9rateur \u2018+=\u2019 de la librairie \u2018Boost Assign\u2019. Permet un style d\u2019initialisation sous forme de liste, tr\u00e8s pratique quand  on a un petit nombre d\u2019\u00e9l\u00e9ments.  Puis on calcule les statistiques par un appel de l\u2019algorithme \u2018accumulate\u2019 en lui passant comme param\u00e8tre le vecteur (begin(), end()), la valeur initiale (make_tuple) et la fonction binaire \u2018computeStats\u2019. L\u2019algorithme retourne le r\u00e9sultat compil\u00e9 (accumulation apr\u00e8s avoir visite tous les \u00e9l\u00e9ments de la collection). Finalement on affiche les statistiques en utilisant les \u201cgetter\u201c.<\/p>\n\n\n\n

La chose remarquable dans cet exemple, le code est concis et sans boucle \u2018for\u2019.
Les algorithmes de la STL offrent un niveau d’abstraction qui permet une impl\u00e9mentation tr\u00e8s propre. Ceux-ci permettent d’appliquer une op\u00e9ration \u00e0 un ensemble d’\u00e9l\u00e9ments sans avoir se pr\u00e9occuper en d\u00e9tail de la nature de ces \u00e9l\u00e9ments, et sans avoir \u00e0 impl\u00e9menter un code laborieux et sp\u00e9cialis\u00e9 pour le faire. Les algorithmes (et la STL plus g\u00e9n\u00e9ralement) proposent le meilleur compromis. Pourquoi?
Selon  Scott Meyers\u2019s article \u201cSTL Algorithms vs. Hand-Written Loops, Dr. Dobbs\u2019s October 2001\u201d il est pr\u00e9f\u00e9rable d\u2019utiliser des algorithmes aux boucles explicites pour les raisons suivantes:<\/p>\n\n\n\n

\u2022 Efficacit\u00e9<\/strong> : algorithme de la STL sont souvent plus efficace que les boucles explicites;
\u2022 Robustesse<\/strong> : \u00e9crire des boucles explicitement est sujet \u00e0 des erreurs;
\u2022 Maintenabilit\u00e9<\/strong> : code qui est plus facile \u00e0 comprendre. Tout est g\u00e8re par l\u2019algorithme et compatible avec tous les types de containeur (qui supporte la stl-interface);<\/p>\n\n\n\n

Cet exemple montre le degr\u00e9 d\u2019abstraction de la STL d\u2019\u00eatre capable de manipuler des donn\u00e9es d\u2019un vecteur (stl-like container) et de les passer \u00e0 l\u2019algorithme afin  d\u2019accomplir une t\u00e2che complexe.<\/p>\n","protected":false},"excerpt":{"rendered":"

Nous d\u00e9montrons par un usage simple de l\u2019algorithme num\u00e9rique \u201caccumulate\u201d,comment la STL permet de r\u00e9soudre les probl\u00e8mes les plus fr\u00e9quents en quelques lignes de code.Moins lignes de code se traduit par moins de bugs, dans 90% du temps,du code concis est plus efficace et plus facile \u00e0 maintenir.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[24],"tags":[],"class_list":["post-1624","post","type-post","status-publish","format-standard","hentry","category-trucs-et-astuces"],"yoast_head":"\nExemple d\u2019un algorithme \u2018numeric\u2019 de la STL - Elligno<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL - Elligno\" \/>\n<meta property=\"og:description\" content=\"Nous d\u00e9montrons par un usage simple de l\u2019algorithme num\u00e9rique \u201caccumulate\u201d,comment la STL permet de r\u00e9soudre les probl\u00e8mes les plus fr\u00e9quents en quelques lignes de code.Moins lignes de code se traduit par moins de bugs, dans 90% du temps,du code concis est plus efficace et plus facile \u00e0 maintenir.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/\" \/>\n<meta property=\"og:site_name\" content=\"Elligno\" \/>\n<meta property=\"article:published_time\" content=\"2014-11-12T16:25:45+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-05-26T18:06:05+00:00\" \/>\n<meta name=\"author\" content=\"Elligno\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Elligno\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/exemple-dun-algorithme-numeric-de-la-stl\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/exemple-dun-algorithme-numeric-de-la-stl\\\/\"},\"author\":{\"name\":\"Elligno\",\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/#\\\/schema\\\/person\\\/95f2e5f7a779215bc13c98f05efafc8b\"},\"headline\":\"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL\",\"datePublished\":\"2014-11-12T16:25:45+00:00\",\"dateModified\":\"2021-05-26T18:06:05+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/exemple-dun-algorithme-numeric-de-la-stl\\\/\"},\"wordCount\":1420,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/#organization\"},\"articleSection\":[\"Trucs et astuces\"],\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/elligno.com\\\/fr\\\/exemple-dun-algorithme-numeric-de-la-stl\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/exemple-dun-algorithme-numeric-de-la-stl\\\/\",\"url\":\"https:\\\/\\\/elligno.com\\\/fr\\\/exemple-dun-algorithme-numeric-de-la-stl\\\/\",\"name\":\"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL - Elligno\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/#website\"},\"datePublished\":\"2014-11-12T16:25:45+00:00\",\"dateModified\":\"2021-05-26T18:06:05+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/exemple-dun-algorithme-numeric-de-la-stl\\\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/elligno.com\\\/fr\\\/exemple-dun-algorithme-numeric-de-la-stl\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/exemple-dun-algorithme-numeric-de-la-stl\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/elligno.com\\\/fr\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/#website\",\"url\":\"https:\\\/\\\/elligno.com\\\/fr\\\/\",\"name\":\"Elligno\",\"description\":\"Site dev elligno\",\"publisher\":{\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/elligno.com\\\/fr\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/#organization\",\"name\":\"Elligno Inc\",\"url\":\"https:\\\/\\\/elligno.com\\\/fr\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/elligno.com\\\/wp-content\\\/uploads\\\/2021\\\/06\\\/favicon.png\",\"contentUrl\":\"https:\\\/\\\/elligno.com\\\/wp-content\\\/uploads\\\/2021\\\/06\\\/favicon.png\",\"width\":256,\"height\":256,\"caption\":\"Elligno Inc\"},\"image\":{\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/elligno.com\\\/fr\\\/#\\\/schema\\\/person\\\/95f2e5f7a779215bc13c98f05efafc8b\",\"name\":\"Elligno\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/5d5d65a6272025dfbdbf8600bd75d9abcc5eede7e37fe620531e2d2c00f91464?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/5d5d65a6272025dfbdbf8600bd75d9abcc5eede7e37fe620531e2d2c00f91464?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/5d5d65a6272025dfbdbf8600bd75d9abcc5eede7e37fe620531e2d2c00f91464?s=96&d=mm&r=g\",\"caption\":\"Elligno\"},\"sameAs\":[\"https:\\\/\\\/elligno.com\"],\"url\":\"https:\\\/\\\/elligno.com\\\/fr\\\/author\\\/panel-65ui89\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL - Elligno","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/","og_locale":"fr_FR","og_type":"article","og_title":"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL - Elligno","og_description":"Nous d\u00e9montrons par un usage simple de l\u2019algorithme num\u00e9rique \u201caccumulate\u201d,comment la STL permet de r\u00e9soudre les probl\u00e8mes les plus fr\u00e9quents en quelques lignes de code.Moins lignes de code se traduit par moins de bugs, dans 90% du temps,du code concis est plus efficace et plus facile \u00e0 maintenir.","og_url":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/","og_site_name":"Elligno","article_published_time":"2014-11-12T16:25:45+00:00","article_modified_time":"2021-05-26T18:06:05+00:00","author":"Elligno","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"Elligno","Dur\u00e9e de lecture estim\u00e9e":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/#article","isPartOf":{"@id":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/"},"author":{"name":"Elligno","@id":"https:\/\/elligno.com\/fr\/#\/schema\/person\/95f2e5f7a779215bc13c98f05efafc8b"},"headline":"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL","datePublished":"2014-11-12T16:25:45+00:00","dateModified":"2021-05-26T18:06:05+00:00","mainEntityOfPage":{"@id":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/"},"wordCount":1420,"commentCount":0,"publisher":{"@id":"https:\/\/elligno.com\/fr\/#organization"},"articleSection":["Trucs et astuces"],"inLanguage":"fr-FR","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/","url":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/","name":"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL - Elligno","isPartOf":{"@id":"https:\/\/elligno.com\/fr\/#website"},"datePublished":"2014-11-12T16:25:45+00:00","dateModified":"2021-05-26T18:06:05+00:00","breadcrumb":{"@id":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/elligno.com\/fr\/exemple-dun-algorithme-numeric-de-la-stl\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/elligno.com\/fr\/"},{"@type":"ListItem","position":2,"name":"Exemple d\u2019un algorithme \u2018numeric\u2019 de la STL"}]},{"@type":"WebSite","@id":"https:\/\/elligno.com\/fr\/#website","url":"https:\/\/elligno.com\/fr\/","name":"Elligno","description":"Site dev elligno","publisher":{"@id":"https:\/\/elligno.com\/fr\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/elligno.com\/fr\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/elligno.com\/fr\/#organization","name":"Elligno Inc","url":"https:\/\/elligno.com\/fr\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/elligno.com\/fr\/#\/schema\/logo\/image\/","url":"https:\/\/elligno.com\/wp-content\/uploads\/2021\/06\/favicon.png","contentUrl":"https:\/\/elligno.com\/wp-content\/uploads\/2021\/06\/favicon.png","width":256,"height":256,"caption":"Elligno Inc"},"image":{"@id":"https:\/\/elligno.com\/fr\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/elligno.com\/fr\/#\/schema\/person\/95f2e5f7a779215bc13c98f05efafc8b","name":"Elligno","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/5d5d65a6272025dfbdbf8600bd75d9abcc5eede7e37fe620531e2d2c00f91464?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/5d5d65a6272025dfbdbf8600bd75d9abcc5eede7e37fe620531e2d2c00f91464?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/5d5d65a6272025dfbdbf8600bd75d9abcc5eede7e37fe620531e2d2c00f91464?s=96&d=mm&r=g","caption":"Elligno"},"sameAs":["https:\/\/elligno.com"],"url":"https:\/\/elligno.com\/fr\/author\/panel-65ui89\/"}]}},"_links":{"self":[{"href":"https:\/\/elligno.com\/fr\/wp-json\/wp\/v2\/posts\/1624","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/elligno.com\/fr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/elligno.com\/fr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/elligno.com\/fr\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/elligno.com\/fr\/wp-json\/wp\/v2\/comments?post=1624"}],"version-history":[{"count":0,"href":"https:\/\/elligno.com\/fr\/wp-json\/wp\/v2\/posts\/1624\/revisions"}],"wp:attachment":[{"href":"https:\/\/elligno.com\/fr\/wp-json\/wp\/v2\/media?parent=1624"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/elligno.com\/fr\/wp-json\/wp\/v2\/categories?post=1624"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/elligno.com\/fr\/wp-json\/wp\/v2\/tags?post=1624"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}