int loadngc(int32_t index) { static int failed; int32_t j; ngcopen(); j = (index-1)*sizeof(NGCrec); grow(); cur->type = NGC; cur->index = index; seek(ngcdb, j, 0); /* special case: NGC data may not be available */ if(read(ngcdb, &cur->ngc, sizeof(NGCrec)) != sizeof(NGCrec)) { if(!failed) { fprint(2, "scat: NGC database not available\n"); failed++; } cur->type = NONGC; cur->ngc.ngc = 0; cur->ngc.ra = 0; cur->ngc.dec = 0; cur->ngc.diam = 0; cur->ngc.mag = 0; return 0; } cur->ngc.ngc = Short(&cur->ngc.ngc); cur->ngc.ra = Long(&cur->ngc.ra); cur->ngc.dec = Long(&cur->ngc.dec); cur->ngc.diam = Long(&cur->ngc.diam); cur->ngc.mag = Short(&cur->ngc.mag); return 1; }
int main() { int ret = 0; _Double d1 = std::make_shared<Double>(1.2); _Double d2 = std::make_shared<Double>(3.4); System::out::println("d1.class: " + d1->getClassName()); System::out::println("d1.long: " + Long(d1->doubleToLongBits()).toString()); System::out::println("d2.long: " + Long(d2->doubleToLongBits()).toString()); System::out::println("d1.hash: " + Integer(d1->hashCode()).toString()); System::out::println("d2.hash: " + Integer(d2->hashCode()).toString()); Double* d3 = new Double(1.2); Object* d4 = new Double(1.2); ret = ret + !d1.get()->equals(1.2); ret = ret + !d1.get()->equals(d3); ret = ret + !d1.get()->equals(d1); ret = ret + !d1.get()->equals(d4); delete d3; delete d4; ret = ret + Assert::assertEquals(d1, d1); ret = ret + !Assert::assertEquals(d1, d2); return ret; }
int loadabell(int32_t index) { int32_t j; abellopen(); j = index-1; grow(); cur->type = Abell; cur->index = index; seek(abelldb, j*sizeof(Abellrec), 0); Eread(abelldb, "abell", &cur->abell, sizeof(Abellrec)); cur->abell.abell = Short(&cur->abell.abell); if(cur->abell.abell != index) { fprint(2, "bad format in abell catalog\n"); exits("abell"); } cur->abell.ra = Long(&cur->abell.ra); cur->abell.dec = Long(&cur->abell.dec); cur->abell.glat = Long(&cur->abell.glat); cur->abell.glong = Long(&cur->abell.glong); cur->abell.rad = Long(&cur->abell.rad); cur->abell.mag10 = Short(&cur->abell.mag10); cur->abell.pop = Short(&cur->abell.pop); cur->abell.dist = Short(&cur->abell.dist); return 1; }
/* * adfGetCacheEntry * * Returns a cache entry, starting from the offset p (the index into records[]) * This offset is updated to the end of the returned entry. */ void adfGetCacheEntry(struct bDirCacheBlock *dirc, int *p, struct CacheEntry *cEntry) { int ptr; ptr = *p; /*printf("p=%d\n",ptr);*/ #ifdef LITT_ENDIAN cEntry->header = swapLong(dirc->records+ptr); cEntry->size = swapLong(dirc->records+ptr+4); cEntry->protect = swapLong(dirc->records+ptr+8); cEntry->days = swapShort(dirc->records+ptr+16); cEntry->mins = swapShort(dirc->records+ptr+18); cEntry->ticks = swapShort(dirc->records+ptr+20); #else cEntry->header = Long(dirc->records+ptr); cEntry->size = Long(dirc->records+ptr+4); cEntry->protect = Long(dirc->records+ptr+8); cEntry->days = Short(dirc->records+ptr+16); cEntry->mins = Short(dirc->records+ptr+18); cEntry->ticks = Short(dirc->records+ptr+20); #endif cEntry->type =(signed char) dirc->records[ptr+22]; cEntry->nLen = dirc->records[ptr+23]; /* cEntry->name = (char*)calloc(1,sizeof(char)*(cEntry->nLen+1)); if (!cEntry->name) return; */ memcpy(cEntry->name, dirc->records+ptr+24, cEntry->nLen); cEntry->name[(int)(cEntry->nLen)]='\0'; cEntry->cLen = dirc->records[ptr+24+cEntry->nLen]; if (cEntry->cLen>0) { /* cEntry->comm =(char*)calloc(1,sizeof(char)*(cEntry->cLen+1)); if (!cEntry->comm) { free( cEntry->name ); cEntry->name=NULL; return; } */ memcpy(cEntry->comm,dirc->records+ptr+24+cEntry->nLen+1,cEntry->cLen); } cEntry->comm[(int)(cEntry->cLen)]='\0'; /*printf("cEntry->nLen %d cEntry->cLen %d %s\n",cEntry->nLen,cEntry->cLen,cEntry->name);*/ *p = ptr+24+cEntry->nLen+1+cEntry->cLen; /* the starting offset of each record must be even (68000 constraint) */ if ((*p%2)!=0) *p=(*p)+1; }
void UnitSphereDistribution::operator () (double &x, double &y, double &z) { for (;;) { double d1 = 1.0 - scale * Long(), d2 = 1.0 - scale * Long(), dd = d1 * d1 + d2 * d2; if (dd < 1.0) { z = 1 - 2 * dd; dd = 2 * sqrt(1.0-dd); x = d1 * dd; y = d2 * dd; return; } } }
xyz geolocation::toxyz() const { // Approach developed by: // // (Olson, D.K. (1996). // "Converting earth-Centered, Earth-Fixed Coordinates to Geodetic Coordinates," // IEEE Transactions on Aerospace and Electronic Systems, Vol. 32, No. 1, January 1996, pp. 473 - 476). // // // Java implementation: // // D. Rose (2014). // "Converting between Earth-Centered, Earth Fixed and Geodetic Coordinates" // //Convert Lat, Lon, Altitude to Earth-Centered-Earth-Fixed (ECEF) //Input is a three element array containing lat, lon (rads) and alt (m) //Returned array contains x, y, z in meters static const double a = 6378137.0; //WGS-84 semi-major axis static const double e2 = 6.6943799901377997e-3; //WGS-84 first eccentricity squared double lat = degreestoradians(Lat()); double lon = degreestoradians(Long()); double alt = Alt(); double n = a / sqrt(1 - e2*sin(lat)*sin(lat)); double dx = ((n + alt)*cos(lat)*cos(lon)); //ECEF x double dy = ((n + alt)*cos(lat)*sin(lon)); //ECEF y double dz = ((n*(1 - e2) + alt)*sin(lat)); //ECEF z return(xyz(dx, dy, dz)); //Return x, y, z in ECEF }
Ran055::Ran055 (unsigned long the_seed) : RandomGenerator(the_seed) { int i, ii; long j, k; // requires at least 32 bit arithmetics assert( sizeof(unsigned long) >= 4 ); max_val = MAX; // initialize the maximum value max_val // initialize table s55[0] = j = seed^MASK ; // XORing with MASK allows use of zero // and other simple bit patterns for idum. k = 1; for (i = 1; i < 55; i++) { ii = (21 * i) % 55; s55[ii] = k; k = j - k; j = s55[ii] ; } j55 = 0; // invariance (b-a-24)%55 = 0 k55 = 24; for (i = 0; i < 165; i++) Long(); // warm up table three times }
TypedValue & TypedValue::operator ! () { if (type == S_FLOAT) { return Int((int32)(! FloatValue(nullptr))); } if (type == S_LONG) return Long((int64)(! LongValue(nullptr))); return Int((int32)(! IntValue(nullptr))); }
TypedValue & TypedValue::operator - () { if (type == S_FLOAT) { return Float( - FloatValue(nullptr)); } if (type == S_LONG) return Long((int64)(- LongValue(nullptr))); return Int(- IntValue(nullptr)); }
TypedValue & TypedValue::operator / (TypedValue &t2) { if (type == S_FLOAT || t2.type == S_FLOAT) { return Float( FloatValue(nullptr) / t2.FloatValue(nullptr)); } if (type == S_LONG || t2.type == S_LONG) return Long((int64)(LongValue(nullptr) / t2.LongValue(nullptr))); return Int( IntValue(nullptr) / t2.IntValue(nullptr)); }
TypedValue & TypedValue::operator ~ () { if (type == S_FLOAT) { internalError("dodgy bitwise operand"); return Int((int32)-1); } if (type == S_LONG) return Long((int64)(~ LongValue(nullptr))); return Int(~ IntValue(nullptr)); }
TypedValue & TypedValue::operator % (TypedValue &t2) { if (type == S_FLOAT || t2.type == S_FLOAT) { internalError("Dodgy mod: float to float"); return Int((int32)-1); } if (type == S_LONG || t2.type == S_LONG) return Long((int64)(LongValue(nullptr) % t2.LongValue(nullptr))); return Int( IntValue(nullptr) % t2.IntValue(nullptr)); }
/* * adfBitmapSum * */ unsigned long adfBitmapSum(unsigned char *buf) { unsigned long newSum; int i; newSum = 0L; for(i=1; i<128; i++) newSum-=Long(buf+i*4); return(newSum); }
int loadsao(int index) { if(index<=0 || index>NSAO) return 0; saoopen(); grow(); cur->type = SAO; cur->index = index; seek(saodb, (index-1)*sizeof(SAOrec), 0); Eread(saodb, "sao", &cur->sao, sizeof(SAOrec)); cur->sao.ra = Long(&cur->sao.ra); cur->sao.dec = Long(&cur->sao.dec); cur->sao.dra = Long(&cur->sao.dra); cur->sao.ddec = Long(&cur->sao.ddec); cur->sao.mag = Short(&cur->sao.mag); cur->sao.mpg = Short(&cur->sao.mpg); cur->sao.hd = Long(&cur->sao.hd); return 1; }
/* * NormalSum * * buf = where the block is stored * offset = checksum place (in bytes) * bufLen = buffer length (in bytes) */ unsigned long adfNormalSum( UCHAR* buf, int offset, int bufLen ) { long newsum; int i; newsum=0L; for(i=0; i < (bufLen/4); i++) if ( i != (offset/4) ) /* old chksum */ newsum+=Long(buf+i*4); newsum=(-newsum); /* WARNING */ return(newsum); }
int loadpatch(int32_t index) { int i; patchopen(); if(index<=0 || index>Npatch) return 0; grow(); cur->type = Patch; cur->index = index; seek(patchdb, patchaddr[index-1], 0); cur->patch.nkey = (patchaddr[index]-patchaddr[index-1])/4; Eread(patchdb, "patch", cur->patch.key, cur->patch.nkey*4); for(i=0; i<cur->patch.nkey; i++) cur->patch.key[i] = Long(&cur->patch.key[i]); return 1; }
void nameopen(void) { Biobuf b; int i; char *l, *p; if(namedb == 0) { namedb = eopen("name"); Binit(&b, namedb, OREAD); for(i=0; i<NName; i++) { l = Brdline(&b, '\n'); if(l == 0) break; p = strchr(l, '\t'); if(p == 0) { Badformat: Bprint(&bout, "warning: name.scat bad format; line %d\n", i+1); break; } *p++ = 0; strcpy(name[i].name, l); if(strncmp(p, "ngc", 3) == 0) name[i].ngc = atoi(p+3); else if(strncmp(p, "ic", 2) == 0) name[i].ngc = atoi(p+2)+NNGC; else if(strncmp(p, "sao", 3) == 0) name[i].sao = atoi(p+3); else if(strncmp(p, "abell", 5) == 0) name[i].abell = atoi(p+5); else goto Badformat; } if(i == NName) Bprint(&bout, "warning: too many names in name.scat (max %d); extra ignored\n", NName); close(namedb); bayerdb = eopen("bayer"); Eread(bayerdb, "bayer", bayer, sizeof bayer); close(bayerdb); for(i=0; i<NBayer; i++) bayer[i].sao = Long(&bayer[i].sao); } }
unsigned long adfBootSum2(unsigned char *buf) { unsigned long prevsum, newSum; int i; prevsum = newSum=0L; for(i=0; i<1024/sizeof(unsigned long); i++) { if (i!=1) { prevsum = newSum; newSum += Long(buf+i*4); if (newSum < prevsum) newSum++; } } newSum = ~newSum; /* not */ return(newSum); }
/* * adfBootSum * */ unsigned long adfBootSum(unsigned char *buf) { unsigned long d, newSum; int i; newSum=0L; for(i=0; i<256; i++) { if (i!=1) { d = Long(buf+i*4); if ( (ULONG_MAX-newSum)<d ) newSum++; newSum+=d; } } newSum = ~newSum; /* not */ return(newSum); }
void swapEndian( unsigned char *buf, int type ) { int i,j; int p; i=0; p=0; if (type>MAX_SWTYPE || type<0) adfEnv.eFct("SwapEndian: type do not exist"); while( swapTable[type][i]!=0 ) { for(j=0; j<swapTable[type][i]; j++) { switch( swapTable[type][i+1] ) { case SW_LONG: *(unsigned long*)(buf+p)=Long(buf+p); p+=4; break; case SW_SHORT: *(unsigned short*)(buf+p)=Short(buf+p); p+=2; break; case SW_CHAR: p++; break; default: ; } } i+=2; } if (p!=swapTable[type][i+1]) (*adfEnv.wFct)("Warning: Endian Swapping length"); /* BV */ }
TypedValue & TypedValue::operator - (TypedValue &t2) { if (type == S_TIME && t2.type == S_TIME) { Time *ti1 = TimeValue(); Time *ti2 = t2.TimeValue(); return TimeV(*ti1 - *ti2); } if (type == S_TIME) { Time *ti1 = TimeValue(); int ti2 = t2.IntValue(nullptr); return TimeV(*ti1 - ti2); } if (t2.type == S_TIME) { int ti1 = IntValue(nullptr); Time *ti2 = t2.TimeValue(); return TimeV(Time(ti1) - *ti2); } if (type == S_FLOAT || t2.type == S_FLOAT) return Float( FloatValue(nullptr) - t2.FloatValue(nullptr)); if (type == S_LONG || t2.type == S_LONG) return Long((int64)(LongValue(nullptr) - t2.LongValue(nullptr))); return Int( IntValue(nullptr) - t2.IntValue(nullptr)); }
Long convert(long long a) { return normal(Long(1, a)); }
int _tmain(int argc, _TCHAR* argv[]) { /*int width = 1024,height=600; SDL_Surface* screen = enableScreen(width,height,24); Color white = Color(255,255,255); float red=255,green=255,blue=255,posx=200,posy=200; white.SetNewColor(red,green,blue); while (true) { SDL_Event keyEvent ; SDL_PollEvent(&keyEvent); for (int x=posx;x<posx+100;x++) for (int y=posy;y<posy+100;y++) { putpixel(screen,x,y,Color(0,0,0).GetUint32()); } if(keyEvent.type == SDL_KEYDOWN) switch (keyEvent.key.keysym.sym) { case SDLK_ESCAPE: return 0; case SDLK_1: if(red<255) red+=1; break; case SDLK_2: if(red>0) red-=1; break; case SDLK_3: if(green<255) green+=1; break; case SDLK_4: if(green>0) green-=1; break; case SDLK_5: if(blue<255) blue+=1; break; case SDLK_6: if(blue>0) blue-=1; break; case SDLK_UP: posy-=1; break; case SDLK_DOWN: posy+=1; break; case SDLK_LEFT: posx-=1; break; case SDLK_RIGHT: posx+=1; break; } white.SetNewColor(red,green,blue); for (int x=posx;x<posx+100;x++) for (int y=posy;y<posy+100;y++) { putpixel(screen,x,y,white.GetUint32()); } SDL_UpdateRect(screen,0,0,width,height); }*/ Sphere s1 = Sphere(Vector(0,200,0),Color(255,0,0),20); SDL_Surface* screen = enableScreen(1024,600,24); LightSource light(150,50,0,20000); DrawSphere(screen,s1,1024,600,light); //SmartDrawSphere(screen,light,s1,1024,600); float a = Skalar(s1.center_,s1.center_); int b = Long(s1.center_); while (true) { SDL_Event keyEvent ; SDL_PollEvent(&keyEvent); if(keyEvent.type == SDL_KEYDOWN) switch (keyEvent.key.keysym.sym) { case SDLK_ESCAPE: return 0; case SDLK_LEFT: { DrawScreen(screen,1024,600,Color(0,0,0)); light.x_-=5; DrawSphere(screen,s1,1024,600,light); break; } case SDLK_RIGHT: { DrawScreen(screen,1024,600,Color(0,0,0)); light.x_+=5; DrawSphere(screen,s1,1024,600,light); break; } case SDLK_UP: { DrawScreen(screen,1024,600,Color(0,0,0)); light.y_+=5; DrawSphere(screen,s1,1024,600,light); break; } case SDLK_DOWN: { DrawScreen(screen,1024,600,Color(0,0,0)); light.y_-=5; DrawSphere(screen,s1,1024,600,light); break; } case SDLK_PAGEUP: { DrawScreen(screen,1024,600,Color(0,0,0)); light.density_+=1000; DrawSphere(screen,s1,1024,600,light); break; } case SDLK_PAGEDOWN: { DrawScreen(screen,1024,600,Color(0,0,0)); light.density_-=1000; DrawSphere(screen,s1,1024,600,light); break; } } //DrawScreen(screen,1024,600,Color(0,0,0)); //DrawSphere(screen,s1,1024,600,light); } return 0; }
void RealClass::ToInt(Context *ctx, Long n) throw(Exception) { Real *r = (Real*) ctx->at(-n); ctx->pop(n); ctx->push(new Integer(Long(r->data))); }