Byla vydána nová verze 4.8.0 programu na úpravu digitálních fotografií darktable (Wikipedie).
Nová čísla časopisů od nakladatelství Raspberry Pi: MagPi 142 (pdf) a HackSpace 79 (pdf).
Qtractor (Wikipedie) dospěl do verze 1.0.0. Jedná se o Audio/MIDI vícestopý sekvencer.
Byl vydán svobodný kancelářský balík OnlyOffice Docs 8.1. Vedle četných oprav přináší několik funkcí včetně podpory editace textu v PDF a vytváření formulářů v PDF.
Daniel Stenberg, autor nástroje curl, z databáze SteamDB zjistil, že aktuálně 22 734 her na Steamu používá curl.
Společnost Anthropic vydala Claude 3.5 Sonnet, tj. novou verzi své umělé inteligence Claude (Wikipedie). Videoukázky na YouTube. S Claude 3, stejně jak s GPT-3.5, Llama 3 a Mixtral, si lze pokecat bez přihlašování na DuckDuckGo AI Chat.
Byla vydána nová stabilní verze 6.8 webového prohlížeče Vivaldi (Wikipedie). Postavena je na Chromiu 126. Přehled novinek i s náhledy v příspěvku na blogu a na YouTube. Vypíchnuta jsou vylepšení v integrovaném poštovním klientu.
Příspěvek Aukce domén – měsíc po spuštění na blogu CZ.NIC shrnuje první měsíc provozu Aukce domén .CZ. Aukcemi prošlo celkem 18 174 domén, z toho na 742 z nich byl učiněn alespoň 1 příhoz. Nejdražší aukcí byla na doménu virtualnisidlo.cz s cenou 95 001 Kč, která však nebyla včas uhrazena. Nejdražší aukcí, která byla vydražena i zaplacena je praguecityline.cz s cenovkou 55 600 Kč.
Před 40 lety, 19. června 1984, Bob Scheifler představil první verzi okenního systému X (X Window System). Vycházela z okenního systému W (W Window System).
Desktopové prostředí MATE bylo vydáno ve verzi 1.28. V gitových repozitářích je sice už od února, ale oznámení vydání se na webu objevilo s několikaměsíčním zpožděním (únorové datum zveřejnění je nepravdivé). Jde o první velké vydání od roku 2021. Uživatelsky nejvýznamnější pokrok je v podpoře Waylandu.
A[x][y][z][n]
. velikosti (kromě n) jsou vysoké stovky, cele pole je 1-2 GB, takže to nejde jako lokální proměnná v main. ale nedaří se mi vymyslet jak zkonvertuji pointr ziskaný alokací z malloc void * = malloc (potrebna velikost);na 4 dimenzionální pole.
Řešení dotazu:
buťto uděláš mockrát posobě malloc nebo strašně dlouhatatatatatatánskou jednorozměrnou nudli a k elementům pole se budeš dostávat ukazatelovovou aritmetikou :D ;D
hele pro 3d :O ;D prostě jako ještě jeden rozměr přidáš a bude to jakoby uplně to samý :D :D ;D ;D
Osobně bych asi radši použil tu dlouhou nudli. Jirkabuťto uděláš mockrát posobě malloc nebo strašně dlouhatatatatatatánskou jednorozměrnou nudli a k elementům pole se budeš dostávat ukazatelovovou aritmetikou :D ;D
#include <stdio.h> #include <stdlib.h> #include <string.h> #define ARRAY_TYPE int // return ARRAY_TYPE[s1][s2][s3][s4] ARRAY_TYPE ****alloc4array(size_t s1,size_t s2,size_t s3,size_t s4) { ARRAY_TYPE ****data; size_t a,b,c; data=(ARRAY_TYPE ****) malloc(s1*sizeof(ARRAY_TYPE***)); for(a=0;a<s1;a++) { data[a]=(ARRAY_TYPE ***) malloc(s2*sizeof(ARRAY_TYPE **)); if(data[a] == NULL) exit(1); for(b=0;b<s2;b++) { data[a][b]=(ARRAY_TYPE **) malloc(s3*sizeof(ARRAY_TYPE *)); if(data[a] == NULL) exit(1); for(c=0;c<s3;c++) { data[a][b][c]=(ARRAY_TYPE *) malloc(s4*sizeof(ARRAY_TYPE)); if(data[a] == NULL) exit(1); bzero(data[a][b][c], s4*sizeof(ARRAY_TYPE)); } } } return data; } int main(int argc, char **argv) { ARRAY_TYPE ****data; data=alloc4array(100,100,100,100); printf("[0,0,0,0]: %d\n", data[0][0][0][0]); // plus uvolnit pole return 0; }Ak nemáš veľkú RAM, tak dobre je pri takých testov vypnúť swap. V prípade, že program spotrebuje všetku RAM, tak OS proces zabije a nezačne pomaly swapovať.
Toto je zle riešenie, nepoužívať.Bylo by fajn napsat, kde je chyba. Ale našel jsem to. Jirka
diff
22c22 < if(data[a] == NULL) --- > if(data[a][b] == NULL) 27c27 < if(data[a] == NULL) --- > if(data[a][b][c] == NULL)
Měl jsem stejný nápad. Jirkadiff
22c22 < if(data[a] == NULL) --- > if(data[a][b] == NULL) 27c27 < if(data[a] == NULL) --- > if(data[a][b][c] == NULL)
#include <stdio.h> #include <stdlib.h> #include <string.h> #define ARRAY_TYPE int // return ARRAY_TYPE[s1][s2][s3][s4] ARRAY_TYPE ****alloc4array(size_t s1,size_t s2,size_t s3,size_t s4) { ARRAY_TYPE ****data; size_t a,b,c; data=(ARRAY_TYPE ****) malloc(s1*sizeof(ARRAY_TYPE***)); for(a=0;a<s1;a++) { data[a]=(ARRAY_TYPE ***) malloc(s2*sizeof(ARRAY_TYPE **)); if(data[a] == NULL) exit(1); for(b=0;b<s2;b++) { data[a][b]=(ARRAY_TYPE **) malloc(s3*sizeof(ARRAY_TYPE *)); if(data[a][b] == NULL) exit(1); for(c=0;c<s3;c++) { data[a][b][c]=(ARRAY_TYPE *) malloc(s4*sizeof(ARRAY_TYPE)); if(data[a][b][c] == NULL) exit(1); bzero(data[a][b][c], s4*sizeof(ARRAY_TYPE)); } } } return data; } int main(int argc, char **argv) { ARRAY_TYPE ****data; data=alloc4array(100,100,100,100); printf("[0,0,0,0]: %d\n", data[0][0][0][0]); // plus uvolnit pole return 0; }Ak nemáš veľkú RAM, tak dobre je pri takých testov vypnúť swap. V prípade, že program spotrebuje všetku RAM, tak OS proces zabije a nezačne pomaly swapovať.
mmap(3)
, se kterým se budou data ze souboru číst až při přístupu. Jem ožné to nastavit tak, že se data do souboru propisují, paměť je jen pro čtení, nebo je možné paměť zapisovat beze změny souboru.
Preferuji přístup s dlouhou jednorozměrnou nudlí, protože se nemusí mnhohokrát volat malloc a namísto 4 přístupů do paměti postačí jeden.
Ukázka:
#include <math.h> #include <stdbool.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> struct hypercube_entry { uint32_t value; }; struct hypercube { size_t z_len, y_len, x_len, w_len; struct hypercube_entry entries[]; }; struct hypercube * hypercube_alloc(size_t z_len, size_t y_len, size_t x_len, size_t w_len); inline static struct hypercube_entry * hypercube_entry(struct hypercube *hypercube, size_t z_len, size_t y_len, size_t x_len, size_t w_len); size_t hypercube_sizeof(size_t z_len, size_t y_len, size_t x_len, size_t w_len); struct hypercube * hypercube_alloc(size_t z_len, size_t y_len, size_t x_len, size_t w_len) { struct hypercube *hypercube_mem; size_t hypercube_sz; hypercube_sz = hypercube_sizeof(z_len, y_len, x_len, w_len); hypercube_mem = malloc(hypercube_sz); if (hypercube_mem == NULL) { fprintf(stderr, "Cannot allocate %lu bytes for hypercube. Aborting.\n", hypercube_sz); } hypercube_mem->z_len = z_len; hypercube_mem->y_len = y_len; hypercube_mem->x_len = x_len; hypercube_mem->w_len = w_len; } size_t hypercube_sizeof(size_t z_len, size_t y_len, size_t x_len, size_t w_len) { return sizeof(struct hypercube) + sizeof(struct hypercube_entry) * z_len * y_len * x_len * w_len; } inline static struct hypercube_entry * hypercube_entry(struct hypercube *hypercube, size_t z, size_t y, size_t x, size_t w) { struct hypercube_entry *entry = hypercube->entries; entry += z * hypercube->y_len * hypercube->x_len * hypercube->w_len; entry += y * hypercube->x_len * hypercube->w_len; entry += x * hypercube->w_len; entry += w; return entry; } int main(void) { size_t z_len = 100; size_t y_len = 99; size_t x_len = 98; size_t w_len = 97; struct hypercube *hypercube; hypercube = hypercube_alloc(z_len, w_len, y_len, x_len); printf("Allocated %lu bytes\n.", hypercube_sizeof(z_len, w_len, y_len, x_len)); /* Draw 4-dimensional super-ellipsoid. * Quite inefficient algorithm. */ for (int x = 0; x < hypercube->x_len; x++) for (int y = 0; y < hypercube->y_len; y++) for (int z = 0; z < hypercube->z_len; z++) for (int w = 0; w < hypercube->w_len; w++) { bool is_inside = .5f >= ( powf(((float) x - 50.f) * .02, 4.f) + powf(((float) y - 50.f) * .02, 4.f) + powf(((float) z - 50.f) * .02, 4.f) + powf(((float) w - 50.f) * .02, 4.f)); hypercube_entry(hypercube, z, y, x, w)->value = is_inside ? 1 : 0; } /* Draw slices of it. */ for (int w = 10; w < hypercube->w_len - 10; w += 10) { printf("w = %i\n", w); for (int y = 1; y < hypercube->y_len; y += 2) { for (int x = 1; x < hypercube->x_len; x++) { int z = 0; for (; z < hypercube->z_len && !hypercube_entry(hypercube, z, y, x, w)->value; z++); if (z < 80) { if (hypercube_entry(hypercube, z, y - 1, x - 1, w) ->value) { putchar('*'); } else { putchar('#'); } } else { putchar('_'); } } putchar('\n'); } putchar('\n'); } }
MAP_PRIVATE
) s možností zápisu a zapisovat do něj jak chce.
Odpovědi typu rádoby-pole à la Java už tady zazněly, takže přidávám jednu s kompaktním 4-rozměrným polem.
Tohle^^^, mimochodem, v dotazu chybí — jestli jsou jednotlivé dimenze stále stejně velké a pole lze tudíž alokovat naráz jedním malloc()
em nebo jestli se velikost různých (pod)polí může lišit a všechno se pak musí alokovat přes další úrovně polí pointerů, jako v Javě.
#include <inttypes.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> struct A { int blah; }; static const size_t X = 11, Y = 13, Z = 7, N = 5; int main() { struct A (*const array)[Y][Z][N] = malloc(sizeof(struct A[X][Y][Z][N])); int counter = X * Y * Z * N / 2; for (size_t x = 0; x < X; ++x) for (size_t y = 0; y < Y; ++y) for (size_t z = 0; z < Z; ++z) for (size_t n = 0; n < N; ++n) array[x][y][z][n].blah = counter--; int64_t sum = 0; for (size_t x = 0; x < X; ++x) for (size_t y = 0; y < Y; ++y) for (size_t z = 0; z < Z; ++z) for (size_t n = 0; n < N; ++n) sum += array[x][y][z][n].blah; free(array); printf("%" PRId64 "\n", sum); }
Trik je v tom, že v typu pointeru na pole array
chybí první rozměr X
— ten jako jediný není třeba definovat v typu, protože pointerová ařiťmetika potřebuje znát jenom ty následující rozměry. Tedy 4-rozměrné pole můžeme s klidem nechat „zkazit“ na pointer na první (tedy, nulté) 3-rozměrné (pod)pole.
Že to vypíše nulu, to je asi jasné, leč mnohem důležitější vždycky je, co na to říká valgrind
.
Ještě pro úplnost: To „slibované“ smrduté kazení pole na pointer se v mém příkladu vůbec neděje. Vezmu void*
z malloc()
a přiřadím ho rovnou do pointeru na nulté 3-rozměrné pod-pole.
Ale kdybych kolem toho chtěl strašně moc kecat, mohlo by to vypadat třeba takhle:
struct A (*const alloc)[X][Y][Z][N] = malloc(sizeof(struct A[X][Y][Z][N])); struct A (*const array)[Y][Z][N] = *alloc; /* Tady! */ /* ... */ free(alloc);
Jo a kdo si to chce fakt zahustit, ten si může nastavit třeba:
static const size_t X = 201, Y = 201, Z = 201, N = 201;To^^^ pak trvá (na mém stroji) celé 1,5 (se)kundy, což už je nějaké trvání! Velikost toho pole bude 6528963204 B, takže asi 6,08 GiB.
(se)kundyhahahahahaha nechceš být standup komik s tímhle materiálem?
Chtěl bych kandidovat na prezidenta, až na to budu mít věk. Zatím mám fyzicky 37 a mentálně cca 15, takže 2023 nestíhám. 2028 snad.
Tiskni
Sdílej: