Bonjour.
Je ne sais d=E9clarer ni une liste dont le nombre d'=E9l=E9ments est
variable, ni un tableau dont le nombre de dimensions est variable.
Pour ce dernier probl=E8me, j'ai pens=E9 =E0 cr=E9er un tableau sur Excel e=
n
2D, qui croit en fonction du nombre de dimension. Mais =E7a me semble
difficile =E0 g=E9rer.
Plus philosophiquement, pensez-vous que le nombre de dimensions d'un
probl=E8me donn=E9 soit une limite th=E9orique =E0 l'IA ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Jean-marc
fraction wrote:
Bonjour.
Hello,
Je ne sais déclarer ni une liste dont le nombre d'éléments est variable,
Ca, c'est facile - Redim et Redim Preserve. Voir : http://faq.vb.free.fr/index.php?question3 http://faq.vb.free.fr/index.php?question0
ni un tableau dont le nombre de dimensions est variable.
Ca, c'est un problème mal posé - Ce n'est pas une question de langage, c'est un problème de modélisation.
Si tu y réfléchis, tu verras que pouvoir disposer d'un tableau dont le nombre de dimensions n'est pas connu à l'avance ne t'avance à rien.
Plus simplement, tout peut se ramener à un tableau à une dimension dont les éléments peuvent eux même être des tableaux dont les élements peuvent eux même être des tableaux, etc.
Bête exemple: Option Explicit
Private Type b c(10) As Integer End Type
Dim a(10) As b
Private Sub Form_Load() a(1).c(3) = 666 End Sub
a est un tableau à une dimension, chaque élément de a est un autre tableau a 10 dimensions.
Il n'y a pas de limites à ce genre de déclarations. Et bien sur, a et b peuvent eux même être dynamiques, alloués et désalloués avec Redim.
[Note: si il le fallait vraiment, je saurais écrire un programme qui manipule un tableau "dont le nombre de dimensions est variable". Ca n'aurait pas d'intérêt, mais c'est faisable.]
Plus philosophiquement, pensez-vous que le nombre de dimensions d'un problème donné soit une limite théorique à l'IA ?
Absolument pas :-) On sait déclarer des tableaux à autant de "dimensions" que l'on veut, c'est simplement une question de choix de structures de données.
(Note bien que l'IA est un sujet extrèmement vaste, et que derrière le sigle se cache des milliers de réalité différente, allant de la programmation génétique au data mining, de la "compréhension" du langage naturel aux applications des réseaux de neurones, et j'en passe et des meilleures. Mais aucune des branches de l'IA ne bloque sur un problème de représentation des "dimensions".)
Si tu es intéressé par le sujet, je te recommande vivement un excellent livre bourré d'exemples pratiques : "AI Application Programming -2nd Edition", Par M.Tim Jones, chez Charles River Media.
Je ne sais déclarer ni une liste dont le nombre d'éléments est
variable,
Ca, c'est facile - Redim et Redim Preserve.
Voir :
http://faq.vb.free.fr/index.php?question3
http://faq.vb.free.fr/index.php?question0
ni un tableau dont le nombre de dimensions est variable.
Ca, c'est un problème mal posé - Ce n'est pas une question de
langage, c'est un problème de modélisation.
Si tu y réfléchis, tu verras que pouvoir disposer d'un tableau
dont le nombre de dimensions n'est pas connu à l'avance ne
t'avance à rien.
Plus simplement, tout peut se ramener à un tableau à une dimension
dont les éléments peuvent eux même être des tableaux dont les
élements peuvent eux même être des tableaux, etc.
Bête exemple:
Option Explicit
Private Type b
c(10) As Integer
End Type
Dim a(10) As b
Private Sub Form_Load()
a(1).c(3) = 666
End Sub
a est un tableau à une dimension, chaque élément de a est un autre
tableau a 10 dimensions.
Il n'y a pas de limites à ce genre de déclarations. Et bien sur, a et b
peuvent eux même être dynamiques, alloués et désalloués avec Redim.
[Note: si il le fallait vraiment, je saurais écrire un programme qui
manipule un tableau "dont le nombre de dimensions est variable". Ca
n'aurait pas d'intérêt, mais c'est faisable.]
Plus philosophiquement, pensez-vous que le nombre de dimensions d'un
problème donné soit une limite théorique à l'IA ?
Absolument pas :-) On sait déclarer des tableaux à autant de "dimensions"
que l'on veut, c'est simplement une question de choix de structures de
données.
(Note bien que l'IA est un sujet extrèmement vaste, et que derrière le sigle
se cache des milliers de réalité différente, allant de la programmation
génétique au data mining, de la "compréhension" du langage naturel aux
applications des réseaux de neurones, et j'en passe et des meilleures. Mais
aucune des branches de l'IA ne bloque sur un problème de représentation
des "dimensions".)
Si tu es intéressé par le sujet, je te recommande vivement un excellent
livre
bourré d'exemples pratiques : "AI Application Programming -2nd Edition",
Par M.Tim Jones, chez Charles River Media.
Je ne sais déclarer ni une liste dont le nombre d'éléments est variable,
Ca, c'est facile - Redim et Redim Preserve. Voir : http://faq.vb.free.fr/index.php?question3 http://faq.vb.free.fr/index.php?question0
ni un tableau dont le nombre de dimensions est variable.
Ca, c'est un problème mal posé - Ce n'est pas une question de langage, c'est un problème de modélisation.
Si tu y réfléchis, tu verras que pouvoir disposer d'un tableau dont le nombre de dimensions n'est pas connu à l'avance ne t'avance à rien.
Plus simplement, tout peut se ramener à un tableau à une dimension dont les éléments peuvent eux même être des tableaux dont les élements peuvent eux même être des tableaux, etc.
Bête exemple: Option Explicit
Private Type b c(10) As Integer End Type
Dim a(10) As b
Private Sub Form_Load() a(1).c(3) = 666 End Sub
a est un tableau à une dimension, chaque élément de a est un autre tableau a 10 dimensions.
Il n'y a pas de limites à ce genre de déclarations. Et bien sur, a et b peuvent eux même être dynamiques, alloués et désalloués avec Redim.
[Note: si il le fallait vraiment, je saurais écrire un programme qui manipule un tableau "dont le nombre de dimensions est variable". Ca n'aurait pas d'intérêt, mais c'est faisable.]
Plus philosophiquement, pensez-vous que le nombre de dimensions d'un problème donné soit une limite théorique à l'IA ?
Absolument pas :-) On sait déclarer des tableaux à autant de "dimensions" que l'on veut, c'est simplement une question de choix de structures de données.
(Note bien que l'IA est un sujet extrèmement vaste, et que derrière le sigle se cache des milliers de réalité différente, allant de la programmation génétique au data mining, de la "compréhension" du langage naturel aux applications des réseaux de neurones, et j'en passe et des meilleures. Mais aucune des branches de l'IA ne bloque sur un problème de représentation des "dimensions".)
Si tu es intéressé par le sujet, je te recommande vivement un excellent livre bourré d'exemples pratiques : "AI Application Programming -2nd Edition", Par M.Tim Jones, chez Charles River Media.
Bonjour. a est un tableau à une dimension, chaque élément de a est un autre
tableau a 10 dimensions.
Je voulais dire bien sur: "chaque élément de a est un autre tableau a 1 dimension". A() est un tableau à une dimension de 10 éléments. Chanque élément de a() est un tableau à une dimension de 10 éléments.
A est donc ici isomorphe à un tableau à 2 dimensions ayant 10 élements par dimension que l'on pourrait écrire: Dim a(10, 10)
Bonjour.
a est un tableau à une dimension, chaque élément de a est un autre
tableau a 10 dimensions.
Je voulais dire bien sur: "chaque élément de a est un autre
tableau a 1 dimension".
A() est un tableau à une dimension de 10 éléments. Chanque élément
de a() est un tableau à une dimension de 10 éléments.
A est donc ici isomorphe à un tableau à 2 dimensions ayant 10 élements
par dimension que l'on pourrait écrire:
Dim a(10, 10)
Bonjour. a est un tableau à une dimension, chaque élément de a est un autre
tableau a 10 dimensions.
Je voulais dire bien sur: "chaque élément de a est un autre tableau a 1 dimension". A() est un tableau à une dimension de 10 éléments. Chanque élément de a() est un tableau à une dimension de 10 éléments.
A est donc ici isomorphe à un tableau à 2 dimensions ayant 10 élements par dimension que l'on pourrait écrire: Dim a(10, 10)
Merci. J'ai compris comment déclarer un tel tableau. Mais il me manque de savoir comment renvoyer une valeur donnée de ce tableau (sans connaître n). Exemple : a(1).b(1)...n(1)
Merci.
J'ai compris comment déclarer un tel tableau. Mais il me manque de
savoir comment renvoyer une valeur donnée de ce tableau (sans
connaître n).
Exemple : a(1).b(1)...n(1)
Merci. J'ai compris comment déclarer un tel tableau. Mais il me manque de savoir comment renvoyer une valeur donnée de ce tableau (sans connaître n). Exemple : a(1).b(1)...n(1)
Jean-marc
fraction wrote:
Merci. J'ai compris comment déclarer un tel tableau. Mais il me manque de savoir comment renvoyer une valeur donnée de ce tableau (sans connaître n). Exemple : a(1).b(1)...n(1)
Ce n'est pas possible - C'est un problème de structure de données.
Est ce que ce qui t'intérrèsse, ca ne serait pas plutot un arbre ? http://fr.wikipedia.org/wiki/Catégorie:Arbre_(structure_de_données)
Merci.
J'ai compris comment déclarer un tel tableau. Mais il me manque de
savoir comment renvoyer une valeur donnée de ce tableau (sans
connaître n).
Exemple : a(1).b(1)...n(1)
Ce n'est pas possible - C'est un problème de structure de données.
Est ce que ce qui t'intérrèsse, ca ne serait pas plutot un
arbre ?
http://fr.wikipedia.org/wiki/Catégorie:Arbre_(structure_de_données)
Merci. J'ai compris comment déclarer un tel tableau. Mais il me manque de savoir comment renvoyer une valeur donnée de ce tableau (sans connaître n). Exemple : a(1).b(1)...n(1)
Ce n'est pas possible - C'est un problème de structure de données.
Est ce que ce qui t'intérrèsse, ca ne serait pas plutot un arbre ? http://fr.wikipedia.org/wiki/Catégorie:Arbre_(structure_de_données)
Ce n'est pas possible - C'est un problème de structure de données.
Même si n est connu lors de l'exécution (en redimensionnant un objet ou un variant qui contient le tableau par exemple) ?
Est ce que ce qui t'intérrèsse, ca ne serait pas plutot un arbre ?http://fr.wikipedia.org/wiki/Catégorie:Arbre_(structure_de_donn ées)
Ça m'intéresse aussi, mais pour d'autres raisons. J'aurais éventuellement besoin de définir un arbre causal (type arbre généalogique).
Jean-marc
fraction wrote:
Exemple : a(1).b(1)...n(1)
Ce n'est pas possible - C'est un problème de structure de données.
Même si n est connu lors de l'exécution (en redimensionnant un objet ou un variant qui contient le tableau par exemple) ?
Non, en tout cas pas sous cette forme.
Ce qu'il est possible de faire [en supposant que ça ait un sens, ce qui n'est pas le cas] c'est de déclarer un tableau à une dimension (en gros, c'est juste de la mémoire que tu alloues) et de dynamiquement décider de la structure.
L'idée générale est la suivante: Imaginons que je veuille représenter une matrice (10,10). c'est donc un tableau à 2 dimensions, de 10 éléments dans chaque dimension. Je peux en VB déclare ça: Dim a(10, 10)
Mais en fait, ça traduit juste un besoin de 100 cases mémoires. Je peux donc tout aussi bien déclarer: Dim a(100)
Du coup, je peux décider que pour faire référence à la case mémoire correspondant aux coordonnées (x,y), j'accède à l'élément a((x-1)*10 + y) ou encore (c'est purement arbitraire): a(x + (y-1)*10)
Tu peux généraliser ça à un usage à N dimensions, avec n inconnu.
Tu peux même faire varier N au cours du temps, avec à la clef un amusant problème de relocation des données ...
Je précise que tout ça n'a aucun intérêt: en pratique, un programme doit savoir à l'avance ce qu'il manipule.
[ca rappelle les questions que nous avons de temps en temps sur "comment créer dynamiquement une variable" : c'est un non-sens, puis que si cela était possible, il faudrait alors que le programme génère aussi dynamiquement du code pour utiliser cette nouvelle variable ...]
Ce n'est pas possible - C'est un problème de structure de données.
Même si n est connu lors de l'exécution (en redimensionnant un objet
ou un variant qui contient le tableau par exemple) ?
Non, en tout cas pas sous cette forme.
Ce qu'il est possible de faire [en supposant que ça ait un
sens, ce qui n'est pas le cas] c'est de déclarer un tableau
à une dimension (en gros, c'est juste de la mémoire que tu
alloues) et de dynamiquement décider de la structure.
L'idée générale est la suivante:
Imaginons que je veuille représenter une matrice (10,10).
c'est donc un tableau à 2 dimensions, de 10 éléments dans
chaque dimension.
Je peux en VB déclare ça:
Dim a(10, 10)
Mais en fait, ça traduit juste un besoin de 100 cases mémoires.
Je peux donc tout aussi bien déclarer:
Dim a(100)
Du coup, je peux décider que pour faire référence à la case mémoire
correspondant aux coordonnées (x,y), j'accède à l'élément
a((x-1)*10 + y)
ou encore (c'est purement arbitraire): a(x + (y-1)*10)
Tu peux généraliser ça à un usage à N dimensions, avec n inconnu.
Tu peux même faire varier N au cours du temps, avec à la clef un
amusant problème de relocation des données ...
Je précise que tout ça n'a aucun intérêt: en pratique, un programme
doit savoir à l'avance ce qu'il manipule.
[ca rappelle les questions que nous avons de temps en temps sur
"comment créer dynamiquement une variable" : c'est un non-sens,
puis que si cela était possible, il faudrait alors que le programme
génère aussi dynamiquement du code pour utiliser cette nouvelle
variable ...]
Ce n'est pas possible - C'est un problème de structure de données.
Même si n est connu lors de l'exécution (en redimensionnant un objet ou un variant qui contient le tableau par exemple) ?
Non, en tout cas pas sous cette forme.
Ce qu'il est possible de faire [en supposant que ça ait un sens, ce qui n'est pas le cas] c'est de déclarer un tableau à une dimension (en gros, c'est juste de la mémoire que tu alloues) et de dynamiquement décider de la structure.
L'idée générale est la suivante: Imaginons que je veuille représenter une matrice (10,10). c'est donc un tableau à 2 dimensions, de 10 éléments dans chaque dimension. Je peux en VB déclare ça: Dim a(10, 10)
Mais en fait, ça traduit juste un besoin de 100 cases mémoires. Je peux donc tout aussi bien déclarer: Dim a(100)
Du coup, je peux décider que pour faire référence à la case mémoire correspondant aux coordonnées (x,y), j'accède à l'élément a((x-1)*10 + y) ou encore (c'est purement arbitraire): a(x + (y-1)*10)
Tu peux généraliser ça à un usage à N dimensions, avec n inconnu.
Tu peux même faire varier N au cours du temps, avec à la clef un amusant problème de relocation des données ...
Je précise que tout ça n'a aucun intérêt: en pratique, un programme doit savoir à l'avance ce qu'il manipule.
[ca rappelle les questions que nous avons de temps en temps sur "comment créer dynamiquement une variable" : c'est un non-sens, puis que si cela était possible, il faudrait alors que le programme génère aussi dynamiquement du code pour utiliser cette nouvelle variable ...]
> Tu peux même faire varier N au cours du temps, avec à la clef un amusant problème de relocation des données ...
Je ne suis pas d'accord avec le mot "amusant". :-) J'ai une propriété d'objet à étudier. Sa valeur de vérité (ou d'existence) dépend de la valeur de vérité de n autres propriétés . Je veux que mon déducteur me donne toutes les combinaisons possibles. Et je ne trouve pas ça "amusant". :-)
> Tu peux même faire varier N au cours du temps, avec à la clef un
amusant problème de relocation des données ...
Je ne suis pas d'accord avec le mot "amusant". :-)
J'ai une propriété d'objet à étudier. Sa valeur de vérité (ou
d'existence) dépend de la valeur de vérité de n autres propriétés . Je
veux que mon déducteur me donne toutes les combinaisons possibles. Et
je ne trouve pas ça "amusant". :-)
> Tu peux même faire varier N au cours du temps, avec à la clef un amusant problème de relocation des données ...
Je ne suis pas d'accord avec le mot "amusant". :-) J'ai une propriété d'objet à étudier. Sa valeur de vérité (ou d'existence) dépend de la valeur de vérité de n autres propriétés . Je veux que mon déducteur me donne toutes les combinaisons possibles. Et je ne trouve pas ça "amusant". :-)
fraction
On 18 oct, 15:42, fraction wrote:
> Tu peux même faire varier N au cours du temps, avec à la clef un > amusant problème de relocation des données ...
Je ne suis pas d'accord avec le mot "amusant". :-) J'ai une propriété d'objet à étudier. Sa valeur de vérité (ou d'existence) dépend de la valeur de vérité de n autres propriét és. Je veux que mon déducteur me donne toutes les combinaisons possibles. Et je ne trouve pas ça "amusant". :-)
Ça y est, je crois avoir trouver. Etant donné qu'il n'y a que deux valeurs, 0 et 1 (je gèrerais les contradictions après), il suffit de convertir les coordonnées en chaîne binaire inversée (plus 1). a(1).b(1).c(0) se transforme en 011=3 (plus un) égal 4. Le dimensionnement est facile, c'est 2^(nombre de propriétés).
On 18 oct, 15:42, fraction <fract...@tele2.fr> wrote:
> Tu peux même faire varier N au cours du temps, avec à la clef un
> amusant problème de relocation des données ...
Je ne suis pas d'accord avec le mot "amusant". :-)
J'ai une propriété d'objet à étudier. Sa valeur de vérité (ou
d'existence) dépend de la valeur de vérité de n autres propriét és. Je
veux que mon déducteur me donne toutes les combinaisons possibles. Et
je ne trouve pas ça "amusant". :-)
Ça y est, je crois avoir trouver. Etant donné qu'il n'y a que deux
valeurs, 0 et 1 (je gèrerais les contradictions après), il suffit de
convertir les coordonnées en chaîne binaire inversée (plus 1).
a(1).b(1).c(0) se transforme en 011=3 (plus un) égal 4.
Le dimensionnement est facile, c'est 2^(nombre de propriétés).
> Tu peux même faire varier N au cours du temps, avec à la clef un > amusant problème de relocation des données ...
Je ne suis pas d'accord avec le mot "amusant". :-) J'ai une propriété d'objet à étudier. Sa valeur de vérité (ou d'existence) dépend de la valeur de vérité de n autres propriét és. Je veux que mon déducteur me donne toutes les combinaisons possibles. Et je ne trouve pas ça "amusant". :-)
Ça y est, je crois avoir trouver. Etant donné qu'il n'y a que deux valeurs, 0 et 1 (je gèrerais les contradictions après), il suffit de convertir les coordonnées en chaîne binaire inversée (plus 1). a(1).b(1).c(0) se transforme en 011=3 (plus un) égal 4. Le dimensionnement est facile, c'est 2^(nombre de propriétés).
Jean-marc
fraction wrote:
On 18 oct, 15:42, fraction wrote:
Tu peux même faire varier N au cours du temps, avec à la clef un amusant problème de relocation des données ...
Je ne suis pas d'accord avec le mot "amusant". :-) J'ai une propriété d'objet à étudier. Sa valeur de vérité (ou d'existence) dépend de la valeur de vérité de n autres propriétés. Je veux que mon déducteur me donne toutes les combinaisons possibles. Et je ne trouve pas ça "amusant". :-)
Ça y est, je crois avoir trouver. Etant donné qu'il n'y a que deux valeurs, 0 et 1 (je gèrerais les contradictions après), il suffit de convertir les coordonnées en chaîne binaire inversée (plus 1). a(1).b(1).c(0) se transforme en 011=3 (plus un) égal 4. Le dimensionnement est facile, c'est 2^(nombre de propriétés).
Voila qui semble d'un coup beaucoup plus raisonnable. Astuce pour parcourir toutes les combinaisons possibles : il suffit de "compter" de 0 à (2^n)-1 et de regarder la valeur en base 2. Ainsi, si on a 3 propriétés: 2^3-1 = 8-1 = 7 0 000 1 001 2 010 3 011 4 100 5 101 6 110 7 111
On n'a pas non plus forcément besoin de passer par une chaine, il suffit bien souvent de garder un nombre puis de jouer avec les masques binaires et les opérateurs (bitwise) AND et OR.
On 18 oct, 15:42, fraction <fract...@tele2.fr> wrote:
Tu peux même faire varier N au cours du temps, avec à la clef un
amusant problème de relocation des données ...
Je ne suis pas d'accord avec le mot "amusant". :-)
J'ai une propriété d'objet à étudier. Sa valeur de vérité (ou
d'existence) dépend de la valeur de vérité de n autres propriétés. Je
veux que mon déducteur me donne toutes les combinaisons possibles. Et
je ne trouve pas ça "amusant". :-)
Ça y est, je crois avoir trouver. Etant donné qu'il n'y a que deux
valeurs, 0 et 1 (je gèrerais les contradictions après), il suffit de
convertir les coordonnées en chaîne binaire inversée (plus 1).
a(1).b(1).c(0) se transforme en 011=3 (plus un) égal 4.
Le dimensionnement est facile, c'est 2^(nombre de propriétés).
Voila qui semble d'un coup beaucoup plus raisonnable.
Astuce pour parcourir toutes les combinaisons possibles : il suffit
de "compter" de 0 à (2^n)-1 et de regarder la valeur en base 2.
Ainsi, si on a 3 propriétés:
2^3-1 = 8-1 = 7
0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111
On n'a pas non plus forcément besoin de passer par une chaine,
il suffit bien souvent de garder un nombre puis de jouer avec
les masques binaires et les opérateurs (bitwise) AND et OR.
Tu peux même faire varier N au cours du temps, avec à la clef un amusant problème de relocation des données ...
Je ne suis pas d'accord avec le mot "amusant". :-) J'ai une propriété d'objet à étudier. Sa valeur de vérité (ou d'existence) dépend de la valeur de vérité de n autres propriétés. Je veux que mon déducteur me donne toutes les combinaisons possibles. Et je ne trouve pas ça "amusant". :-)
Ça y est, je crois avoir trouver. Etant donné qu'il n'y a que deux valeurs, 0 et 1 (je gèrerais les contradictions après), il suffit de convertir les coordonnées en chaîne binaire inversée (plus 1). a(1).b(1).c(0) se transforme en 011=3 (plus un) égal 4. Le dimensionnement est facile, c'est 2^(nombre de propriétés).
Voila qui semble d'un coup beaucoup plus raisonnable. Astuce pour parcourir toutes les combinaisons possibles : il suffit de "compter" de 0 à (2^n)-1 et de regarder la valeur en base 2. Ainsi, si on a 3 propriétés: 2^3-1 = 8-1 = 7 0 000 1 001 2 010 3 011 4 100 5 101 6 110 7 111
On n'a pas non plus forcément besoin de passer par une chaine, il suffit bien souvent de garder un nombre puis de jouer avec les masques binaires et les opérateurs (bitwise) AND et OR.
