main()
{
int i, j;
double t, p, x, y, z, r, R, N;
ginit(500, 500, WHITE);
GRAPH g;
g.window(-PI, -PI, PI, PI);
g.line(-PI, 0, PI, 0); // x
g.line(0, PI, 0, -PI); // y
g.setcolor(BLACK);
r = 1.0;
R = 2.0;
i = 0;
while(i < NUMBER)
{
t = i * (PI / (NUMBER / 2));
j = 0;
while(j < NUMBER)
{
p = j * (PI / (NUMBER / 2));
x = R * cos(t) + r * cos(p) * cos(t); //External reference Wikipedia
y = R * sin(t) + r * cos(p) * sin(t);
z = r * sin(p);
g.pset(x, y);
j = j + 1;
}
i = i + 1;
}
gend();
}
//Èë¿Úº¯Êý
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lptCmdLine, int nCmd)
{
srand(time(0));
ghInstance = hInstance;
ginit();
GameLoop(gdisplay);
gclear();
return 0;
}
Rat* getStrategies(Equilibrium eq)
{
int n = eq.lcpdim;
Rat* strat;
strat = malloc((n) * sizeof(Rat));
int i, row;
gmpt num, den;
ginit(num);
ginit(den);
for (i=1; i<=n; i++)
{
if((row = eq.bascobas[Z(i)]) < n) /* If Z(i) is basic */
{
/* value of Z(i): scfa[Z(i)]*rhs[row] / (scfa[RHS]*det) */
gmulint(eq.scfa[Z(i)], eq.A[row][RHS(n)], num);
gmulint(eq.det, eq.scfa[RHS(n)], den);
greduce(num, den);
strat[i-1] = ratinit();
gset(strat[i-1].num, num);
gset(strat[i-1].den, den);
}
else if((row = eq.bascobas[W(i,n)]) < n)
{
strat[i-1] = ratfromi(0);
/* value of W(i-n) is rhs[row] / (scfa[RHS]*det)
copy(num, eq.A[row][RHS(n)]);
mulint(eq.det, eq.scfa[RHS(n)], den);
reduce(num, den);
copy(strat[i-1].num, num);
copy(strat[i-1].den, den);*/
}
else
{
strat[i-1] = ratfromi(0);
}
} /* end of for (i=...) */
gclear(num);
gclear(den);
return strat;
}
int main(int argc, char *argv[])
{
ginit();
prefsize(640, 480);
winopen("Asteroids");
init();
event_loop();
gexit();
return 0;
}
void
st_memory(void)
{
enum { P = N/2/sizeof(void*) };
static OBJ arr[P];
useclass(Counter, AutoRelease);
OBJ ar = gnew(AutoRelease);
size_t sz = gsize(Counter);
size_t i;
int lvl;
// allocator warm up
for (i = 0; i < P; i++)
arr[i++] = malloc(sz);
for (i = 0; i < P; i++)
free(arr[i++]);
i = 0;
STEST( "malloc", P, arr[i++] = malloc(sz) );
i = 0;
STEST( "free", P, free(arr[i++]) );
i = 0;
STEST( "alloc + init", P, arr[i++] = ginit(galloc(Counter)) );
i = 0;
STEST( "retain", P, gretain(arr[i++]) );
i = 0;
lvl = cos_logmsg_setLevel(COS_LOGMSG_WARN);
STEST( "autoRelease", P, gautoRelease(arr[i++]) );
cos_logmsg_setLevel(lvl);
i = 0;
STEST( "release", P, grelease(arr[i++]) );
STEST( "alloc + init + release", P, grelease(ginit(galloc(Counter))) );
grelease(ar);
}
void maininit(void)
{
calibrate();
ginit();
gpal(0);
setretr(true);
initkeyb();
detectjoy();
inir();
initsound();
recstart();
}
/*
* Subroutine to do actual fixing after state initialization.
*/
static void
Dfix2(Char **v)
{
ginit(); /* Initialize glob's area pointers */
Dvp = v;
Dcp = STRNULL; /* Setup input vector for Dreadc */
unDgetC(0);
unDredc(0); /* Clear out any old peeks (at error) */
dolp = 0;
dolcnt = 0; /* Clear out residual $ expands (...) */
while (Dword())
continue;
}
void InitSGI ()
{
ginit (); /* Initialize the display. */
ginit_done = true;
cursoff ();
RGBmode (); /* Select RGB mode (24-bit color). */
gconfig ();
RGBcolor (0, 0, 0);
clear ();
qdevice (KEYBD);
}
int main(int argc, char** argv) {
printf("Test %d\n", argc);
printf("Thread %d booting\n", thread_id());
if(thread_id() == 0) {
ginit(argc, argv);
}
thread_barrior();
init(argc, argv);
thread_barrior();
char key[] = "password";
char message[] = "Hello World";
printf("Plain text: ");
for(int i = 0; i < sizeof(message); i++) {
printf("%02x", message[i]);
}
printf("\n");
char* encrypted = Encrypt(key, message, sizeof(message));
printf("Encry text: ");
for(int i = 0; i < sizeof(message); i++) {
printf("%02x", encrypted[i]);
}
printf("\n");
char* decrypted = Decrypt(key, encrypted, sizeof(message));
printf("Decry text: ");
for(int i = 0; i < sizeof(message); i++) {
printf("%02x", decrypted[i]);
}
printf("\n");
thread_barrior();
destroy();
thread_barrior();
if(thread_id() == 0) {
gdestroy(argc, argv);
}
return 0;
}
int main(int argc, char** argv) {
//printf("Thread %d bootting\n", thread_id());
if(thread_id() == 0) {
ginit(argc, argv);
}
thread_barrior();
init(argc, argv);
thread_barrior();
printf("PacketNgin APP Start\n");
perf();
perf();
perf();
/*
uint32_t i = 0;
while(1) {
uint32_t count = ni_count();
if(count > 0) {
i = (i + 1) % count;
NetworkInterface* ni = ni_get(i);
if(ni_has_input(ni)) {
process(ni);
}
}
}
*/
thread_barrior();
destroy();
thread_barrior();
if(thread_id() == 0) {
gdestroy(argc, argv);
}
while(1);
return 0;
}
/*
* Subroutine to do actual fixing after state initialization.
*/
void
Dfix2(tchar **v)
{
tchar *agargv[GAVSIZ];
#ifdef TRACE
tprintf("TRACE- Dfix2()\n");
#endif
ginit(agargv); /* Initialize glob's area pointers */
Dvp = v; Dcp = S_ /* "" */; /* Setup input vector for Dreadc */
unDgetC(0); unDredc(0); /* Clear out any old peeks (at error) */
dolp = 0; dolcnt = 0; /* Clear out residual $ expands (...) */
while (Dword())
continue;
gargv = copyblk(gargv);
}
/**************************** Main ****************************************/
void main(void)
{
int nb = 0;
initcom();
ginit();
gwindow(0,1000,0,255);
printf("\nFAPERG V1.0\n");
do {
lab_aktual();
if ( nb == 0 ) gpos(nb,ewert[0]);
else gdraw(nb,ewert[0]);
delay(10);
nb++;
} while ( !kbhit() );
gend();
}
int main(int argc, char** argv) {
printf("Thread %d booting\n", thread_id());
if(thread_id() == 0) {
ginit(argc, argv);
}
thread_barrior();
init(argc, argv);
thread_barrior();
//char name[128] = { 0, };
char *name;
printf("Input your name: ");
//fflush(stdout);
while(1) {
//int len = scanf("%s", name);
name = readline();
printf("readline()\n");
if(name){
printf("%s\n", name);
}
int len = strlen(name);
printf("%s\n", name);
if(len > 0) {
printf("%d out> Hello %s from thread %d\n", len, name, thread_id());
//fprintf(stdout, "%d out> Hello %s from thread %d\n", len, name, thread_id());
//fprintf(stderr, "%d err> Hello %s from thread %d\n", len, name, thread_id());
fflush(stdout);
}
}
thread_barrior();
destroy();
thread_barrior();
if(thread_id() == 0) {
gdestroy(argc, argv);
}
return 0;
}
/**************************** Main ****************************************/
void main(void)
{
int i;
unsigned char wert;
initcom();
ginit();
gwindow(0,4000,0,255);
printf("\nSPEICHKO V1.0\n");
for ( i = 1; i <= 4000; i++ ) {
wert = rxcharw();
if ( i == 1) gpos(i,wert);
else gdraw(i,wert);
}
txchar(CTRL_C);
printf("Dr�cke Taste..."); getch();
gend();
}
/**************************** Main ****************************************/
void main(void)
{
unsigned char zaehlertief, zaehlerhoch, data[256];
long periode = 1000000L; /* Zeitintervall zwischen Messungen */
int i, start = TRUE;
initcom();
ginit();
gwindow(0,255,0,255);
t_start(); /* Installiere Timer-Software */
t_alarm_start(); /* Installiere Alarm-Uhr */
printf("\nPOISSON V1.0\n");
for ( i = 0; i <= 255; i++ ) data[i] = 0;
t_alarm_set(0,periode,T_ONCE);
do {
do ; while ( t_alarm_check(0) == 0 );
t_alarm_set(0,periode,T_ONCE);
txchar(SYNCHBYTE);
zaehlertief = rxcharw();
zaehlerhoch = rxcharw();
if ( start ) start = FALSE; /* Erster Wert unbrauchbar */
else data[zaehlertief]++;
gclear();
for ( i = 0; i <= 255; i++ ) {
if ( i == 0 ) gpos(i, data[i]);
else gdraw(i, data[i]);
}
} while ( !kbhit() );
t_stop(); /* Desinstalliere Timer */
printf("\nDr�cke Taste..."); getch(); getch();
gend();
}
void main()
{
ginit();
load_init();
int c;
//double data;
while ( (c = getchar()) != EOF )
{
ungetc( c, stdin );
draw();
px++;
if ( px > 639 )
{
cleardevice();
px = 0;
}
}
save_init();
//closegraph();
}
Equilibrium createEquilibrium(gmpt** A, gmpt* scfa, gmpt det, int* bascobas, int* whichvar, int n, int nrows, int ncols)
{
Equilibrium eq;
T2ALLOC (eq.A, n, n+2, gmpt);
G2INIT (eq.A, n, n+2);
eq.scfa = TALLOC (n+2, gmpt);
eq.bascobas = TALLOC(2*n+1, int);
eq.whichvar = TALLOC(2*n+1, int);
int i, j;
for(i = 0; i < n; ++i)
{
for(j = 0; j < n+2; ++j)
{
gset(eq.A[i][j], A[i][j]);
}
}
for(i = 0; i < n+2; ++i)
{
gset(eq.scfa[i], scfa[i]);
}
for(i = 0; i < 2*n+1; ++i)
{
eq.bascobas[i] = bascobas[i];
eq.whichvar[i] = whichvar[i];
}
ginit(eq.det);
gset(eq.det, det);
eq.lcpdim = n;
eq.nrows = nrows;
eq.ncols = ncols;
return eq;
}
int main(int argc, char** argv) {
printf("Thread %d booting\n", thread_id());
if(thread_id() == 0) {
time_init();
event_init();
ginit(argc, argv);
}
thread_barrior();
init(argc, argv);
thread_barrior();
/* Start of User Code Area */
int fd;
file_init();
file_opendir("/", open_cb, &fd);
if(thread_id() == 0) {
while(1) {
event_loop();
}
}
/* End of User Code Area */
thread_barrior();
destroy();
thread_barrior();
if(thread_id() == 0) {
gdestroy(argc, argv);
}
return 0;
}
int main(int argc, char** argv)
{
printf("Thread %d bootting\n", thread_id());
if(thread_id() == 0) {
ginit(argc, argv);
}
thread_barrior();
init(argc, argv);
thread_barrior();
#ifdef _DEBUG_
printf("PacketNgin Performance Testing\n");
#endif
while(1){
uint32_t count = ni_count();
if(count > 0){
if(ni_has_input(ni)) {
process(ni);
}
}
}
thread_barrior();
destroy();
thread_barrior();
if(thread_id() == 0) {
gdestroy(argc, argv);
}
return 0;
}
int main(int argc, char* argv[]) {
// Initialisation
argp_parse(&argp, argc, argv, 0, 0, 0);
init_globals();
if(! wsinit() ) {
fprintf(stderr, "Could not allocate grammar workspace\n");
return 1;
}
gsl_rng* rng = gsl_rng_alloc( gsl_rng_env_setup() );
if(!rng) {
fprintf(stderr, "Could not create rng\n");
return 1;
}
// Create a set of grammars according to desired initial condition
grammar_t grammars[agents];
for(unsigned a=0; a<agents; a++) {
if(! (grammars[a] = ginit()) ) {
fprintf(stderr, "Could not create grammar\n");
}
switch(initial_condition) {
case ic_random:
randomise_associations(grammars[a], rng);
break;
case ic_identity:
identity_associations(grammars[a]);
break;
case ic_rook:
rook_associations(grammars[a], rng);
break;
default:
fprintf(stderr, "Unknown initial condition\n");
return 1;
}
renew_pseudo_associations(grammars[a]);
}
// Print out initial coherence matrix
printf("coherence agents=%u round=0\n", agents);
for(unsigned a1=0; a1<agents; a1++) {
for(unsigned a2=0; a2<agents; a2++) {
printf("%g ", coherence(grammars[a1], grammars[a2]));
}
printf("\n");
}
printf("\n");
unsigned interactions_per_round = agents * meanings * signals;
for(unsigned t=0;t<rounds*interactions_per_round;t++) {
// Update loop starts here
// 1. Choose a pair of speakers
unsigned a1 = gsl_rng_uniform_int(rng, agents);
unsigned a2 = gsl_rng_uniform_int(rng, agents-1);
if (a2 >= a1) a2++;
// 2. Speaker selects a topic
meaning_t m1 = sample_meaning(grammars[a1], rng);
// 3. Speaker produces a signal for m
signal_t s = produce_signal(grammars[a1], m1, rng);
// 4. Listener infers a meaning
meaning_t m2 = infer_meaning(grammars[a2], s, rng);
// 5. Obtain feedback
double fb = feedback > 0.0 ? stochastic_feedback(m1,m2,rng) : deterministic_feedback(m1,m2);
// 6. Update grammars
vary_association(grammars[a1], m1, s, fb*stepsize );
vary_association(grammars[a2], m2, s, fb*stepsize );
renew_pseudo_associations(grammars[a1]);
renew_pseudo_associations(grammars[a2]);
// Update loop ends here
// Print out the coherence matrix at the end of each rounds
if((t+1) % interactions_per_round == 0) {
printf("coherence agents=%u round=%u\n", agents, (t+1)/interactions_per_round);
for(unsigned a1=0; a1<agents; a1++) {
for(unsigned a2=0; a2<agents; a2++) {
printf("%g ", coherence(grammars[a1], grammars[a2]));
}
printf("\n");
}
printf("\n");
}
}
// Print out grammars at the end
for(unsigned a=0; a<agents; a++) {
printf("grammar agent=%u meanings=%u signals=%u round=%u\n", a, meanings, signals, rounds);
for(meaning_t m=0; m<meanings; m++) {
for(signal_t s=0;s<signals; s++) {
printf("%g ", get_association(grammars[a], m, s));
}
printf("\n");
}
printf("\n");
}
// Print out pseudo grammars at the end
for(unsigned a=0; a<agents; a++) {
printf("pseudo agent=%u meanings=%u signals=%u round=%u\n", a, meanings, signals, rounds);
for(meaning_t m=0; m<meanings; m++) {
for(signal_t s=0;s<signals; s++) {
printf("%g ", get_pseudo_association(grammars[a], m, s));
}
printf("\n");
}
printf("\n");
}
return 0;
}
/*
* a routine to demonstrate using locator.
*/
main()
{
int i, bt, act, nchars;
short data;
Scoord x, y, sx, sy;
Screencoord minx, maxx, miny, maxy;
ginit();
color(BLACK);
clear();
color(BLUE);
getviewport(&minx, &maxx, &miny, &maxy);
ortho2((Coord)minx, (Coord)maxx, (Coord)miny, (Coord)maxy);
/*
* draw some axes
*/
move2s((Scoord)minx, (Scoord)((maxy - miny) / 2));
draw2s((Scoord)maxx, (Scoord)((maxy - miny) / 2));
move2s((Scoord)((maxx - minx) / 2), (Scoord)miny);
draw2s((Scoord)((maxx - minx) / 2), (Scoord)maxy);
color(GREEN);
/*
* enable the left and middle mouse buttons
*/
unqdevice(INPUTCHANGE);
qdevice(LEFTMOUSE);
qdevice(MIDDLEMOUSE);
/*
* Wait for REDRAW event ...
*/
while (qread(&data) != REDRAW)
;
act = 0;
/*
* getvaluator tells us the valuator's value. In
* this case it's the X and Y positions of the mouse.
* Note: these come back to us in screen coordinates.
*/
while((bt = qread(&data)) != MIDDLEMOUSE) {
sx = getvaluator(MOUSEX);
sy = getvaluator(MOUSEY);
if (bt == -1) {
gexit();
printf("No locator device found\n");
exit(0);
} else {
if (act) {
act = 0;
move2s(sx, sy);
draw2s(x, y);
} else {
act = 1;
x = sx;
y = sy;
}
}
(void)qread(&data); /* swallow the up event */
}
gexit();
}
int main(int argc, char *argv[])
{
int rc, i, uid, n, c, ch, t, mtbl, line, offset;
FILE *fp;
char filename[64], inbuf[128], name[NATIONNMLEN+1], *p, *u;
struct stat st_buf;
/* set directory */
if(argc > 1)
if(chdir(argv[1]) == -1) {
gmove(20,18);
gprintf("Error Setting Directory %s\n", argv[1]);
ggetch();
gend();
exit(1);
}
/* set up display */
ginit();
gmove(5, 10);
gputs("WARTOOL 1.0 Game Editor for Solomoriah's WAR!");
gmove(6, 10);
gputs("Copyright 1994, J. Christopher Gonnerman");
gmove(7, 10);
gputs("All Rights Reserved.");
/* load map file */
rc = loadmap();
if(rc != 0) {
gmove(20,10);
gprintf("Error Loading Map (%s)\n", errors[rc]);
ggetch();
gend();
exit(1);
}
/* load game save */
rc = loadsave();
if(rc != 0) {
gmove(20,10);
gprintf("Error Loading Game Save (%s)\n", errors[rc]);
ggetch();
gend();
exit(1);
}
/* execute master file */
gmove(20,10);
gputs("Reading Master Commands... ");
grefresh();
fp = fopen(MASTERFL, "r");
if(fp != NULL) {
for(i = 0; fgets(inbuf, 128, fp) != NULL; i++) {
rc = execpriv(inbuf);
if(rc == 0) {
if((i+1) % 10 == 0) {
gmove(20,48);
gprintf("%3d lines", i+1);
grefresh();
}
} else {
gmove(20,10);
gprintf("Master Cmd Failed, Line %d, Code %d ", i+1, rc);
(void)ggetch();
gend();
exit(2);
}
}
fclose(fp);
}
/* main loop */
gmove(20,10);
gputs("Press Any Key to Begin... ");
gclrline();
ggetch();
mainscreen();
toolmain();
unlink("game.bak");
if(rename("game.sav", "game.bak") == 0)
fp = fopen("game.sav", "w");
else
fp = fopen("game.sv!", "w");
savegame(fp);
fclose(fp);
/* clean up */
endwin();
exit(0);
}
Memimage*
statgraph(Graph *g)
{
int i, nbin, x, lo, hi, min, max, first;
Memimage *m;
Rectangle r;
Statbin *b, bin[2000]; /* 32 kB, but whack is worse */
needstack(8192); /* double check that bin didn't kill us */
if(g->wid <= MinWidth)
g->wid = DefaultWidth;
if(g->ht <= MinHeight)
g->ht = DefaultHeight;
if(g->wid > nelem(bin))
g->wid = nelem(bin);
if(g->fill < 0)
g->fill = ((uint)(uintptr)g->arg>>8)%nelem(lofill);
if(g->fill > nelem(lofill))
g->fill %= nelem(lofill);
nbin = g->wid - (Left+Right);
binstats(g->fn, g->arg, g->t0, g->t1, bin, nbin);
/*
* compute bounds
*/
min = g->min;
max = g->max;
if(min < 0 || max <= min){
min = max = 0;
first = 1;
for(i=0; i<nbin; i++){
b = &bin[i];
if(b->nsamp == 0)
continue;
if(first || b->min < min)
min = b->min;
if(first || b->max > max)
max = b->max;
first = 0;
}
}
qlock(&memdrawlock);
ginit();
if(smallfont==nil || black==nil || blue==nil || red==nil || hifill[0]==nil || lofill[0]==nil){
werrstr("graphics initialization failed: %r");
qunlock(&memdrawlock);
return nil;
}
/* fresh image */
m = allocmemimage(Rect(0,0,g->wid,g->ht), ABGR32);
if(m == nil){
qunlock(&memdrawlock);
return nil;
}
r = Rect(Left, Top, g->wid-Right, g->ht-Bottom);
memfillcolor(m, DTransparent);
/* x axis */
memimagedraw(m, Rect(r.min.x, r.max.y, r.max.x, r.max.y+1), black, ZP, memopaque, ZP, S);
/* y labels */
drawlabel(m, r.min, max);
if(min != 0)
drawlabel(m, Pt(r.min.x, r.max.y-smallfont->height), min);
/* actual data */
for(i=0; i<nbin; i++){
b = &bin[i];
if(b->nsamp == 0)
continue;
lo = scalept(b->min, min, max, r.max.y, r.min.y);
hi = scalept(b->max, min, max, r.max.y, r.min.y);
x = r.min.x+i;
hi-=2;
memimagedraw(m, Rect(x, hi, x+1,lo), hifill[g->fill%nelem(hifill)], ZP, memopaque, ZP, S);
memimagedraw(m, Rect(x, lo, x+1, r.max.y), lofill[g->fill%nelem(lofill)], ZP, memopaque, ZP, S);
}
if(bin[nbin-1].nsamp)
drawlabel(m, Pt(r.max.x, r.min.y+(Dy(r)-smallfont->height)/2), bin[nbin-1].avg);
qunlock(&memdrawlock);
return m;
}
