Indice array per righe, offset e indirizzo
In un array 3×4×5 con elementi da 8 byte, la posizione 1, 2, 3 è l'elemento 33: offset di 264 byte e indirizzo 4360 dalla base 4096. Ogni passaggio intermedio è visibile, per controllare l'aritmetica dei puntatori o fare il debug di un buffer appiattito. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Dimensioni
- 3, 4, 5
- Indici
- 1, 2, 3
- Dimensione dell'elemento (byte)
- 8
- Indirizzo di base
- 4096
- Ordine
- row-major
- Passi (stride)
- 20, 5, 1
- Contributi
- 20, 10, 3
- Indice lineare
- 33
Questo calcolatore converte le coordinate di un array multidimensionale nell’unica posizione lineare usata dalla disposizione contigua per righe in stile C. Inserisca le dimensioni dall’asse più esterno a quello più interno, l’indice a base zero di ogni asse, la dimensione dell’elemento in byte e, facoltativamente, un indirizzo di base. Il risultato mostra lo stride di ogni asse, il contributo di ciascun indice, l’offset dell’elemento, l’offset in byte e l’indirizzo finale.
Inserisca dimensioni e indici nello stesso ordine
Elenci le dimensioni dall’asse più esterno a quello più interno, esattamente come compaiono nella dichiarazione o nella shape. Per un array formato da 3 piani, 4 righe e 5 colonne, inserisca 3, 4 e 5. Fornisca quindi un indice a base zero per ciascuna dimensione nello stesso ordine.
La coordinata del secondo piano, della terza riga e della quarta colonna è dunque 1, 2 e 3. Le dimensioni devono essere interi positivi; ogni indice deve essere almeno zero e strettamente minore della dimensione corrispondente. Il calcolatore rifiuta rank diversi e coordinate fuori limite, invece di produrre in silenzio un indirizzo esterno all’array.
È necessaria anche la dimensione dell’elemento, perché il solo indice non identifica una posizione in byte. Utilizzi l’effettiva larghezza di memorizzazione, ad esempio quattro byte per un comune intero a 32 bit oppure otto per un double. Se conosce l’inizio dell’array, indichi l’indirizzo di base non negativo; altrimenti lasci zero e interpreti il risultato come offset dall’inizio.
Comprenda il calcolo degli stride per righe
Nell’ordine per righe, l’ultimo asse è memorizzato in modo contiguo: avanzare di una posizione su tale asse sposta di un solo elemento, quindi il suo stride è uno. Lo stride di ogni asse precedente è il prodotto di tutte le dimensioni alla sua destra. Con dimensioni 3 per 4 per 5, gli stride sono 20, 5 e 1: avanzare di un piano salta quattro righe da cinque elementi, avanzare di una riga salta cinque elementi e avanzare di una colonna ne salta uno.
Lo strumento moltiplica ciascun indice per lo stride del relativo asse e mostra questi prodotti come contributi. La somma genera l’indice lineare a base zero. Per 1, 2 e 3, il calcolo è 1 per 20, più 2 per 5, più 3 per 1, quindi 33.
I valori intermedi rendono verificabile il risultato e aiutano a individuare dimensioni invertite o moltiplicatori dell’ordine per colonne. Tutta l’aritmetica usa interi controllati: se un prodotto o una somma supera l’intervallo sicuro di JavaScript, viene restituito un errore invece di un indirizzo arrotondato.
Converta l’indice dell’elemento in indirizzo byte
Un indice lineare conta elementi, non byte. Per ottenere l’offset in byte, lo moltiplichi per la dimensione dell’elemento. L’elemento con indice 33, usando elementi da otto byte, inizia 264 byte dopo l’inizio dell’array.
L’indirizzo finale è tale offset sommato alla base fornita: con base 4096, l’elemento inizia all’indirizzo 4360. La risposta mantiene separati indice lineare, offset, base e indirizzo, così Lei può confrontare ogni fase con il codice sorgente, un debugger, una specifica binaria o il calcolo di un buffer GPU. L’indirizzo è un intero decimale esatto entro l’intervallo sicuro; lo strumento non accede alla memoria e non ispeziona processi.
Il calcolo presume un array denso e contiguo, privo di padding fra elementi o righe. Righe con pitch, leading dimension esplicite, viste sezionate o stride personalizzati richiedono i reali stride fisici.
Casi d'uso
Verificare l’aritmetica dei puntatori
Controlli gli offset di elementi e byte usati in C, C++, Rust o WebAssembly prima di accedere a un buffer appiattito.
Correggere l’appiattimento dei tensori
Confronti stride e contributi previsti con una libreria tensoriale, un serializzatore o una routine di scambio dati.
Illustrare il layout di memoria
Mostri come ogni coordinata multidimensionale contribuisce a una posizione contigua e all’indirizzo finale.
Domande frequenti
Gli indici partono da zero?
Sì. Ogni indice parte da zero e deve essere minore della dimensione corrispondente.
Che cosa significa ordine per righe?
È un layout contiguo in cui l’ultimo asse varia più rapidamente, come nei normali array multidimensionali C.
Quale indirizzo di base devo usare?
Indichi l’indirizzo in byte in cui inizia l’array. Lasci zero se Le serve solo l’offset relativo all’inizio.
Sono supportati gli array per colonne?
No. Il calcolo implementa volutamente l’ordine per righe; la memorizzazione per colonne usa stride diversi.
Considera il padding o stride personalizzati?
No. Presume elementi densi e contigui. Layout con pitch, padding, trasposizione o sezioni richiedono gli stride fisici.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo 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)Esempio di richiesta
{
"dimensions": [
3,
4,
5
],
"indices": [
1,
2,
3
],
"element_size_bytes": 8
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.array_rowmajor_index",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_dimensions | 32 |
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Converta l’indice dell’elemento in indirizzo byte
Ogni richiesta API costa $0.002; per controlli rapidi, lo stesso calcolo deterministico è disponibile nel browser.
Domande tecniche
Quanto costa tramite API?
Ogni richiesta costa $0.002. La versione nel browser esegue localmente lo stesso calcolo deterministico.