ForHosting KIT · Outils pour développeurs

Indice de tableau par lignes, décalage et adresse

Dans un tableau 3×4×5 d'éléments de 8 octets, la position 1, 2, 3 correspond à l'élément 33 : décalage de 264 octets et adresse 4360 depuis la base 4096. Chaque étape intermédiaire s'affiche pour vérifier l'arithmétique de pointeurs ou déboguer un tampon aplati. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Dimensions: 3, 4, 5
Indices: 1, 2, 3
Taille de l'élément (octets): 8
Adresse de base: 4 096

Vous obtenez

Ordre: row-major
Pas (strides): 20, 5, 1
Contributions: 20, 10, 3
Indice linéaire: 33

Ce calculateur convertit les coordonnées d’un tableau multidimensionnel en la position linéaire unique employée par une disposition contiguë par lignes de style C. Saisissez les dimensions de l’axe extérieur vers l’axe intérieur, l’indice à base zéro associé à chaque axe, la taille d’un élément en octets et, éventuellement, une adresse de base. Le résultat détaille le pas de chaque axe, la contribution de chaque indice, le décalage de l’élément, son décalage en octets et son adresse finale.

Saisir les tailles et la position dans le même ordre

Énumérez les tailles depuis l’axe le plus extérieur jusqu’à l’axe le plus intérieur, telles qu’elles figurent dans la déclaration ou la forme du tableau. Pour un tableau de 3 plans, 4 lignes et 5 colonnes, saisissez 3, 4 et 5. Indiquez ensuite un indice à base zéro pour chaque dimension, dans le même ordre.

Les coordonnées du deuxième plan, de la troisième ligne et de la quatrième colonne sont donc 1, 2 et 3. Chaque dimension doit être un entier positif, tandis que chaque indice doit être supérieur ou égal à zéro et strictement inférieur à la dimension correspondante. Le calculateur refuse les rangs incompatibles et les coordonnées hors limites afin de ne jamais produire discrètement une adresse extérieure au tableau.

La taille d’un élément est également indispensable, car un indice d’élément ne suffit pas à désigner un emplacement en octets. Utilisez la largeur de stockage réelle, par exemple quatre octets pour un entier courant de 32 bits ou huit pour un double. Si vous connaissez le début du tableau, indiquez cette adresse de base positive ou nulle ; sinon, conservez zéro et interprétez le résultat comme un décalage relatif.

Comprenez le calcul des pas en ordre par lignes

En ordre par lignes, le dernier axe est stocké de manière contiguë : avancer d’une position sur cet axe déplace exactement d’un élément, et son pas vaut donc un. Le pas de chaque axe précédent correspond au produit de toutes les dimensions placées à sa droite. Avec des dimensions 3 par 4 par 5, les pas sont 20, 5 et 1 : changer de plan saute quatre lignes de cinq éléments, changer de ligne saute cinq éléments et changer de colonne en saute un.

L’outil multiplie chaque indice par le pas de son axe et affiche ces produits comme contributions. Leur somme donne l’indice linéaire à base zéro. Pour 1, 2 et 3, le calcul est 1 fois 20, plus 2 fois 5, plus 3 fois 1, soit 33.

Ces valeurs intermédiaires facilitent l’audit et révèlent les erreurs fréquentes, comme l’inversion des dimensions ou l’emploi de multiplicateurs propres à l’ordre par colonnes. Tous les calculs utilisent des entiers contrôlés ; tout dépassement de la plage sûre de JavaScript produit une erreur plutôt qu’une adresse arrondie.

Transformez l’indice en adresse exprimée en octets

Un indice linéaire compte des éléments, et non des octets. Pour obtenir le décalage en octets, multipliez-le par la taille d’un élément. L’élément d’indice 33, avec des éléments de huit octets, commence 264 octets après le début du tableau.

L’adresse finale est ce décalage ajouté à l’adresse de base : avec une base de 4096, l’élément commence à l’adresse 4360. La réponse sépare l’indice linéaire, le décalage, la base et l’adresse finale afin que vous puissiez comparer chaque étape avec le code source, un débogueur, une spécification binaire ou un calcul de tampon GPU. L’adresse est renvoyée sous forme d’entier décimal exact dans la plage sûre ; aucun accès mémoire ni examen de processus n’est effectué.

Le calcul suppose un tableau dense, contigu et dépourvu de remplissage entre lignes ou éléments. Les lignes avec pitch, dimensions principales explicites, vues découpées ou pas personnalisés nécessitent leurs pas physiques réels.

Cas d’usage

Vérifier l’arithmétique des pointeurs

Validez les décalages d’éléments et d’octets employés en C, C++, Rust ou WebAssembly avant d’accéder à un tampon aplati.

Déboguer l’aplatissement d’un tenseur

Comparez les pas et contributions attendus à ceux d’une bibliothèque de tenseurs, d’un sérialiseur ou d’une routine d’échange.

Expliquer l’organisation en mémoire

Montrez comment chaque coordonnée multidimensionnelle contribue à une position contiguë et à l’adresse finale.

Questions fréquentes

Les indices commencent-ils à zéro ?

Oui. Chaque indice commence à zéro et doit rester inférieur à la taille de la dimension correspondante.

Qu’est-ce que l’ordre par lignes ?

C’est une disposition contiguë dans laquelle le dernier axe varie le plus rapidement, comme dans les tableaux multidimensionnels C.

Quelle adresse de base faut-il utiliser ?

Indiquez l’adresse en octets où commence le tableau. Gardez zéro si vous souhaitez uniquement un décalage relatif au début.

Les tableaux en ordre par colonnes sont-ils acceptés ?

Non. Le calcul applique volontairement l’ordre par lignes ; le stockage par colonnes exige une autre suite de pas.

Le remplissage ou les pas personnalisés sont-ils pris en compte ?

Non. Les éléments doivent être denses et contigus. Un stockage avec pitch, remplissage, transposition ou découpage exige ses pas physiques.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/dev/array-rowmajor-index

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/dev/array-rowmajor-index \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dimensions":[3,4,5],"indices":[1,2,3],"element_size_bytes":8}'

const res = await fetch("https://api.kit.forhosting.com/dev/array-rowmajor-index", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "dimensions": [
      3,
      4,
      5
    ],
    "indices": [
      1,
      2,
      3
    ],
    "element_size_bytes": 8
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/array-rowmajor-index",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "dimensions": [
        3,
        4,
        5
    ],
    "indices": [
        1,
        2,
        3
    ],
    "element_size_bytes": 8
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/array-rowmajor-index", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"dimensions":[3,4,5],"indices":[1,2,3],"element_size_bytes":8}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"dimensions":[3,4,5],"indices":[1,2,3],"element_size_bytes":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/array-rowmajor-index", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "dimensions": [
    3,
    4,
    5
  ],
  "indices": [
    1,
    2,
    3
  ],
  "element_size_bytes": 8
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.array_rowmajor_index",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

max_dimensions 32

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Transformez l’indice en adresse exprimée en octets

Chaque requête API coûte $0.002, tandis que le même calcul déterministe est disponible dans le navigateur pour une vérification rapide.

Questions techniques

Quel est le tarif via l’API ?

Chaque requête coûte $0.002. La version pour navigateur exécute localement le même calcul déterministe.

Consulter la documentation complète du KIT →

Lancer gratuitement

Exemple résolu

Saisir les tailles et la position dans le même ordre

Comprenez le calcul des pas en ordre par lignes

Transformez l’indice en adresse exprimée en octets

Cas d’usage

Vérifier l’arithmétique des pointeurs

Déboguer l’aplatissement d’un tenseur

Expliquer l’organisation en mémoire

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Limites

Erreurs

Notes techniques

Transformez l’indice en adresse exprimée en octets

Questions techniques

merci