ForHosting KIT · Matematica

Angoli del grafico a torta dai valori gratis online

I valori 1, 1 e 2 sommano 4, quindi diventano un quarto, un quarto e metà del cerchio. Inserisca una lista di valori o pesi e ottenga l'angolo di ogni fetta, che sommano esattamente 360 gradi, e la sua percentuale. Gratis nel suo browser.

Gratis
Funziona nel suo browser
Senza registrazione
I suoi dati restano sul dispositivo

Esegui gratis nel browser Vedi l'API

Usalo da WebAPIEmailTelegramApp presto

Esempio risolto

Se inserisce

Valori degli spicchi: 1, 1, 2

Ottiene

Totale: 4
Angolo (gradi): 90, 90, 180
Quota del cerchio (%): 25, 25, 50

Converte i valori o i pesi dei settori in gradi del grafico a torta che sommano a 360 e in percentuali che sommano a 100. Gratis, deterministico e privato nel Suo browser.

Dai numeri alle fette del cerchio

Un grafico a torta divide il giro completo, 360 gradi, in proporzione ai valori che rappresenta. Ogni fetta riceve il suo valore diviso per il totale e moltiplicato per 360. Con i valori 1, 1 e 2 il totale è 4, quindi le prime due fette occupano un quarto del cerchio ciascuna e l'ultima la metà. La stessa proporzione moltiplicata per 100 invece che per 360 dà la percentuale della legenda. Il calcolatore restituisce le due liste insieme, così gli angoli che disegna e le percentuali che scrive descrivono sempre la stessa ripartizione.

Perché il cerchio si chiude e a cosa fare attenzione

Quando i valori non si dividono in modo esatto, arrotondare ogni angolo per conto suo può lasciare uno spiraglio o una sovrapposizione. Qui l'ultima fetta assorbe quel piccolo resto, perciò gli angoli sommano esattamente 360 gradi e le percentuali 100. Serve per controllare i compiti, preparare un grafico a mano con il goniometro o verificare un foglio di calcolo. Gli errori più comuni sono dimenticare di dividere per il totale, mescolare percentuali e quantità grezze nella stessa lista e inserire una lista vuota o con totale zero, che il calcolatore rifiuta.

Casi d'uso

Compiti ed esami

Verifichi rapidamente i classici problemi quantitativi con risposte stabili e riproducibili.

Automazione

Richiami la stessa funzione pura dagli script senza installare un foglio di calcolo o un CAS.

Domande frequenti

È gratis?

Sì. Il tier A gira interamente nel Suo browser senza account.

Effettua chiamate di rete?

No. Il motore parse mantiene tutto sul dispositivo.

Come si trasformano dei valori in angoli di un grafico a torta?

Divida ogni valore per il totale e moltiplichi per 360. Così ogni fetta occupa del cerchio la stessa parte che il suo valore occupa della somma, e il calcolatore lo fa per tutta la lista in una volta.

Perché gli angoli sommano sempre esattamente 360?

Perché il piccolo resto lasciato dall'arrotondamento viene assegnato all'ultima fetta. Così nel grafico non resta nessuno spiraglio né sovrapposizione, e anche le percentuali sommano 100.

I valori devono essere percentuali?

No. Può usare conteggi, misure o pesi su qualsiasi scala, purché il totale sia maggiore di zero. Il calcolatore restituisce gli angoli e anche la percentuale di ogni fetta, che sommano 100.

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

POSThttps://api.kit.forhosting.com/math/pie-chart-angles

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/math/pie-chart-angles \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"values":[1,1,2]}'

const res = await fetch("https://api.kit.forhosting.com/math/pie-chart-angles", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "values": [
      1,
      1,
      2
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/math/pie-chart-angles",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "values": [
        1,
        1,
        2
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/pie-chart-angles", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"values":[1,1,2]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"values":[1,1,2]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/pie-chart-angles", 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

{
  "values": [
    1,
    1,
    2
  ]
}

Esempio di risposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "math.pie_chart_angles",
  "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

per richiesta$0.002

Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.

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

Come funziona

Ogni angolo è valore/totale moltiplicato per 360 gradi. L'ultimo settore assorbe il residuo di arrotondamento affinché la somma resti esattamente 360. L'implementazione è completamente deterministica e gira gratis nel browser con la stessa funzione pura del percorso API. Gli input vengono convalidati prima di qualsiasi calcolo, così i tipi errati e i valori out-of-range diventano chiari errori invalid_input invece di silenziosi risultati NaN. L'implementazione è completamente deterministica e gira gratis nel browser con la stessa funzione pura del percorso API. Gli input vengono convalidati prima di qualsiasi calcolo, così i tipi errati e i valori out-of-range diventano chiari errori invalid_input invece di silenziosi risultati NaN.

Input e output

I campi obbligatori devono essere presenti e con il tipo corretto. I campi facoltativi usano i valori predefiniti documentati. I messaggi di errore usano sottostringhe stabili in inglese per l'aggancio dell'harness. Converte i valori o i pesi dei settori in gradi del grafico a torta che sommano a 360 e in percentuali che sommano a 100. Indichi i campi elencati nello schema di input. Il payload di successo include sempre i campi principali del risultato indicati nello schema di output, così i client possono collegare le metriche dell'interfaccia senza tirare a indovinare. L'implementazione è completamente deterministica e gira gratis nel browser con la stessa funzione pura del percorso API. Gli input vengono convalidati prima di qualsiasi calcolo, così i tipi errati e i valori out-of-range diventano chiari errori invalid_input invece di silenziosi risultati NaN.

Casi limite e vincoli

Rifiuta gli array vuoti e i totali non positivi. Gli intervalli vuoti o contraddittori vengono respinti subito. I valori intermedi estremamente grandi che vanno in overflow rispetto a IEEE-754 diventano un errore out-of-range anziché campi null. L'implementazione è completamente deterministica e gira gratis nel browser con la stessa funzione pura del percorso API. Gli input vengono convalidati prima di qualsiasi calcolo, così i tipi errati e i valori out-of-range diventano chiari errori invalid_input invece di silenziosi risultati NaN. L'implementazione è completamente deterministica e gira gratis nel browser con la stessa funzione pura del percorso API. Gli input vengono convalidati prima di qualsiasi calcolo, così i tipi errati e i valori out-of-range diventano chiari errori invalid_input invece di silenziosi risultati NaN.

Casi di integrazione

Dimostrazioni didattiche

Mostri esempi svolti con fixture golden che corrispondono al widget gratuito e all'API.

Domande tecniche

E se il mio input non è valido?

Riceve invalid_input con un messaggio chiaro in inglese.

I risultati sono stabili?

Sì. La matematica deterministica e gli esempi golden fissano il contratto.

Chi è l'autore di questa capacità?

samurai nel workshop del KIT di ForHosting.

Leggi la documentazione completa del KIT →

Esegui gratis nel browser