xarray

package module
v0.0.0-...-c367913 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 8, 2026 License: MIT Imports: 20 Imported by: 0

README

xarray-go

Tableaux N-dimensionnels étiquetés en Go, inspirés de la bibliothèque Python xarray.

L'idée : manipuler des tableaux multi-dimensionnels dont les axes portent un nom (temps, latitude, longitude…) et des coordonnées (des étiquettes réelles), afin d'indexer par label plutôt que par position numérique.

⚠️ Projet en cours de construction, livré par incréments en méthode agile. Les tableaux sont génériques sur un type numérique (int, uint, float32, float64… via la contrainte Number).

Installation

go get github.com/benedictemarty/xarray

Exemple

package main

import (
	"fmt"

	"github.com/benedictemarty/xarray"
)

func main() {
	da, _ := xarray.NewDataArray(
		[]string{"temps", "lieu"},
		[]int{2, 3},
		[]float64{1, 2, 3, 4, 5, 6},
		map[string][]float64{
			"temps": {2020, 2021},
			"lieu":  {10, 20, 30},
		},
		"température",
	)

	fmt.Println(da)

	// Indexation par label : la ligne correspondant à l'année 2021.
	sub, _ := da.Sel("temps", 2021)
	fmt.Println(sub.Data()) // [4 5 6]

	fmt.Println("moyenne :", da.Mean()) // 3.5
}

Architecture

Trois niveaux, calqués sur xarray :

Niveau Rôle État
Variable Données plates + dimensions nommées + attributs (brique de base) ✅ Sprint 1
DataArray Variable + coordonnées étiquetées + nom (indexation par label) ✅ Sprint 1
Dataset Collection de DataArray partageant dimensions et coordonnées ✅ Sprint 3

Voir docs/ARCHITECTURE.md pour les détails.

Feuille de route

Voir docs/agile/ROADMAP.md et le backlog produit.

  • Sprint 1 — Cœur Variable / DataArray (indexation isel/sel, réductions) ✅
  • Sprint 2 — Opérations : broadcasting, alignement, arithmétique, réductions par axe ✅
  • Sprint 3 — Dataset (regroupement, sel/isel et réductions propagés, fusion) ✅
  • Sprint 4 — Entrées/sorties : JSON et CSV (aller-retour) ✅
  • Sprint 5 — Généralisation des types (generics int/float32/float64…) ✅
  • Sprint 6 — Jointures externes (inner/outer/left/right) ✅
  • Sprint 7 — Benchmarks et optimisations ✅
  • Sprint 8 — netCDF, sous-ensemble classique CDF-1 (aller-retour) ✅

Note generics : les constructeurs infèrent le type depuis les données. Les fonctions de lecture demandent un paramètre de type explicite, ex. xarray.ReadDataArrayCSV[float64](r).

Entrées / sorties

// JSON (DataArray ou Dataset)
_ = da.WriteJSON(w)
da2, _ := xarray.ReadDataArrayJSON[float64](r)
_ = ds.WriteJSON(w)
ds2, _ := xarray.ReadDatasetJSON[float64](r)

// CSV « tidy » : une ligne par cellule (colonnes = dimensions + valeur)
_ = da.WriteCSV(w)
da3, _ := xarray.ReadDataArrayCSV[float64](r)

// netCDF classique (CDF-1), sous-ensemble
_ = ds.WriteNetCDF(w)
ds3, _ := xarray.ReadDatasetNetCDF[float64](r)

// Zarr v2 (chunké, compression none/zlib) — interop zarr-python vérifiée
_ = xarray.WriteDataArrayZarr("data.zarr", da, []int{2, 3}, xarray.ZarrZlib)
da4, _ := xarray.ReadDataArrayZarr("data.zarr")

Voir docs/ZARR.md pour le périmètre Zarr et la validation d'interopérabilité.

Limites netCDF : sous-ensemble du format classique (CDF-1) — pas de NetCDF-4/HDF5, ni records illimités, ni attributs. Types exportables : float64, float32, int32, int16, int8. L'aller-retour est validé en interne ; l'interopérabilité avec les outils netCDF de référence reste à confirmer.

Exemple de CSV produit pour un tableau température(temps, lieu) :

temps,lieu,temperature
2020,10,1
2020,20,2
...

Performances

Comparaison mesurée face à xarray (Python/NumPy) — voir docs/BENCHMARKS.md. En résumé : xarray-go domine les réductions et le groupby (5×–14× plus rapide), tandis que NumPy garde l'avantage sur le calcul élément par élément à grande taille (vectorisation).

Développement

go test ./...    # lancer tous les tests
go vet ./...     # analyse statique

Les modifications sont tracées dans CHANGELOG.md et versionnées avec git.

Licence

MIT — voir LICENSE.

Documentation

Overview

Package xarray fournit des tableaux N-dimensionnels étiquetés en Go, inspirés de la bibliothèque Python xarray.

L'architecture reprend celle de xarray :

  • Variable : conteneur bas niveau (données plates + dimensions nommées) ;
  • DataArray : Variable + coordonnées étiquetées + nom (indexation par label) ;
  • Dataset : collection de DataArrays partageant des dimensions et coordonnées.

Les tableaux sont génériques sur un type numérique (contrainte Number) et disposés en mémoire selon l'ordre C (row-major).

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func DecodeCFTime 

func DecodeCFTime(values []float64, units string) ([]float64, error)

DecodeCFTime convertit des valeurs temporelles CF (« <unité> since <date> ») en secondes depuis l'epoch Unix. Unités reconnues : seconds, minutes, hours, days (et abréviations usuelles).

func EpochCoord 

func EpochCoord(times []time.Time) []float64

EpochCoord convertit une suite d'instants en coordonnée (secondes epoch), prête à être passée comme coordonnée d'un DataArray[float64].

func EpochSeconds 

func EpochSeconds(t time.Time) float64

EpochSeconds convertit un instant en secondes depuis l'epoch Unix (UTC).

func ExtractTime 

func ExtractTime(epochCoord []float64, c TimeComponent) []float64

ExtractTime renvoie la composante c de chaque instant (coordonnée en secondes epoch). Pratique pour construire une coordonnée dérivée (ex. le mois).

func GeoCoords 

func GeoCoords(t Affine, width, height int) (xs, ys []float64, err error)

GeoCoords renvoie les coordonnées monde des CENTRES de pixels le long des axes x (par colonne) et y (par ligne), pour une grille axis-aligned (B = D = 0). Renvoie une erreur si la transformation comporte une rotation (B ou D ≠ 0), cas où x et y ne sont pas séparables en axes 1D.

func PyramidLevels 

func PyramidLevels(dir string) ([]pyramidLevel, error)

PyramidLevels lit la métadonnée « multiscales » d'une pyramide et renvoie la liste des niveaux (chemin + facteur).

func Reproject 

func Reproject(src []float64, srcW, srcH int, srcT Affine, srcCRS string,
	dstT Affine, dstW, dstH int, dstCRS string, method Resampling) ([]float64, error)

Reproject reprojette une grille source vers une grille cible selon la méthode de rééchantillonnage choisie. La transformation de coordonnées s'appuie sur TransformXY (CRS EPSG gérés). Pour une projection non-EPSG (géostationnaire), voir ReprojectFromGeos / reprojectWith.

func ReprojectFromGeos 

func ReprojectFromGeos(src []float64, srcW, srcH int, srcT Affine, geos Geostationary,
	dstT Affine, dstW, dstH int, method Resampling) ([]float64, error)

ReprojectFromGeos reprojette une grille en projection géostationnaire (affine srcT donnant les coordonnées du plan satellite en mètres) vers une grille lon/lat (dstT en degrés, EPSG:4326). Cas des scènes MTG/Meteosat FCI.

func ReprojectNearest 

func ReprojectNearest(src []float64, srcW, srcH int, srcT Affine, srcCRS string,
	dstT Affine, dstW, dstH int, dstCRS string) ([]float64, error)

ReprojectNearest reprojette une grille source (srcW×srcH, géotransformation srcT, CRS srcCRS) vers une grille cible (dstW×dstH, géotransformation dstT, CRS dstCRS) par plus proche voisin. src et le résultat sont en ordre C (ligne par ligne), indexés [row*width + col].

func ResampleSwathNearest 

func ResampleSwathNearest(data, lon, lat []float64, dstT Affine, dstW, dstH int) (grid []float64, counts []int, err error)

ResampleSwathNearest projette les valeurs data, géolocalisées par lon/lat (de même longueur), sur la grille cible définie par la géotransformation dstT (degrés, lon/lat) et dstW×dstH. Renvoie les valeurs grillées (ordre C) et le nombre de pixels sources tombés dans chaque cellule.

func ResampleSwathNearestRadius 

func ResampleSwathNearestRadius(data, lon, lat []float64, dstT Affine, dstW, dstH, radiusCells int) ([]float64, error)

ResampleSwathNearestRadius rééchantillonne une fauchée par plus proche voisin avec un rayon de recherche : pour chaque cellule cible, on retient la valeur du pixel source le plus proche (distance en lon/lat) trouvé dans une fenêtre de ±radiusCells cellules ; aucune → NaN. Contrairement au binning simple, cela COMBLE les cellules vides quand la grille cible est plus fine que la fauchée (équivalent au radius_of_influence de pyresample, exprimé ici en cellules).

func SeasonName 

func SeasonName(s int) string

SeasonName renvoie le nom court d'une saison météorologique (0..3).

func TimeFromEpoch 

func TimeFromEpoch(sec float64) time.Time

TimeFromEpoch reconstruit un instant (UTC) à partir de secondes epoch.

func TransformXY 

func TransformXY(fromCRS, toCRS string, x, y float64) (float64, float64, error)

TransformXY transforme un couple de coordonnées de fromCRS vers toCRS, en passant par le géographique WGS84 (lon/lat) comme pivot. CRS pris en charge : EPSG:4326 (lon/lat), EPSG:3857 (Web Mercator), UTM WGS84 (EPSG:326zz/327zz). Toute autre paire → erreur explicite (PROJ requis).

Convention x/y : en 4326, x = longitude, y = latitude (degrés) ; en projeté, (x, y) en mètres.

func WebMercatorForward 

func WebMercatorForward(lon, lat float64) (x, y float64)

WebMercatorForward projette (lon, lat) en degrés (EPSG:4326) vers (x, y) en mètres (EPSG:3857).

func WebMercatorInverse 

func WebMercatorInverse(x, y float64) (lon, lat float64)

WebMercatorInverse projette (x, y) en mètres (EPSG:3857) vers (lon, lat) en degrés (EPSG:4326).

func WriteDataArrayZarr 

func WriteDataArrayZarr(dir string, da *DataArray[float64], chunks []int, comp ZarrCompression) error

WriteDataArrayZarr écrit un DataArray[float64] dans le répertoire dir au format Zarr v2. chunks donne la taille de chunk par dimension (même longueur que la forme). comp choisit la compression des chunks.

func WriteDataArrayZarrV3 

func WriteDataArrayZarrV3(dir string, da *DataArray[float64], chunks []int, comp ZarrCompression) error

WriteDataArrayZarrV3 écrit un DataArray au format Zarr v3 dans dir.

func WriteDatasetZarr 

func WriteDatasetZarr(dir string, ds *Dataset[float64], comp ZarrCompression) error

WriteDatasetZarr écrit un Dataset[float64] comme groupe Zarr v2 dans dir. Chaque array est stocké en un seul chunk (taille = forme). comp choisit la compression.

func WriteDatasetZarrChunked 

func WriteDatasetZarrChunked(dir string, ds *Dataset[float64], chunks map[string]int, comp ZarrCompression) error

WriteDatasetZarrChunked écrit un Dataset[float64] en Zarr v2 avec un découpage configurable : chunks associe un nom de dimension à une taille de chunk (façon ds.chunk({...}) de xarray). Les dimensions absentes ne sont pas découpées. Permet des accès partiels efficaces sur de grands tableaux.

func WriteDatasetZarrV3 

func WriteDatasetZarrV3(dir string, ds *Dataset[float64], comp ZarrCompression) error

WriteDatasetZarrV3 écrit un Dataset comme groupe Zarr v3 (un array par coordonnée et par variable, chacun en un seul chunk).

func WriteDatasetZarrV3Chunked 

func WriteDatasetZarrV3Chunked(dir string, ds *Dataset[float64], chunks map[string]int, comp ZarrCompression) error

WriteDatasetZarrV3Chunked écrit un Dataset en Zarr v3 avec un découpage configurable (chunks : dimension → taille de chunk, façon ds.chunk({...})).

func WritePyramidZarr 

func WritePyramidZarr(dir string, da *DataArray[float64], yDim, xDim string, nlevels, factor int, comp ZarrCompression) error

WritePyramidZarr écrit une pyramide multi-échelles d'un raster 2D (dimensions [yDim, xDim]). nlevels niveaux sont produits (≥1) ; chaque niveau suivant est une réduction par moyenne de blocs factor×factor (factor ≥ 2) sur y puis x. Les niveaux sont des groupes Zarr « 0 »…« nlevels-1 » sous dir.

func WriteRawF64 

func WriteRawF64(path string, data []float64) error

WriteRawF64 écrit des données float64 dans un fichier binaire (little-endian, ordre C), lisible par ChunkFile.

Types

type Affine 

type Affine struct {
	A, B, C, D, E, F float64
}

Affine est une transformation affine 2D (6 coefficients, convention affine/GDAL).

func FromGDAL 

func FromGDAL(gt [6]float64) Affine

FromGDAL construit une Affine à partir d'un GeoTransform GDAL [x0, dx, rx, y0, ry, dy] (ordre GDAL : origine, pas, rotations).

func ParseGDALGeoTransform 

func ParseGDALGeoTransform(s string) (Affine, error)

ParseGDALGeoTransform lit une chaîne GeoTransform GDAL « x0 dx rx y0 ry dy » (telle qu'écrite par GDAL/rioxarray dans l'attribut GeoTransform) en Affine.

func (Affine) Apply 

func (t Affine) Apply(col, row float64) (x, y float64)

Apply transforme des coordonnées pixel (col, row) en coordonnées monde (x, y).

func (Affine) GDAL 

func (t Affine) GDAL() [6]float64

GDAL renvoie le GeoTransform GDAL équivalent [x0, dx, rx, y0, ry, dy].

func (Affine) Inverse 

func (t Affine) Inverse() (Affine, error)

Inverse renvoie la transformation inverse (monde → pixel). Erreur si le déterminant est nul (transformation dégénérée).

type ChunkSource 

type ChunkSource interface {
	Dims() []string
	Shape() []int
	Coords() map[string][]float64
	NumChunks() int
	ChunkRows(i int) (start, end int) // plage de lignes (axe 0) du chunk i
	ChunkData(i int) ([]float64, error)
}

ChunkSource fournit les données d'un tableau, bloc par bloc, le long de l'axe 0.

type DataArray 

type DataArray[T Number] struct {
	// contains filtered or unexported fields
}

DataArray est un tableau N-dimensionnel étiqueté : une Variable enrichie de coordonnées associées à ses dimensions et d'un nom optionnel.

Les coordonnées permettent l'indexation par label (Sel) en plus de l'indexation par position (Isel).

func Concat 

func Concat[T Number](arrays []*DataArray[T], dim string) (*DataArray[T], error)

Concat concatène plusieurs DataArrays le long d'une dimension existante dim. Tous les tableaux doivent avoir les mêmes dimensions (noms et ordre) et les mêmes tailles sur toutes les dimensions autres que dim. La coordonnée de dim résultante est la concaténation des coordonnées correspondantes (si toutes présentes) ; les autres coordonnées proviennent du premier tableau.

func Dot 

func Dot[T Number](a, b *DataArray[T], dim string) (*DataArray[T], error)

Dot contracte deux DataArrays sur une dimension commune dim (produit tensoriel), à la manière de `xr.dot(a, b, dims=dim)`. Le résultat porte les dimensions restantes de a puis celles de b ; on somme sur dim : 

c[i, j] = Σ_k a[i, k] · b[k, j]

Pour ce MVP, dim doit être la seule dimension commune à a et b.

func InterpBilinear 

func InterpBilinear(da *DataArray[float64], xDim, yDim string, x, y float64) (*DataArray[float64], error)

InterpBilinear renvoie le DataArray réduit sur xDim/yDim par interpolation bilinéaire à la position (x, y). Erreur si le point est hors de la grille.

func NewDataArray 

func NewDataArray[T Number](dims []string, shape []int, data []T, coords map[string][]T, name string) (*DataArray[T], error)

NewDataArray construit un DataArray.

  • dims/shape/data définissent la Variable sous-jacente (cf. NewVariable) ;
  • coords associe optionnellement à certaines dimensions un vecteur d'étiquettes de même longueur que la dimension ;
  • name est le nom (optionnel) du tableau.

func ReadDataArrayCSV 

func ReadDataArrayCSV[T Number](r io.Reader) (*DataArray[T], error)

ReadDataArrayCSV lit un DataArray depuis un flux CSV au format tidy. La dernière colonne est la valeur ; les précédentes sont les dimensions.

func ReadDataArrayJSON 

func ReadDataArrayJSON[T Number](r io.Reader) (*DataArray[T], error)

ReadDataArrayJSON lit un DataArray depuis un flux JSON.

func ReadDataArrayNetCDF 

func ReadDataArrayNetCDF[T Number](r io.Reader) (*DataArray[T], error)

ReadDataArrayNetCDF lit un DataArray depuis un dataset netCDF ne contenant qu'une seule variable de données.

func ReadDataArrayZarr 

func ReadDataArrayZarr(dir string) (*DataArray[float64], error)

ReadDataArrayZarr lit un DataArray[float64] depuis un store Zarr v2 (dir).

func ReprojectDataArray 

func ReprojectDataArray(da *DataArray[float64], srcT Affine, srcCRS string,
	dstT Affine, dstW, dstH int, dstCRS string, yDim, xDim string, method Resampling) (*DataArray[float64], error)

ReprojectDataArray reprojette un DataArray 2D géoréférencé (dimensions [yDim, xDim], géotransformation srcT, CRS srcCRS) vers une grille cible définie par dstT, dstW×dstH et dstCRS. Le résultat porte les coordonnées monde de la grille cible et le CRS cible (attribut "crs").

func Stack 

func Stack[T Number](arrays []*DataArray[T], newDim string, labels []T) (*DataArray[T], error)

Stack empile plusieurs DataArrays de forme identique le long d'une NOUVELLE dimension newDim placée en tête, dont la coordonnée est labels (une étiquette par tableau).

func SwathToDataArray 

func SwathToDataArray(data, lon, lat []float64, dstT Affine, dstW, dstH int, name, yDim, xDim string) (*DataArray[float64], error)

SwathToDataArray rééchantillonne une fauchée en un DataArray[float64] géoréférencé sur la grille cible (dimensions [yDim, xDim]), directement subsettable (SubsetBBox, Query…). name est le nom de la variable produite.

func (*DataArray[T]) Abs 

func (da *DataArray[T]) Abs() *DataArray[T]

Abs renvoie la valeur absolue élément par élément.

func (*DataArray[T]) Add 

func (da *DataArray[T]) Add(other *DataArray[T]) (*DataArray[T], error)

Add renvoie da + other (avec alignement et broadcasting).

Optimisation : pour le cas fréquent « float64, mêmes dimensions après alignement », on utilise un noyau direct (addFloat64) sans closure. Le chemin générique passe par une closure func(T,T) T non inlinée (un appel par élément) ; l'éviter accélère l'opération d'un ordre de grandeur sur les grands tableaux (voir docs/BENCHMARKS.md).

func (*DataArray[T]) AddJoin 

func (da *DataArray[T]) AddJoin(other *DataArray[T], join JoinType, fill T) (*DataArray[T], error)

AddJoin renvoie da + other avec la stratégie de jointure et le remplissage donnés.

func (*DataArray[T]) AddScalar 

func (da *DataArray[T]) AddScalar(s T) *DataArray[T]

AddScalar ajoute s à chaque élément.

func (*DataArray[T]) Apply 

func (da *DataArray[T]) Apply(fn func(T) T) *DataArray[T]

Apply applique une fonction arbitraire à chaque élément.

func (*DataArray[T]) ArgMaxAxis 

func (da *DataArray[T]) ArgMaxAxis(dim string) (*DataArray[float64], error)

ArgMaxAxis renvoie, le long de dim, l'indice (float64) du maximum.

func (*DataArray[T]) ArgMinAxis 

func (da *DataArray[T]) ArgMinAxis(dim string) (*DataArray[float64], error)

ArgMinAxis renvoie, le long de dim, l'indice (float64) du minimum.

func (*DataArray[T]) BFill 

func (da *DataArray[T]) BFill(dim string) (*DataArray[T], error)

BFill propage la prochaine valeur non-NaN vers l'arrière, le long de dim (backward fill). Les NaN en fin restent NaN.

func (*DataArray[T]) Ceil 

func (da *DataArray[T]) Ceil() *DataArray[T]

Ceil renvoie le plafond de chaque élément.

func (*DataArray[T]) Clip 

func (da *DataArray[T]) Clip(lo, hi T) *DataArray[T]

Clip borne chaque élément à l'intervalle [lo, hi].

func (*DataArray[T]) Coarsen 

func (da *DataArray[T]) Coarsen(dim string, factor int) (*Resample[T], error)

Coarsen construit un downsampling par blocs de taille factor le long de dim.

func (*DataArray[T]) Coord 

func (da *DataArray[T]) Coord(dim string) ([]T, error)

Coord renvoie les étiquettes de la coordonnée associée à dim.

func (*DataArray[T]) Cos 

func (da *DataArray[T]) Cos() *DataArray[T]

Cos renvoie le cosinus élément par élément.

func (*DataArray[T]) Count 

func (da *DataArray[T]) Count() int

Count renvoie le nombre de valeurs présentes (non-NaN).

func (*DataArray[T]) CountAxis 

func (da *DataArray[T]) CountAxis(dim string) (*DataArray[float64], error)

CountAxis renvoie, le long de dim, le nombre de valeurs présentes (non-NaN).

func (*DataArray[T]) CountNA 

func (da *DataArray[T]) CountNA() int

CountNA renvoie le nombre de valeurs NaN.

func (*DataArray[T]) Cumprod 

func (da *DataArray[T]) Cumprod(dim string) (*DataArray[T], error)

Cumprod renvoie le produit cumulé le long de dim (même forme).

func (*DataArray[T]) Cumsum 

func (da *DataArray[T]) Cumsum(dim string) (*DataArray[T], error)

Cumsum renvoie la somme cumulée le long de dim (même forme).

func (*DataArray[T]) Data 

func (da *DataArray[T]) Data() []T

Data renvoie une copie des données plates (ordre C).

func (*DataArray[T]) Diff 

func (da *DataArray[T]) Diff(dim string) (*DataArray[T], error)

Diff renvoie les différences successives le long de dim : out[k] = in[k+1] - in[k]. La dimension est réduite de 1 (la coordonnée conserve les positions 1..n-1, comme xarray).

func (*DataArray[T]) Dims 

func (da *DataArray[T]) Dims() []string

Dims renvoie les noms de dimensions.

func (*DataArray[T]) Div 

func (da *DataArray[T]) Div(other *DataArray[T]) (*DataArray[T], error)

Div renvoie da / other.

func (*DataArray[T]) DivJoin 

func (da *DataArray[T]) DivJoin(other *DataArray[T], join JoinType, fill T) (*DataArray[T], error)

DivJoin renvoie da / other avec jointure et remplissage.

func (*DataArray[T]) DropNA 

func (da *DataArray[T]) DropNA(dim string) (*DataArray[T], error)

DropNA supprime, le long de dim, les positions dont la tranche contient au moins un NaN (how = "any", comme le défaut de xarray).

func (*DataArray[T]) Exp 

func (da *DataArray[T]) Exp() *DataArray[T]

Exp renvoie l'exponentielle élément par élément.

func (*DataArray[T]) ExpandDims 

func (da *DataArray[T]) ExpandDims(dim string) (*DataArray[T], error)

ExpandDims insère une nouvelle dimension de taille 1 en tête (sans coordonnée). Les données ne changent pas.

func (*DataArray[T]) FFill 

func (da *DataArray[T]) FFill(dim string) (*DataArray[T], error)

FFill propage la dernière valeur non-NaN vers l'avant, le long de dim (forward fill). Les NaN en tête (avant toute valeur valide) restent NaN.

func (*DataArray[T]) FillNA 

func (da *DataArray[T]) FillNA(value T) *DataArray[T]

FillNA renvoie une copie où chaque NaN est remplacé par value.

func (*DataArray[T]) Floor 

func (da *DataArray[T]) Floor() *DataArray[T]

Floor renvoie le plancher de chaque élément.

func (*DataArray[T]) Georeference 

func (da *DataArray[T]) Georeference(gr GeoRef, xDim, yDim string) (*DataArray[T], error)

Georeference renvoie une copie du DataArray 2D avec des coordonnées monde (centres de pixels) attachées à xDim et yDim, et le CRS stocké dans l'attribut "crs" de la variable. da doit avoir exactement les dimensions [yDim, xDim].

func (*DataArray[T]) GroupBy 

func (da *DataArray[T]) GroupBy(dim string) (*GroupBy[T], error)

GroupBy construit un regroupement le long de dim, en s'appuyant sur la coordonnée de dim. La dimension résultante conserve le nom dim mais ne porte plus que les étiquettes uniques.

func (*DataArray[T]) GroupByBins 

func (da *DataArray[T]) GroupByBins(dim string, edges []T) (*Resample[T], error)

GroupByBins construit un regroupement par intervalles arbitraires sur dim.

func (*DataArray[T]) HasDim 

func (da *DataArray[T]) HasDim(dim string) bool

HasDim indique si le tableau possède la dimension dim.

func (*DataArray[T]) IdxMaxAxis 

func (da *DataArray[T]) IdxMaxAxis(dim string) (*DataArray[T], error)

IdxMaxAxis renvoie, le long de dim, l'étiquette de coordonnée correspondant au maximum (équivalent de `idxmax` de xarray).

func (*DataArray[T]) IdxMinAxis 

func (da *DataArray[T]) IdxMinAxis(dim string) (*DataArray[T], error)

IdxMinAxis renvoie, le long de dim, l'étiquette de coordonnée correspondant au minimum (équivalent de `idxmin` de xarray). La dimension doit avoir une coordonnée.

func (*DataArray[T]) InterpolateNA 

func (da *DataArray[T]) InterpolateNA(dim string) (*DataArray[T], error)

InterpolateNA remplit les valeurs manquantes (NaN) le long de dim par interpolation linéaire entre les valeurs valides encadrantes. L'interpolation se fait selon la coordonnée de dim si elle existe, sinon selon la position. Les NaN de bord (avant la première ou après la dernière valeur valide) sont conservés.

func (*DataArray[T]) IsNull 

func (da *DataArray[T]) IsNull() *DataArray[T]

IsNull renvoie un masque : 1 là où la valeur est NaN, 0 sinon.

func (*DataArray[T]) Isel 

func (da *DataArray[T]) Isel(dim string, index int) (*DataArray[T], error)

Isel sélectionne par position entière le long d'une dimension. La dimension est supprimée du résultat, ainsi que sa coordonnée éventuelle.

func (*DataArray[T]) Log 

func (da *DataArray[T]) Log() *DataArray[T]

Log renvoie le logarithme naturel élément par élément.

func (*DataArray[T]) MarshalJSON 

func (da *DataArray[T]) MarshalJSON() ([]byte, error)

MarshalJSON sérialise le DataArray.

func (*DataArray[T]) Max 

func (da *DataArray[T]) Max() T

Max renvoie le maximum de tous les éléments. Zéro-valeur de T si vide.

func (*DataArray[T]) MaxAxis 

func (da *DataArray[T]) MaxAxis(dim string) (*DataArray[T], error)

MaxAxis réduit la dimension dim par maximum.

func (*DataArray[T]) MaxAxisSkipNA 

func (da *DataArray[T]) MaxAxisSkipNA(dim string) (*DataArray[T], error)

MaxAxisSkipNA réduit dim par maximum en ignorant les NaN.

func (*DataArray[T]) MaxSkipNA 

func (da *DataArray[T]) MaxSkipNA() T

MaxSkipNA renvoie le maximum des éléments non-NaN.

func (*DataArray[T]) Maximum 

func (da *DataArray[T]) Maximum(other *DataArray[T]) (*DataArray[T], error)

Maximum renvoie le maximum élément par élément entre da et other (avec alignement et broadcasting).

func (*DataArray[T]) Mean 

func (da *DataArray[T]) Mean() float64

Mean renvoie la moyenne de tous les éléments (en float64). NaN si vide.

func (*DataArray[T]) MeanAxis 

func (da *DataArray[T]) MeanAxis(dim string) (*DataArray[float64], error)

MeanAxis réduit la dimension dim par moyenne (résultat en float64).

func (*DataArray[T]) MeanAxisSkipNA 

func (da *DataArray[T]) MeanAxisSkipNA(dim string) (*DataArray[float64], error)

MeanAxisSkipNA réduit dim par moyenne (float64) en ignorant les NaN.

func (*DataArray[T]) MeanSkipNA 

func (da *DataArray[T]) MeanSkipNA() float64

MeanSkipNA renvoie la moyenne des éléments non-NaN (NaN si aucun).

func (*DataArray[T]) Median 

func (da *DataArray[T]) Median() float64

Median renvoie la médiane de tous les éléments.

func (*DataArray[T]) MedianAxis 

func (da *DataArray[T]) MedianAxis(dim string) (*DataArray[float64], error)

MedianAxis réduit dim par médiane (float64).

func (*DataArray[T]) Min 

func (da *DataArray[T]) Min() T

Min renvoie le minimum de tous les éléments. Zéro-valeur de T si vide.

func (*DataArray[T]) MinAxis 

func (da *DataArray[T]) MinAxis(dim string) (*DataArray[T], error)

MinAxis réduit la dimension dim par minimum.

func (*DataArray[T]) MinAxisSkipNA 

func (da *DataArray[T]) MinAxisSkipNA(dim string) (*DataArray[T], error)

MinAxisSkipNA réduit dim par minimum en ignorant les NaN.

func (*DataArray[T]) MinSkipNA 

func (da *DataArray[T]) MinSkipNA() T

MinSkipNA renvoie le minimum des éléments non-NaN.

func (*DataArray[T]) Minimum 

func (da *DataArray[T]) Minimum(other *DataArray[T]) (*DataArray[T], error)

Minimum renvoie le minimum élément par élément entre da et other.

func (*DataArray[T]) Mul 

func (da *DataArray[T]) Mul(other *DataArray[T]) (*DataArray[T], error)

Mul renvoie da * other.

func (*DataArray[T]) MulJoin 

func (da *DataArray[T]) MulJoin(other *DataArray[T], join JoinType, fill T) (*DataArray[T], error)

MulJoin renvoie da * other avec jointure et remplissage.

func (*DataArray[T]) MulScalar 

func (da *DataArray[T]) MulScalar(s T) *DataArray[T]

MulScalar multiplie chaque élément par s.

func (*DataArray[T]) Name 

func (da *DataArray[T]) Name() string

Name renvoie le nom du tableau.

func (*DataArray[T]) Ndim 

func (da *DataArray[T]) Ndim() int

Ndim renvoie le nombre de dimensions.

func (*DataArray[T]) NotNull 

func (da *DataArray[T]) NotNull() *DataArray[T]

NotNull renvoie un masque : 1 là où la valeur est présente, 0 si NaN.

func (*DataArray[T]) Pow 

func (da *DataArray[T]) Pow(p float64) *DataArray[T]

Pow élève chaque élément à la puissance p.

func (*DataArray[T]) Quantile 

func (da *DataArray[T]) Quantile(q float64) float64

Quantile renvoie le quantile q ∈ [0,1] de tous les éléments.

func (*DataArray[T]) QuantileAxis 

func (da *DataArray[T]) QuantileAxis(dim string, q float64) (*DataArray[float64], error)

QuantileAxis réduit dim par quantile q (float64).

func (*DataArray[T]) Rename 

func (da *DataArray[T]) Rename(name string) *DataArray[T]

Rename renvoie une copie du tableau portant le nom fourni.

func (*DataArray[T]) RenameDim 

func (da *DataArray[T]) RenameDim(old, newName string) (*DataArray[T], error)

RenameDim renomme une dimension (et sa coordonnée éventuelle).

func (*DataArray[T]) Resample 

func (da *DataArray[T]) Resample(dim string, freq T) (*Resample[T], error)

Resample construit un rééchantillonnage de pas freq le long de dim.

func (*DataArray[T]) Rolling 

func (da *DataArray[T]) Rolling(dim string, window int) (*Rolling[T], error)

Rolling construit une fenêtre glissante de taille window le long de dim.

func (*DataArray[T]) Round 

func (da *DataArray[T]) Round() *DataArray[T]

Round arrondit chaque élément à l'entier le plus proche.

func (*DataArray[T]) Sel 

func (da *DataArray[T]) Sel(dim string, label T) (*DataArray[T], error)

Sel sélectionne par label le long d'une dimension : l'étiquette est recherchée dans la coordonnée de la dimension, puis Isel est appliqué à sa position.

func (*DataArray[T]) SelMany 

func (da *DataArray[T]) SelMany(dim string, labels []T) (*DataArray[T], error)

SelMany conserve, le long de dim, les positions correspondant exactement aux étiquettes fournies (dans l'ordre donné). La dimension est conservée.

func (*DataArray[T]) SelNearest 

func (da *DataArray[T]) SelNearest(dim string, label T) (*DataArray[T], error)

SelNearest sélectionne, le long de dim, la position dont l'étiquette est la plus proche de label (la dimension est réduite, comme Sel/Isel).

func (*DataArray[T]) SelNearestKeep 

func (da *DataArray[T]) SelNearestKeep(dim string, label T) (*DataArray[T], error)

SelNearestKeep sélectionne la position la plus proche de label le long de dim en CONSERVANT la dimension (taille 1). Équivalent de xarray sel(dim=[label], method="nearest"). Utile pour les exports (CoverageJSON, EDR) qui exigent des axes explicites.

func (*DataArray[T]) SelNearestMany 

func (da *DataArray[T]) SelNearestMany(dim string, labels []T) (*DataArray[T], error)

SelNearestMany sélectionne, le long de dim, la position la plus proche pour chacune des étiquettes fournies (dans l'ordre), en CONSERVANT la dimension. Équivalent de xarray sel(dim=[l1, l2, ...], method="nearest"), là où SelNearest (label scalaire) réduit la dimension comme sel(dim=l).

func (*DataArray[T]) SelRange 

func (da *DataArray[T]) SelRange(dim string, lo, hi T) (*DataArray[T], error)

SelRange conserve, le long de dim, les positions dont l'étiquette est dans l'intervalle [lo, hi] (bornes incluses). La dimension est conservée.

func (*DataArray[T]) SelStr 

func (da *DataArray[T]) SelStr(dim string, label string) (*DataArray[T], error)

SelStr sélectionne par étiquette textuelle le long de dim (la dimension est réduite, comme Sel).

func (*DataArray[T]) SelStrMany 

func (da *DataArray[T]) SelStrMany(dim string, labels []string) (*DataArray[T], error)

SelStrMany conserve les positions correspondant aux étiquettes textuelles fournies (dimension conservée, ordre respecté).

func (*DataArray[T]) Shape 

func (da *DataArray[T]) Shape() []int

Shape renvoie la forme du tableau.

func (*DataArray[T]) Sign 

func (da *DataArray[T]) Sign() *DataArray[T]

Sign renvoie -1, 0 ou 1 selon le signe de chaque élément.

func (*DataArray[T]) Sin 

func (da *DataArray[T]) Sin() *DataArray[T]

Sin renvoie le sinus élément par élément.

func (*DataArray[T]) Size 

func (da *DataArray[T]) Size() int

Size renvoie le nombre total d'éléments.

func (*DataArray[T]) Sqrt 

func (da *DataArray[T]) Sqrt() *DataArray[T]

Sqrt renvoie la racine carrée élément par élément.

func (*DataArray[T]) Squeeze 

func (da *DataArray[T]) Squeeze(dim string) (*DataArray[T], error)

Squeeze supprime la dimension dim si elle est de taille 1 (ainsi que sa coordonnée). Les données ne changent pas.

func (*DataArray[T]) Std 

func (da *DataArray[T]) Std() float64

Std renvoie l'écart-type (population) de tous les éléments.

func (*DataArray[T]) StdAxis 

func (da *DataArray[T]) StdAxis(dim string) (*DataArray[float64], error)

StdAxis réduit dim par écart-type (float64).

func (*DataArray[T]) StrCoord 

func (da *DataArray[T]) StrCoord(dim string) ([]string, error)

StrCoord renvoie les étiquettes textuelles de la dimension dim.

func (*DataArray[T]) String 

func (da *DataArray[T]) String() string

String fournit une représentation lisible du DataArray.

func (*DataArray[T]) Sub 

func (da *DataArray[T]) Sub(other *DataArray[T]) (*DataArray[T], error)

Sub renvoie da - other.

func (*DataArray[T]) SubJoin 

func (da *DataArray[T]) SubJoin(other *DataArray[T], join JoinType, fill T) (*DataArray[T], error)

SubJoin renvoie da - other avec jointure et remplissage.

func (*DataArray[T]) Sum 

func (da *DataArray[T]) Sum() T

Sum renvoie la somme de tous les éléments.

func (*DataArray[T]) SumAxis 

func (da *DataArray[T]) SumAxis(dim string) (*DataArray[T], error)

SumAxis réduit la dimension dim par somme.

func (*DataArray[T]) SumAxisSkipNA 

func (da *DataArray[T]) SumAxisSkipNA(dim string) (*DataArray[T], error)

SumAxisSkipNA réduit dim par somme en ignorant les NaN.

func (*DataArray[T]) SumSkipNA 

func (da *DataArray[T]) SumSkipNA() T

SumSkipNA renvoie la somme des éléments non-NaN.

func (*DataArray[T]) Tanh 

func (da *DataArray[T]) Tanh() *DataArray[T]

Tanh renvoie la tangente hyperbolique élément par élément.

func (*DataArray[T]) Transpose 

func (da *DataArray[T]) Transpose(newDims ...string) (*DataArray[T], error)

Transpose réordonne les dimensions du DataArray selon newDims (permutation).

func (*DataArray[T]) UnmarshalJSON 

func (da *DataArray[T]) UnmarshalJSON(b []byte) error

UnmarshalJSON désérialise un DataArray (avec validation via NewDataArray).

func (*DataArray[T]) Var 

func (da *DataArray[T]) Var() float64

Var renvoie la variance (population, ddof=0) de tous les éléments.

func (*DataArray[T]) VarAxis 

func (da *DataArray[T]) VarAxis(dim string) (*DataArray[float64], error)

VarAxis réduit dim par variance (float64).

func (*DataArray[T]) Variable 

func (da *DataArray[T]) Variable() *Variable[T]

Variable renvoie la Variable sous-jacente.

func (*DataArray[T]) Where 

func (da *DataArray[T]) Where(mask *DataArray[T], other T) (*DataArray[T], error)

Where renvoie une copie où les éléments dont le masque vaut 0 sont remplacés par other (le masque est un DataArray de même forme, non-zéro = conserver).

func (*DataArray[T]) WhereFunc 

func (da *DataArray[T]) WhereFunc(keep func(T) bool, other T) *DataArray[T]

WhereFunc renvoie une copie où chaque élément ne satisfaisant pas keep est remplacé par other. C'est le masquage conditionnel de base (équivalent de `da.where(cond, other)` de xarray, la condition étant un prédicat élément par élément).

func (*DataArray[T]) WithStrCoord 

func (da *DataArray[T]) WithStrCoord(dim string, labels []string) (*DataArray[T], error)

WithStrCoord renvoie une copie du tableau avec une coordonnée textuelle sur la dimension dim (labels de longueur égale à la taille de dim).

func (*DataArray[T]) WriteCSV 

func (da *DataArray[T]) WriteCSV(w io.Writer) error

WriteCSV écrit le DataArray au format tidy : une colonne par dimension puis la valeur ; l'en-tête donne les noms des dimensions et de la variable.

func (*DataArray[T]) WriteJSON 

func (da *DataArray[T]) WriteJSON(w io.Writer) error

WriteJSON écrit le DataArray au format JSON.

func (*DataArray[T]) WriteNetCDF 

func (da *DataArray[T]) WriteNetCDF(w io.Writer) error

WriteNetCDF écrit un DataArray comme un dataset netCDF à une seule variable.

type Dataset 

type Dataset[T Number] struct {
	// contains filtered or unexported fields
}

Dataset est une collection de DataArrays (les « variables de données ») partageant un système commun de dimensions et de coordonnées.

func DecodeCF 

func DecodeCF(ds *Dataset[float64]) (*Dataset[float64], error)

DecodeCF applique le décodage du packing CF à toutes les variables d'un Dataset[float64] : valeur = brut × scale_factor + add_offset, et les valeurs égales à _FillValue / missing_value deviennent NaN. Les attributs consommés sont retirés (la variable est désormais « décodée »).

func DecodeTime 

func DecodeTime(ds *Dataset[float64], dim string) (*Dataset[float64], error)

DecodeTime décode la coordonnée temporelle dim d'un Dataset selon son attribut « units » CF (« <unité> since <date> ») et la remplace par des secondes depuis l'epoch Unix. Sans attribut units exploitable, le Dataset est renvoyé inchangé.

func NewDataset 

func NewDataset[T Number](vars map[string]*DataArray[T]) (*Dataset[T], error)

NewDataset construit un Dataset à partir d'un ensemble de variables nommées, en vérifiant la cohérence des dimensions et des coordonnées.

func OpenNetCDFFile 

func OpenNetCDFFile(path string, conv NetCDFConverter) (*Dataset[float64], error)

OpenNetCDFFile ouvre un fichier netCDF quel que soit son format.

  • CDF-1 : lu directement.
  • HDF5/CDF-2/CDF-5 : converti en CDF-1 via conv (fichier temporaire) puis lu.

Si conv est nil, un convertisseur est recherché dans le PATH. Le décodage CF (packing, temps) n'est PAS appliqué ici : appelez DecodeCF/DecodeTime ensuite, comme pour ReadDatasetNetCDF.

func ReadDatasetJSON 

func ReadDatasetJSON[T Number](r io.Reader) (*Dataset[T], error)

ReadDatasetJSON lit un Dataset depuis un flux JSON. Les coordonnées partagées sont réinjectées dans chaque variable selon ses dimensions.

func ReadDatasetNetCDF 

func ReadDatasetNetCDF[T Number](rd io.Reader) (*Dataset[T], error)

ReadDatasetNetCDF lit un Dataset depuis un flux netCDF classique (sous-ensemble). Les valeurs stockées sont converties vers le type T demandé.

func ReadDatasetZarr 

func ReadDatasetZarr(dir string) (*Dataset[float64], error)

ReadDatasetZarr lit un Dataset[float64] depuis un groupe Zarr v2 (dir). Les arrays 1D nommés comme une dimension sont interprétés comme des coordonnées ; les autres comme des variables de données.

func ReadPyramidLevel 

func ReadPyramidLevel(dir string, level int) (*Dataset[float64], error)

ReadPyramidLevel lit un niveau donné d'une pyramide écrite par WritePyramidZarr (niveau 0 = pleine résolution). Renvoie le Dataset de ce niveau.

func (*Dataset[T]) Add 

func (ds *Dataset[T]) Add(other *Dataset[T]) (*Dataset[T], error)

Add renvoie ds + other (variable par variable).

func (*Dataset[T]) AddScalar 

func (ds *Dataset[T]) AddScalar(s T) (*Dataset[T], error)

AddScalar ajoute s à toutes les variables.

func (*Dataset[T]) Coarsen 

func (ds *Dataset[T]) Coarsen(dim string, factor int) (*DatasetGroupBy[T], error)

Coarsen construit un downsampling par blocs sur un Dataset (propagé aux variables portant la dimension).

func (*Dataset[T]) Coord 

func (ds *Dataset[T]) Coord(dim string) ([]T, error)

Coord renvoie les étiquettes de la coordonnée partagée dim.

func (*Dataset[T]) Cumsum 

func (ds *Dataset[T]) Cumsum(dim string) (*Dataset[T], error)

Cumsum applique la somme cumulée le long de dim à chaque variable la portant (les autres sont conservées).

func (*Dataset[T]) Dims 

func (ds *Dataset[T]) Dims() map[string]int

Dims renvoie la taille de chaque dimension du dataset.

func (*Dataset[T]) Div 

func (ds *Dataset[T]) Div(other *Dataset[T]) (*Dataset[T], error)

Div renvoie ds / other.

func (*Dataset[T]) DropVars 

func (ds *Dataset[T]) DropVars(names ...string) (*Dataset[T], error)

DropVars renvoie une copie du dataset privée des variables indiquées.

func (*Dataset[T]) FillNA 

func (ds *Dataset[T]) FillNA(value T) (*Dataset[T], error)

FillNA renvoie une copie du dataset où les NaN de chaque variable sont remplacés par value.

func (*Dataset[T]) GeoRefFromCF 

func (ds *Dataset[T]) GeoRefFromCF(name string) (GeoRef, bool)

GeoRefFromCF extrait le géoréférencement d'une variable de données à partir des métadonnées CF (convention rioxarray/GDAL) : l'attribut `grid_mapping` de la variable nomme une variable de CRS portant `crs_wkt`/`spatial_ref` (identifiant du CRS) et `GeoTransform` (géotransformation GDAL). Renvoie le GeoRef et true si une géotransformation exploitable a été trouvée.

func (*Dataset[T]) Get 

func (ds *Dataset[T]) Get(name string) (*DataArray[T], error)

Get renvoie la variable de données nommée name.

func (*Dataset[T]) GroupBy 

func (ds *Dataset[T]) GroupBy(dim string) (*DatasetGroupBy[T], error)

GroupBy construit un regroupement du Dataset le long de dim, via la coordonnée partagée de dim.

func (*Dataset[T]) GroupByBins 

func (ds *Dataset[T]) GroupByBins(dim string, edges []T) (*DatasetGroupBy[T], error)

GroupByBins construit un regroupement par intervalles arbitraires sur un Dataset (propagé aux variables portant la dimension).

func (*Dataset[T]) GroupByTime 

func (ds *Dataset[T]) GroupByTime(dim string, c TimeComponent) (*DatasetGroupBy[T], error)

GroupByTime regroupe par composante temporelle (mois, saison, …) — climatologie.

func (*Dataset[T]) Isel 

func (ds *Dataset[T]) Isel(dim string, index int) (*Dataset[T], error)

Isel sélectionne par position le long de dim et propage l'opération à toutes les variables portant cette dimension (les autres restent inchangées).

func (*Dataset[T]) MaxAxis 

func (ds *Dataset[T]) MaxAxis(dim string) (*Dataset[T], error)

MaxAxis réduit la dimension dim par maximum.

func (*Dataset[T]) MeanAxis 

func (ds *Dataset[T]) MeanAxis(dim string) (*Dataset[float64], error)

MeanAxis réduit la dimension dim par moyenne (résultat en float64).

func (*Dataset[T]) MedianAxis 

func (ds *Dataset[T]) MedianAxis(dim string) (*Dataset[float64], error)

MedianAxis réduit dim par médiane (float64).

func (*Dataset[T]) Merge 

func (ds *Dataset[T]) Merge(other *Dataset[T]) (*Dataset[T], error)

Merge fusionne deux datasets. En cas de variable homonyme, celle de other l'emporte.

func (*Dataset[T]) MinAxis 

func (ds *Dataset[T]) MinAxis(dim string) (*Dataset[T], error)

MinAxis réduit la dimension dim par minimum.

func (*Dataset[T]) Mul 

func (ds *Dataset[T]) Mul(other *Dataset[T]) (*Dataset[T], error)

Mul renvoie ds * other.

func (*Dataset[T]) MulScalar 

func (ds *Dataset[T]) MulScalar(s T) (*Dataset[T], error)

MulScalar multiplie toutes les variables par s.

func (*Dataset[T]) Resample 

func (ds *Dataset[T]) Resample(dim string, freq T) (*DatasetGroupBy[T], error)

Resample regroupe par intervalles réguliers (largeur freq) d'une coordonnée numérique. Renvoie un DatasetGroupBy (agrégations Sum/Mean/Min/Max).

func (*Dataset[T]) ResampleCalendar 

func (ds *Dataset[T]) ResampleCalendar(dim string, p Period) (*DatasetGroupBy[T], error)

ResampleCalendar regroupe par période calendaire (coordonnée en secondes epoch).

func (*Dataset[T]) Rolling 

func (ds *Dataset[T]) Rolling(dim string, window int) (*DatasetRolling[T], error)

Rolling construit une fenêtre glissante de taille window le long de dim sur le Dataset.

func (*Dataset[T]) Sel 

func (ds *Dataset[T]) Sel(dim string, label T) (*Dataset[T], error)

Sel sélectionne par label le long de dim (via la coordonnée partagée).

func (*Dataset[T]) StdAxis 

func (ds *Dataset[T]) StdAxis(dim string) (*Dataset[float64], error)

StdAxis réduit dim par écart-type (float64).

func (*Dataset[T]) String 

func (ds *Dataset[T]) String() string

String fournit une représentation lisible du dataset.

func (*Dataset[T]) Sub 

func (ds *Dataset[T]) Sub(other *Dataset[T]) (*Dataset[T], error)

Sub renvoie ds - other.

func (*Dataset[T]) SumAxis 

func (ds *Dataset[T]) SumAxis(dim string) (*Dataset[T], error)

SumAxis réduit la dimension dim par somme sur toutes les variables concernées.

func (*Dataset[T]) VarAxis 

func (ds *Dataset[T]) VarAxis(dim string) (*Dataset[float64], error)

VarAxis réduit dim par variance (float64) sur toutes les variables concernées.

func (*Dataset[T]) VarNames 

func (ds *Dataset[T]) VarNames() []string

VarNames renvoie les noms des variables de données, triés.

func (*Dataset[T]) WithVar 

func (ds *Dataset[T]) WithVar(name string, da *DataArray[T]) (*Dataset[T], error)

WithVar renvoie une copie du dataset augmentée (ou remplacée) de la variable name.

func (*Dataset[T]) WriteJSON 

func (ds *Dataset[T]) WriteJSON(w io.Writer) error

WriteJSON écrit le Dataset au format JSON.

func (*Dataset[T]) WriteNetCDF 

func (ds *Dataset[T]) WriteNetCDF(w io.Writer) error

WriteNetCDF écrit le Dataset au format netCDF classique (sous-ensemble).

type DatasetGroupBy 

type DatasetGroupBy[T Number] struct {
	// contains filtered or unexported fields
}

DatasetGroupBy représente un regroupement d'un Dataset le long d'une dimension, par les valeurs (répétées) de la coordonnée partagée de cette dimension. L'agrégation est propagée à toutes les variables portant la dimension ; les autres sont conservées (converties au type de sortie si nécessaire).

func (*DatasetGroupBy[T]) Groups 

func (g *DatasetGroupBy[T]) Groups() int

Groups renvoie le nombre de groupes.

func (*DatasetGroupBy[T]) Max 

func (g *DatasetGroupBy[T]) Max() (*Dataset[T], error)

Max agrège chaque groupe par maximum.

func (*DatasetGroupBy[T]) Mean 

func (g *DatasetGroupBy[T]) Mean() (*Dataset[float64], error)

Mean agrège chaque groupe par moyenne (résultat en float64).

func (*DatasetGroupBy[T]) Min 

func (g *DatasetGroupBy[T]) Min() (*Dataset[T], error)

Min agrège chaque groupe par minimum.

func (*DatasetGroupBy[T]) Sum 

func (g *DatasetGroupBy[T]) Sum() (*Dataset[T], error)

Sum agrège chaque groupe par somme.

type DatasetRolling 

type DatasetRolling[T Number] struct {
	// contains filtered or unexported fields
}

DatasetRolling propage une fenêtre glissante à toutes les variables d'un Dataset portant la dimension visée.

func (*DatasetRolling[T]) Max 

func (r *DatasetRolling[T]) Max() (*Dataset[float64], error)

Max : maximum mobile.

func (*DatasetRolling[T]) Mean 

func (r *DatasetRolling[T]) Mean() (*Dataset[float64], error)

Mean : moyenne mobile sur le Dataset.

func (*DatasetRolling[T]) Min 

func (r *DatasetRolling[T]) Min() (*Dataset[float64], error)

Min : minimum mobile.

func (*DatasetRolling[T]) Sum 

func (r *DatasetRolling[T]) Sum() (*Dataset[float64], error)

Sum : somme mobile.

type GeoRef 

type GeoRef struct {
	Transform Affine
	CRS       string // ex. "EPSG:4326", WKT, proj4…
}

GeoRef associe une géotransformation et un CRS (identifiant opaque).

type Geostationary 

type Geostationary struct {
	Lon0, Height, A, B float64
}

Geostationary décrit une projection géostationnaire.

  • Lon0 : longitude sub-satellite (degrés)
  • Height : hauteur de perspective au-dessus de l'ellipsoïde (m)
  • A, B : demi-grand et demi-petit axes de l'ellipsoïde (m)

func MTGGeos 

func MTGGeos() Geostationary

MTGGeos renvoie la projection géostationnaire de MTG-I (sub-satellite 0°, ellipsoïde WGS84, hauteur de perspective 35 785 831 m).

func (Geostationary) Forward 

func (g Geostationary) Forward(lon, lat float64) (x, y float64, ok bool)

Forward projette (lon, lat) en degrés vers (x, y) en mètres dans le plan géostationnaire. ok=false si le point n'est pas visible depuis le satellite (au-delà du limbe terrestre).

func (Geostationary) Inverse 

func (g Geostationary) Inverse(x, y float64) (lon, lat float64, ok bool)

Inverse projette (x, y) en mètres (plan géostationnaire) vers (lon, lat) en degrés. ok=false si (x, y) ne correspond à aucun point de la Terre.

type GribMessage 

type GribMessage struct {
	Ni, Nj         int
	La1, Lo1       float64 // premier point (degrés)
	Di, Dj         float64 // incréments (degrés)
	JScansPositive bool    // false = du nord vers le sud (cas courant)
	Values         []float64
}

GribMessage est un message GRIB2 décodé : les valeurs sur une grille lat/lon.

func ReadGrib 

func ReadGrib(r io.Reader) ([]*GribMessage, error)

ReadGrib lit tous les messages GRIB2 (grille lat/lon, simple packing) d'un flux.

func (*GribMessage) ToDataArray 

func (m *GribMessage) ToDataArray(name string) (*DataArray[float64], error)

ToDataArray convertit le message en DataArray[float64] de dimensions (latitude, longitude), avec les coordonnées correspondantes.

type GroupBy 

type GroupBy[T Number] struct {
	// contains filtered or unexported fields
}

GroupBy représente un regroupement d'un DataArray le long d'une dimension, par les valeurs (éventuellement répétées) de la coordonnée de cette dimension.

Exemple : une dimension « temps » dont la coordonnée vaut [1, 1, 2, 2] (des numéros de mois répétés) peut être regroupée par mois, chaque groupe étant ensuite agrégé (somme, moyenne…).

func (*GroupBy[T]) Groups 

func (g *GroupBy[T]) Groups() int

Groups renvoie le nombre de groupes.

func (*GroupBy[T]) Labels 

func (g *GroupBy[T]) Labels() []T

Labels renvoie les étiquettes de groupe (uniques, triées).

func (*GroupBy[T]) Max 

func (g *GroupBy[T]) Max() (*DataArray[T], error)

Max agrège chaque groupe par maximum.

func (*GroupBy[T]) Mean 

func (g *GroupBy[T]) Mean() (*DataArray[float64], error)

Mean agrège chaque groupe par moyenne (résultat en float64).

func (*GroupBy[T]) Min 

func (g *GroupBy[T]) Min() (*DataArray[T], error)

Min agrège chaque groupe par minimum.

func (*GroupBy[T]) Sum 

func (g *GroupBy[T]) Sum() (*DataArray[T], error)

Sum agrège chaque groupe par somme.

type JoinType 

type JoinType int

JoinType désigne la stratégie d'alignement des coordonnées avant une opération binaire entre deux DataArrays. 

const (
	// JoinInner ne conserve que les étiquettes communes (jointure interne).
	JoinInner JoinType = iota
	// JoinOuter conserve l'union des étiquettes ; les valeurs manquantes sont
	// remplies par la valeur de remplissage fournie.
	JoinOuter
	// JoinLeft conserve les étiquettes de l'opérande gauche.
	JoinLeft
	// JoinRight conserve les étiquettes de l'opérande droit.
	JoinRight
)

func (JoinType) String 

func (j JoinType) String() string

type LazyArray 

type LazyArray struct {
	// contains filtered or unexported fields
}

LazyArray représente un calcul différé sur une ChunkSource.

func Chunk 

func Chunk(da *DataArray[float64], chunkSize int) (*LazyArray, error)

Chunk crée un LazyArray adossé à un DataArray en mémoire, découpé en blocs de chunkSize lignes (le long de l'axe 0).

func ChunkFile 

func ChunkFile(path string, dims []string, shape []int, coords map[string][]float64, chunkSize int) (*LazyArray, error)

ChunkFile crée un LazyArray adossé à un fichier binaire de float64 (ordre C), découpé en blocs de chunkSize lignes le long de l'axe 0. Les données ne sont jamais chargées entièrement en mémoire (hors-mémoire / out-of-core).

func ChunkZarr 

func ChunkZarr(dir string, chunkSize int) (*LazyArray, error)

ChunkZarr crée un LazyArray hors-mémoire adossé à un store Zarr v2 (tableau 1D ou 2D, dtype <f8). Les chunks sont lus à la demande. chunkSize est le nombre de lignes (axe 0) par bloc lazy.

func (*LazyArray) Add 

func (l *LazyArray) Add(other *LazyArray) (*LazyArray, error)

Add combine deux LazyArray par addition (différée, chunk par chunk).

func (*LazyArray) AddScalar 

func (l *LazyArray) AddScalar(s float64) *LazyArray

AddScalar empile l'ajout d'un scalaire.

func (*LazyArray) Compute 

func (l *LazyArray) Compute() (*DataArray[float64], error)

Compute matérialise le résultat en DataArray[float64] (exécution parallèle par chunk).

func (*LazyArray) Div 

func (l *LazyArray) Div(other *LazyArray) (*LazyArray, error)

Div combine par division.

func (*LazyArray) Map 

func (l *LazyArray) Map(fn func(float64) float64) *LazyArray

Map empile une transformation élément par élément (différée).

func (*LazyArray) Max 

func (l *LazyArray) Max() (float64, error)

Max renvoie le maximum (streaming).

func (*LazyArray) MaxAxis 

func (l *LazyArray) MaxAxis(dim string) (*DataArray[float64], error)

MaxAxis réduit dim par maximum (streaming).

func (*LazyArray) Mean 

func (l *LazyArray) Mean() (float64, error)

Mean renvoie la moyenne (streaming).

func (*LazyArray) MeanAxis 

func (l *LazyArray) MeanAxis(dim string) (*DataArray[float64], error)

MeanAxis réduit dim par moyenne (streaming).

func (*LazyArray) Min 

func (l *LazyArray) Min() (float64, error)

Min renvoie le minimum (streaming).

func (*LazyArray) MinAxis 

func (l *LazyArray) MinAxis(dim string) (*DataArray[float64], error)

MinAxis réduit dim par minimum (streaming).

func (*LazyArray) Mul 

func (l *LazyArray) Mul(other *LazyArray) (*LazyArray, error)

Mul combine par multiplication.

func (*LazyArray) MulScalar 

func (l *LazyArray) MulScalar(s float64) *LazyArray

MulScalar empile la multiplication par un scalaire.

func (*LazyArray) NumChunks 

func (l *LazyArray) NumChunks() int

NumChunks renvoie le nombre de blocs.

func (*LazyArray) Sub 

func (l *LazyArray) Sub(other *LazyArray) (*LazyArray, error)

Sub combine par soustraction.

func (*LazyArray) Sum 

func (l *LazyArray) Sum() (float64, error)

Sum agrège toutes les valeurs sans charger l'ensemble en mémoire.

func (*LazyArray) SumAxis 

func (l *LazyArray) SumAxis(dim string) (*DataArray[float64], error)

SumAxis réduit dim par somme (streaming).

type NetCDFConverter 

type NetCDFConverter func(src, dst string) error

NetCDFConverter réécrit le fichier src en CDF-1 classique dans dst.

func FindNetCDFConverter 

func FindNetCDFConverter() (NetCDFConverter, string, error)

FindNetCDFConverter détecte un convertisseur externe disponible dans le PATH (`nccopy` fourni par netCDF, ou `cdo`) et renvoie la fonction associée, son nom, ou une erreur si aucun n'est trouvé.

type NetCDFFormat 

type NetCDFFormat int

NetCDFFormat identifie le format d'un fichier d'après ses octets de signature. 

const (
	FormatUnknown NetCDFFormat = iota
	FormatCDF1                 // CDF\x01 — lisible directement
	FormatCDF2                 // CDF\x02 — 64-bit offset
	FormatCDF5                 // CDF\x05 — 64-bit data
	FormatHDF5                 // \x89HDF — NetCDF-4 / HDF5
)

func SniffNetCDFFormat 

func SniffNetCDFFormat(path string) (NetCDFFormat, error)

SniffNetCDFFormat lit les premiers octets d'un fichier et déduit son format.

func (NetCDFFormat) String 

func (f NetCDFFormat) String() string

type Number 

type Number interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
		~float32 | ~float64
}

Number est la contrainte des types numériques supportés par les tableaux. Elle couvre les entiers signés/non signés et les flottants.

type Period 

type Period int

Period désigne une période calendaire de rééchantillonnage. 

const (
	PeriodHour Period = iota
	PeriodDay
	PeriodMonth
	PeriodYear
)

type Resample 

type Resample[T Number] struct {
	// contains filtered or unexported fields
}

Resample regroupe les valeurs le long d'une dimension par intervalles réguliers de sa coordonnée (de largeur freq), à la manière de xarray.DataArray.resample.

Comme notre modèle ne gère pas encore le temps, le rééchantillonnage se fait sur une coordonnée numérique : le bin d'une étiquette l est floor((l - origine) / freq), l'origine étant la plus petite étiquette. La dimension est réduite aux bins (non vides), dont la coordonnée devient la borne gauche.

func GroupByTime 

func GroupByTime[T Number](da *DataArray[T], dim string, c TimeComponent) (*Resample[T], error)

GroupByTime regroupe le long de dim par composante temporelle (la coordonnée de dim étant en secondes epoch). Par exemple, grouper par CompMonth réunit tous les mois de janvier ensemble (climatologie mensuelle), quelle que soit l'année. Renvoie un Resample (agrégations Sum/Mean/Min/Max) dont les étiquettes sont les valeurs de composante (1..12 pour les mois, etc.).

func ResampleCalendar 

func ResampleCalendar[T Number](da *DataArray[T], dim string, p Period) (*Resample[T], error)

ResampleCalendar regroupe le long de dim par période calendaire (heure, jour, mois, année), la coordonnée de dim étant interprétée comme des secondes epoch. Renvoie un Resample dont les étiquettes sont les débuts de période (epoch).

func (*Resample[T]) Groups 

func (r *Resample[T]) Groups() int

Groups renvoie le nombre de bins non vides.

func (*Resample[T]) Max 

func (r *Resample[T]) Max() (*DataArray[T], error)

Max agrège chaque bin par maximum.

func (*Resample[T]) Mean 

func (r *Resample[T]) Mean() (*DataArray[float64], error)

Mean agrège chaque bin par moyenne (float64).

func (*Resample[T]) Min 

func (r *Resample[T]) Min() (*DataArray[T], error)

Min agrège chaque bin par minimum.

func (*Resample[T]) Sum 

func (r *Resample[T]) Sum() (*DataArray[T], error)

Sum agrège chaque bin par somme.

type Resampling 

type Resampling int

Resampling désigne la méthode d'interpolation au rééchantillonnage. 

const (
	Nearest  Resampling = iota // plus proche voisin
	Bilinear                   // interpolation bilinéaire (données continues)
	Cubic                      // convolution cubique (noyau de Keys, a=-0.5)
)

type Rolling 

type Rolling[T Number] struct {
	// contains filtered or unexported fields
}

Rolling représente une fenêtre glissante le long d'une dimension, à la manière de xarray.DataArray.rolling. La fenêtre est « trailing » : la valeur à l'indice i agrège les éléments [i-window+1 … i]. Les positions dont la fenêtre est incomplète (i < window-1) valent NaN.

Les agrégations renvoient un DataArray[float64] de MÊME forme (les NaN de bord imposent le type flottant, comme dans xarray).

func (*Rolling[T]) Max 

func (r *Rolling[T]) Max() (*DataArray[float64], error)

Max : maximum mobile.

func (*Rolling[T]) Mean 

func (r *Rolling[T]) Mean() (*DataArray[float64], error)

Mean : moyenne mobile.

func (*Rolling[T]) Min 

func (r *Rolling[T]) Min() (*DataArray[float64], error)

Min : minimum mobile.

func (*Rolling[T]) Sum 

func (r *Rolling[T]) Sum() (*DataArray[float64], error)

Sum : somme mobile.

type TimeComponent 

type TimeComponent int

TimeComponent désigne une composante calendaire extraite d'un instant. 

const (
	CompYear TimeComponent = iota
	CompMonth
	CompDay
	CompHour
	CompMinute
	CompWeekday   // 0 = dimanche … 6 = samedi
	CompDayOfYear // 1..366
	CompSeason    // 0 = DJF (hiver), 1 = MAM, 2 = JJA, 3 = SON
)

type Variable 

type Variable[T Number] struct {
	// contains filtered or unexported fields
}

Variable est un tableau N-dimensionnel dont les axes portent un nom. C'est la brique de base sur laquelle DataArray et Dataset sont construits.

Les données sont stockées à plat en ordre C (row-major) : le dernier axe varie le plus vite.

func NewVariable 

func NewVariable[T Number](dims []string, shape []int, data []T) (*Variable[T], error)

NewVariable construit une Variable à partir de noms de dimensions, d'une forme (shape) et de données plates en ordre C.

Contraintes vérifiées :

  • len(dims) == len(shape) ;
  • les noms de dimensions sont non vides et uniques ;
  • les tailles sont positives ou nulles ;
  • len(data) == produit des tailles.

func (*Variable[T]) At 

func (v *Variable[T]) At(idx ...int) (T, error)

At renvoie la valeur au multi-indice positionnel donné.

func (*Variable[T]) Attrs 

func (v *Variable[T]) Attrs() map[string]string

Attrs renvoie une copie des attributs (métadonnées libres).

func (*Variable[T]) Data 

func (v *Variable[T]) Data() []T

Data renvoie une copie des données plates (ordre C).

func (*Variable[T]) Dims 

func (v *Variable[T]) Dims() []string

Dims renvoie une copie des noms de dimensions.

func (*Variable[T]) Isel 

func (v *Variable[T]) Isel(dim string, index int) (*Variable[T], error)

Isel (integer select) sélectionne une position entière sur une dimension et renvoie une nouvelle Variable dont cette dimension est supprimée.

func (*Variable[T]) Ndim 

func (v *Variable[T]) Ndim() int

Ndim renvoie le nombre de dimensions.

func (*Variable[T]) SetAttr 

func (v *Variable[T]) SetAttr(key, value string)

SetAttr définit un attribut (métadonnée) sur la variable.

func (*Variable[T]) Shape 

func (v *Variable[T]) Shape() []int

Shape renvoie une copie de la forme (taille de chaque dimension).

func (*Variable[T]) Size 

func (v *Variable[T]) Size() int

Size renvoie le nombre total d'éléments.

func (*Variable[T]) String 

func (v *Variable[T]) String() string

String fournit une représentation lisible de la variable.

func (*Variable[T]) Transpose 

func (v *Variable[T]) Transpose(newDims ...string) (*Variable[T], error)

Transpose renvoie une nouvelle Variable dont les axes sont réordonnés selon newDims. newDims doit être une permutation des dimensions courantes.

type ZarrComp 

type ZarrComp = ZarrCompression

ZarrComp est un alias interne pour la lisibilité des helpers.

type ZarrCompression 

type ZarrCompression int

ZarrCompression désigne le compresseur utilisé pour les chunks. 

const (
	ZarrNone ZarrCompression = iota // aucune compression
	ZarrZlib                        // zlib (numcodecs "zlib")
	ZarrZstd                        // zstd (numcodecs "zstd")
)

Source Files

View all Source files

Directories

Path Synopsis
cmd
benchexpr command
Commande benchexpr : mesure une expression composée multi-tableaux mean(a * b) sur deux stores Zarr, lus paresseusement (out-of-core).
 Commande benchexpr : mesure une expression composée multi-tableaux mean(a * b) sur deux stores Zarr, lus paresseusement (out-of-core).
benchzarr command
Commande benchzarr : mesure le temps de calcul de la moyenne d'un tableau Zarr lu paresseusement (out-of-core) par le moteur lazy.
 Commande benchzarr : mesure le temps de calcul de la moyenne d'un tableau Zarr lu paresseusement (out-of-core) par le moteur lazy.
genzarr command
Commande genzarr : écrit un store Zarr v2 de démonstration, pour vérifier l'interopérabilité avec zarr-python.
 Commande genzarr : écrit un store Zarr v2 de démonstration, pour vérifier l'interopérabilité avec zarr-python.
genzarrds command
Commande genzarrds : écrit un Dataset comme groupe Zarr v2 (démo interop).
 Commande genzarrds : écrit un Dataset comme groupe Zarr v2 (démo interop).
ndvi command
Démo runnable : calcul d'un NDVI géoréférencé de bout en bout avec xarray-go.
 Démo runnable : calcul d'un NDVI géoréférencé de bout en bout avec xarray-go.
readgrib command
Commande readgrib : lit un GRIB2 (regular_ll, simple packing) et affiche la grille et quelques valeurs (pour valider contre ecCodes).
 Commande readgrib : lit un GRIB2 (regular_ll, simple packing) et affiche la grille et quelques valeurs (pour valider contre ecCodes).
readgrib-ec command
Commande readgrib-ec : lit un GRIB via le backend ecCodes (tout template).
 Commande readgrib-ec : lit un GRIB via le backend ecCodes (tout template).
readzarr command
Commande readzarr : lit un store Zarr v2 et affiche forme et données.
 Commande readzarr : lit un store Zarr v2 et affiche forme et données.
reproject command
Démo runnable : reprojection d'un raster géoréférencé (WGS84 lon/lat → Web Mercator EPSG:3857) avec interpolation bilinéaire, de bout en bout.
 Démo runnable : reprojection d'un raster géoréférencé (WGS84 lon/lat → Web Mercator EPSG:3857) avec interpolation bilinéaire, de bout en bout.
experimental
cgokernel
Package cgokernel est une DÉMONSTRATION isolée : appeler un noyau C vectorisé depuis Go via cgo, pour répondre à la question « peut-on réutiliser du C (comme celui de NumPy) ? ».
 Package cgokernel est une DÉMONSTRATION isolée : appeler un noyau C vectorisé depuis Go via cgo, pour répondre à la question « peut-on réutiliser du C (comme celui de NumPy) ? ».
eccodesgrib
Ce fichier fournit un remplacement pur-Go quand le backend ecCodes n'est pas compilé (absence du tag `eccodes`).
 Ce fichier fournit un remplacement pur-Go quand le backend ecCodes n'est pas compilé (absence du tag `eccodes`).
Package geoapi fournit des briques pour servir des données xarray-go à la manière d'un serveur OGC API (type pygeoapi) : export CoverageJSON, sous-échantillonnage géospatial, etc.
 Package geoapi fournit des briques pour servir des données xarray-go à la manière d'un serveur OGC API (type pygeoapi) : export CoverageJSON, sous-échantillonnage géospatial, etc.
Package ml fournit quelques algorithmes de machine learning classiques construits sur le moteur ndarray.
 Package ml fournit quelques algorithmes de machine learning classiques construits sur le moteur ndarray.
Package ndarray fournit un tableau dense N-dimensionnel de float64, façon « mini-NumPy », destiné à servir de moteur de calcul.
 Package ndarray fournit un tableau dense N-dimensionnel de float64, façon « mini-NumPy », destiné à servir de moteur de calcul.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.