コード例 #1
0
int main()
{
    const fix_point fp1(6.375f);
    const fix_point fp2 = -4.0f;

    // ----------------------------------------------------------
    // integral and fractional parts
    assert( floor(fp1) ==  6.f  );
    assert( fp1.frac() == .375f );

    assert( frac(fp1)  == .375f );
    assert( floor(fp2) == -4.f  );
    assert( fp2.frac() ==  0.f  );
    assert( frac(fp2)  ==  0.f  );

    // ----------------------------------------------------------
    // comparison and ordering
    assert( fp1 == fix_point(6.375) );
    assert( fp1 == 6.375f);
    assert( fp2 != fp1 );
    assert( fp2 < fp1  );
    assert( fp1 > fp2  );
    assert( fp2 <= fp1 );
    assert( fp1 >= fp2 );
    assert( fp1 <= fix_point(6.375) );
    assert( fp1 >= fix_point(6.375) );

    // ----------------------------------------------------------
    // arithmetics
    assert( fp1 + fp2 ==  2.375f   );
    assert( fp1 - fp2 ==  10.375f  );
    assert( fp1 * fp2 == -25.5f    );
    assert( fp1 / fp2 == -1.59375f );

    // ----------------------------------------------------------
    // arithmetics assignment
    fix_point
    fp3 = fp1;  fp3 += fp2;     assert( fp3 ==  2.375f   );
    fp3 = fp1;  fp3 -= fp2;     assert( fp3 ==  10.375f  );
    fp3 = fp1;  fp3 *= fp2;     assert( fp3 == -25.5f    );
    fp3 = fp1;  fp3 /= fp2;     assert( fp3 == -1.59375f );

    // ----------------------------------------------------------
    // pre/post - increment/decrement
    fp3 = fp1;  assert( ++fp3 ==  7.375f );
    fp3 = fp1;  assert( --fp3 ==  5.375f );
    fp3 = fp1;  assert( fp3++ ==  6.375f  );  assert( fp3 ==  7.375f  );
    fp3 = fp1;  assert( fp3-- ==  6.375f  );  assert( fp3 ==  5.375f  );

    // ----------------------------------------------------------
    // trigonometric functions
    assert( sin(fix_point(0.3f)) == fix_point(sin(0.3f)) );
    assert( cos(fix_point(0.5f)) == fix_point(cos(0.5f)) );

    // ----------------------------------------------------------
    // check some more numbers
    for ( float f = 0.f ; f <= 1.f ; f += 0.25f )   assert( fix_point(f) == f );
}
コード例 #2
0
ファイル: frsky_data.c プロジェクト: 30rasheed/x-VTOLdrone
/**
 * Sends frame 2 (every 1000ms):
 *   GPS course, latitude, longitude, ground speed, GPS altitude, remaining battery level
 */
void frsky_send_frame2(int uart)
{
	/* get a local copy of the global position data */
	struct vehicle_global_position_s global_pos;
	memset(&global_pos, 0, sizeof(global_pos));
	orb_copy(ORB_ID(vehicle_global_position), global_position_sub, &global_pos);

	/* get a local copy of the vehicle status data */
	struct vehicle_status_s vehicle_status;
	memset(&vehicle_status, 0, sizeof(vehicle_status));
	orb_copy(ORB_ID(vehicle_status), vehicle_status_sub, &vehicle_status);

	/* send formatted frame */
	float course = 0, lat = 0, lon = 0, speed = 0, alt = 0;
	char lat_ns = 0, lon_ew = 0;
	int sec = 0;
	if (global_pos.global_valid) {
		time_t time_gps = global_pos.time_gps_usec / 1000000;
		struct tm *tm_gps = gmtime(&time_gps);

		course = (global_pos.yaw + M_PI_F) / M_PI_F * 180.0f;
		lat    = frsky_format_gps(abs(global_pos.lat));
		lat_ns = (global_pos.lat < 0) ? 'S' : 'N';
		lon    = frsky_format_gps(abs(global_pos.lon));
		lon_ew = (global_pos.lon < 0) ? 'W' : 'E';
		speed  = sqrtf(global_pos.vel_n * global_pos.vel_n + global_pos.vel_e * global_pos.vel_e)
				* 25.0f / 46.0f;
		alt    = global_pos.alt;
		sec    = tm_gps->tm_sec;
	}

	frsky_send_data(uart, FRSKY_ID_GPS_COURS_BP, course);
	frsky_send_data(uart, FRSKY_ID_GPS_COURS_AP, frac(course) * 1000.0f);

	frsky_send_data(uart, FRSKY_ID_GPS_LAT_BP, lat);
	frsky_send_data(uart, FRSKY_ID_GPS_LAT_AP, frac(lat) * 10000.0f);
	frsky_send_data(uart, FRSKY_ID_GPS_LAT_NS, lat_ns);

	frsky_send_data(uart, FRSKY_ID_GPS_LONG_BP, lon);
	frsky_send_data(uart, FRSKY_ID_GPS_LONG_AP, frac(lon) * 10000.0f);
	frsky_send_data(uart, FRSKY_ID_GPS_LONG_EW, lon_ew);

	frsky_send_data(uart, FRSKY_ID_GPS_SPEED_BP, speed);
	frsky_send_data(uart, FRSKY_ID_GPS_SPEED_AP, frac(speed) * 100.0f);

	frsky_send_data(uart, FRSKY_ID_GPS_ALT_BP, alt);
	frsky_send_data(uart, FRSKY_ID_GPS_ALT_AP, frac(alt) * 100.0f);

	frsky_send_data(uart, FRSKY_ID_FUEL,
			roundf(vehicle_status.battery_remaining * 100.0f));

	frsky_send_data(uart, FRSKY_ID_GPS_SEC, sec);

	frsky_send_startstop(uart);
}
コード例 #3
0
ShGeneric<N, T> hashmrg(const ShGeneric<N, T>& p) {
  ShAttrib<N, SH_TEMP, T> result = frac(p * 0.01);
  ShGeneric<N, T> a = fillcast<N>(
      ShConstAttrib4f(M_PI * M_PI * M_PI * M_PI, std::exp(4.0), 
          std::pow(13.0, M_PI / 2.0), std::sqrt(1997.0)));

  for(int i = 0; i < MRG_REPS; ++i) {
    for(int j = 0; j < N; ++j) { 
      result(j) = frac(dot(result, a));
    }
  }
  return result;
}
コード例 #4
0
ShGeneric<N, T> hashlcg(const ShGeneric<N, T>& p) {
  ShAttrib<N, SH_TEMP, T> result = frac(p * 0.01);

  // TODO fix this for long tuples
  ShGeneric<N, T> a = fillcast<N>(
      ShConstAttrib4f(M_PI * M_PI * M_PI * M_PI, std::exp(4.0), 
          std::pow(13.0, M_PI / 2.0), std::sqrt(1997.0)));
  ShGeneric<N, T> m = fillcast<N>(
      ShConstAttrib4f(std::sqrt(2.0), 1.0 / M_PI, std::sqrt(3.0), 
          std::exp(-1.0)));

  for(int i = 0; i < LCG_REPS; ++i) result = frac(mad(result, a, m)); 
  return result;
}
コード例 #5
0
ファイル: sampsampler.cpp プロジェクト: DimondTheCat/xray
BOOL SingleSampler::NextSample( Point2* pOut, float* pSampleSz )
{
	if ( n ) return FALSE;
#ifdef CENTER_OF_PIXEL
	pOut->x = pOut->y = 0.5f;
#else
	*pOut = pSC->SurfacePtScreen();	// center of fragment
    pOut->x = frac( pOut->x ); pOut->y = frac( pOut->y );
#endif
	*pSampleSz = 1.0f;	// entire pixel

	++n;
	return TRUE;
}
コード例 #6
0
ファイル: plBMSampler.cpp プロジェクト: Asteral/Plasma
AColor plBMSampler::Sample(ShadeContext& sc, float u,float v) 
{
    AColor none(0.0f, 0.0f, 0.0f, 0.0f);

    if (!fInitialized)
        return none;

    BMM_Color_64 c;
    int x,y;
    float fu,fv;
    fu = frac(u);
    fv = 1.0f-frac(v);
    if (fData.fEnableCrop)
    {
        if (fData.fCropPlacement)
        {
            if (!PlaceUV(sc,fu, fv, int(u), int(v)))
                return AColor(0,0,0,0);
            x = (int)(fu*fbmw+0.5f);
            y = (int)(fv*fbmh+0.5f);
        }
        else
        {
            x = mod(clipx + (int)(fu*fclipw+0.5f),bmw);
            y = mod(clipy + (int)(fv*fcliph+0.5f),bmh);
        }
    }
    else
    {
        x = (int)(fu*fbmw+0.5f);
        y = (int)(fv*fbmh+0.5f);
    }
    fBM->GetLinearPixels(x,y,1,&c);
    switch(fData.fAlphaSource)
    {
    case plBMSamplerData::kDiscard:
        c.a = 0xffff; 
        break;
    case plBMSamplerData::kFromRGB:
        c.a = (c.r+c.g+c.b)/3; 
        break;
        //  TBD
        // XPCOL needs to be handled in bitmap for filtering. 
        // Need to open a bitmap with this property.
        //  case ALPHA_XPCOL:  break; 
    }
    return c;
}
コード例 #7
0
ファイル: fraction.cpp プロジェクト: zoness32/Program-2
Fraction& Fraction::operator = (const float& f)
{
    Fraction frac(f);
    num = frac.num;
    den = frac.den;
    return *this;
}
コード例 #8
0
ファイル: frsky_data.c プロジェクト: 30rasheed/x-VTOLdrone
/**
 * Sends frame 1 (every 200ms):
 *   acceleration values, barometer altitude, temperature, battery voltage & current
 */
void frsky_send_frame1(int uart)
{
	/* get a local copy of the current sensor values */
	struct sensor_combined_s raw;
	memset(&raw, 0, sizeof(raw));
	orb_copy(ORB_ID(sensor_combined), sensor_sub, &raw);

	/* get a local copy of the battery data */
	struct battery_status_s battery;
	memset(&battery, 0, sizeof(battery));
	orb_copy(ORB_ID(battery_status), battery_sub, &battery);

	/* send formatted frame */
	frsky_send_data(uart, FRSKY_ID_ACCEL_X,
			roundf(raw.accelerometer_m_s2[0] * 1000.0f));
	frsky_send_data(uart, FRSKY_ID_ACCEL_Y,
			roundf(raw.accelerometer_m_s2[1] * 1000.0f));
	frsky_send_data(uart, FRSKY_ID_ACCEL_Z,
			roundf(raw.accelerometer_m_s2[2] * 1000.0f));

	frsky_send_data(uart, FRSKY_ID_BARO_ALT_BP,
			raw.baro_alt_meter);
	frsky_send_data(uart, FRSKY_ID_BARO_ALT_AP,
			roundf(frac(raw.baro_alt_meter) * 100.0f));

	frsky_send_data(uart, FRSKY_ID_TEMP1,
			roundf(raw.baro_temp_celcius));

	frsky_send_data(uart, FRSKY_ID_VFAS,
			roundf(battery.voltage_v * 10.0f));
	frsky_send_data(uart, FRSKY_ID_CURRENT,
			(battery.current_a < 0) ? 0 : roundf(battery.current_a * 10.0f));

	frsky_send_startstop(uart);
}
コード例 #9
0
ファイル: frsky_data.c プロジェクト: 27Seanerz/Firmware
/**
 * Sends frame 1 (every 200ms):
 *   acceleration values, barometer altitude, temperature, battery voltage & current
 */
void frsky_send_frame1(int uart)
{
	/* send formatted frame */
	frsky_send_data(uart, FRSKY_ID_ACCEL_X,
			roundf(sensor_combined->accelerometer_m_s2[0] * 1000.0f));
	frsky_send_data(uart, FRSKY_ID_ACCEL_Y,
			roundf(sensor_combined->accelerometer_m_s2[1] * 1000.0f));
	frsky_send_data(uart, FRSKY_ID_ACCEL_Z,
			roundf(sensor_combined->accelerometer_m_s2[2] * 1000.0f));

	frsky_send_data(uart, FRSKY_ID_BARO_ALT_BP,
			sensor_combined->baro_alt_meter[0]);
	frsky_send_data(uart, FRSKY_ID_BARO_ALT_AP,
			roundf(frac(sensor_combined->baro_alt_meter[0]) * 100.0f));

	frsky_send_data(uart, FRSKY_ID_TEMP1,
			roundf(sensor_combined->baro_temp_celcius[0]));

	frsky_send_data(uart, FRSKY_ID_VFAS,
			roundf(battery_status->voltage_v * 10.0f));
	frsky_send_data(uart, FRSKY_ID_CURRENT,
			(battery_status->current_a < 0) ? 0 : roundf(battery_status->current_a * 10.0f));

	frsky_send_startstop(uart);
}
コード例 #10
0
ファイル: dom_times.c プロジェクト: rplantiko/painters
// RAMC, zu der der Ekliptikpunkt der Länge l die mund. Pos. m erhält
double t_placidus(  double m, double ee, double l, double phi ) {
  double ascdiff,ra,d,a;
  ekq( ee, l, 0., &ra, &d);
  ascdiff = ad(d,phi);
  a = (m < 180) ? ((m - 90.)/90.) : ((m-270.)/90.);  
  return frac(ra-(m+a*ascdiff-270.),360.);
  }
コード例 #11
0
ファイル: frsky_data.c プロジェクト: 2013-8-15/Firmware
/**
 * Sends frame 2 (every 1000ms):
 *   GPS course, latitude, longitude, ground speed, GPS altitude, remaining battery level
 */
void frsky_send_frame2(int uart)
{
	/* send formatted frame */
	float course = 0, lat = 0, lon = 0, speed = 0, alt = 0;
	char lat_ns = 0, lon_ew = 0;
	int sec = 0;

	if (global_pos->timestamp != 0 && hrt_absolute_time() < global_pos->timestamp + 20000) {
		time_t time_gps = global_pos->time_utc_usec / 1000000ULL;
		struct tm *tm_gps = gmtime(&time_gps);

		course = (global_pos->yaw + M_PI_F) / M_PI_F * 180.0f;
		lat    = frsky_format_gps(fabsf(global_pos->lat));
		lat_ns = (global_pos->lat < 0) ? 'S' : 'N';
		lon    = frsky_format_gps(fabsf(global_pos->lon));
		lon_ew = (global_pos->lon < 0) ? 'W' : 'E';
		speed  = sqrtf(global_pos->vel_n * global_pos->vel_n + global_pos->vel_e * global_pos->vel_e)
			 * 25.0f / 46.0f;
		alt    = global_pos->alt;
		sec    = tm_gps->tm_sec;
	}

	frsky_send_data(uart, FRSKY_ID_GPS_COURS_BP, course);
	frsky_send_data(uart, FRSKY_ID_GPS_COURS_AP, frac(course) * 1000.0f);

	frsky_send_data(uart, FRSKY_ID_GPS_LAT_BP, lat);
	frsky_send_data(uart, FRSKY_ID_GPS_LAT_AP, frac(lat) * 10000.0f);
	frsky_send_data(uart, FRSKY_ID_GPS_LAT_NS, lat_ns);

	frsky_send_data(uart, FRSKY_ID_GPS_LONG_BP, lon);
	frsky_send_data(uart, FRSKY_ID_GPS_LONG_AP, frac(lon) * 10000.0f);
	frsky_send_data(uart, FRSKY_ID_GPS_LONG_EW, lon_ew);

	frsky_send_data(uart, FRSKY_ID_GPS_SPEED_BP, speed);
	frsky_send_data(uart, FRSKY_ID_GPS_SPEED_AP, frac(speed) * 100.0f);

	frsky_send_data(uart, FRSKY_ID_GPS_ALT_BP, alt);
	frsky_send_data(uart, FRSKY_ID_GPS_ALT_AP, frac(alt) * 100.0f);

	frsky_send_data(uart, FRSKY_ID_FUEL,
			roundf(battery_status->remaining * 100.0f));

	frsky_send_data(uart, FRSKY_ID_GPS_SEC, sec);

	frsky_send_startstop(uart);
}
コード例 #12
0
size_t map_count_to_color_historic(int cnt, int num_colors,
                                   const std::vector<int>& distribution,
                                   size_t total_pixles, double P, double Q) {
  auto u = static_cast<double>(distribution[cnt]) /
             static_cast<double>(total_pixles);
  u = frac(u * P + Q); // FRAC substracts the int part from the number
  return static_cast<size_t>(u * static_cast<double>(num_colors));
}
コード例 #13
0
ファイル: test_image.c プロジェクト: KelseyGeiger/PPM-Render
float interpolated_noise(float x, float y)
{
	int x_ = floor_i(x);
	int y_ = floor_i(y);
	
	float frac_x = frac(x);
	float frac_y = frac(y);
	
	float v1 = smooth_noise_2D(x_, y_);
	float v2 = smooth_noise_2D(x_ + 1, y_);
	float v3 = smooth_noise_2D(x_, y_ + 1);
	float v4 = smooth_noise_2D(x_ + 1, y_ + 1);
	
	float i1 = cos_interp(v1, v2, frac_x);
	float i2 = cos_interp(v3, v4, frac_x);
	
	return cos_interp(i1, i2, frac_y);
}
コード例 #14
0
ファイル: fw_draw.c プロジェクト: Comanche93/eech
void update_fixed_wing_sprite_light_timers (void)
{
	sprite_light_timer += (get_delta_time () * SPRITE_LIGHT_TIMER_FREQUENCY);

	if (sprite_light_timer >= 1.0)
	{
		sprite_light_timer = frac (sprite_light_timer);
	}
}
コード例 #15
0
ファイル: fraction.cpp プロジェクト: chaitanyav/cpp
int main(int argc, char *argv[]) {
  Fraction frac(8);
  Fraction frac2 = 5;
  frac = 9;
  frac = (Fraction) 7;
  frac = Fraction(6);
  frac = static_cast<Fraction>(6);
  frac = frac2.times(19);
  return 0;
}
コード例 #16
0
ファイル: frac.c プロジェクト: cawthorne/beebs
int benchmark()
{
  double error = 1.0e-10;
  int n,d,i;

  for(i = 0; i < 10; ++i)
    frac(nums[i], &n, &d, error);

  return n;
}
コード例 #17
0
ファイル: noise.cpp プロジェクト: BradWalker/Graphics
float noise(float x,float y,float z,int d)
{
  int x0,x1,x2,x3;
  int y0,y1,y2,y3;
  int z0,z1,z2,z3;
  float ox,oy,oz;
  float v0,v1,v2,v3;

  x+=1500; y+=1500; z+=1500;

  ox=frac(x); oy=frac(y); oz=frac(z);

  x0=((int)x+0)%MAX_NOISE;
  x1=((int)x+1)%MAX_NOISE;
  x2=((int)x+2)%MAX_NOISE;
  x3=((int)x+3)%MAX_NOISE;
  y0=((int)y+0)%MAX_NOISE;
  y1=((int)y+1)%MAX_NOISE;
  y2=((int)y+2)%MAX_NOISE;
  y3=((int)y+3)%MAX_NOISE;
  z0=((int)z+0)%MAX_NOISE;
  z1=((int)z+1)%MAX_NOISE;
  z2=((int)z+2)%MAX_NOISE;
  z3=((int)z+3)%MAX_NOISE;

  v0=Interpolate2D(noise_t[x0][y0][z0][d],noise_t[x1][y0][z0][d],noise_t[x2][y0][z0][d],noise_t[x3][y0][z0][d],
                   noise_t[x0][y1][z0][d],noise_t[x1][y1][z0][d],noise_t[x2][y1][z0][d],noise_t[x3][y1][z0][d],
                   noise_t[x0][y2][z0][d],noise_t[x1][y2][z0][d],noise_t[x2][y2][z0][d],noise_t[x3][y2][z0][d],
                   noise_t[x0][y3][z0][d],noise_t[x1][y3][z0][d],noise_t[x2][y3][z0][d],noise_t[x3][y3][z0][d],ox,oy);
  v1=Interpolate2D(noise_t[x0][y0][z1][d],noise_t[x1][y0][z1][d],noise_t[x2][y0][z1][d],noise_t[x3][y0][z1][d],
                   noise_t[x0][y1][z1][d],noise_t[x1][y1][z1][d],noise_t[x2][y1][z1][d],noise_t[x3][y1][z1][d],
                   noise_t[x0][y2][z1][d],noise_t[x1][y2][z1][d],noise_t[x2][y2][z1][d],noise_t[x3][y2][z1][d],
                   noise_t[x0][y3][z1][d],noise_t[x1][y3][z1][d],noise_t[x2][y3][z1][d],noise_t[x3][y3][z1][d],ox,oy);
  v2=Interpolate2D(noise_t[x0][y0][z2][d],noise_t[x1][y0][z2][d],noise_t[x2][y0][z2][d],noise_t[x3][y0][z2][d],
                   noise_t[x0][y1][z2][d],noise_t[x1][y1][z2][d],noise_t[x2][y1][z2][d],noise_t[x3][y1][z2][d],
                   noise_t[x0][y2][z2][d],noise_t[x1][y2][z2][d],noise_t[x2][y2][z2][d],noise_t[x3][y2][z2][d],
                   noise_t[x0][y3][z2][d],noise_t[x1][y3][z2][d],noise_t[x2][y3][z2][d],noise_t[x3][y3][z2][d],ox,oy);
  v3=Interpolate2D(noise_t[x0][y0][z3][d],noise_t[x1][y0][z3][d],noise_t[x2][y0][z3][d],noise_t[x3][y0][z3][d],
                   noise_t[x0][y1][z3][d],noise_t[x1][y1][z3][d],noise_t[x2][y1][z3][d],noise_t[x3][y1][z3][d],
                   noise_t[x0][y2][z3][d],noise_t[x1][y2][z3][d],noise_t[x2][y2][z3][d],noise_t[x3][y2][z3][d],
                   noise_t[x0][y3][z3][d],noise_t[x1][y3][z3][d],noise_t[x2][y3][z3][d],noise_t[x3][y3][z3][d],ox,oy);
  return Interpolate1D(v0,v1,v2,v3,oz);
}
コード例 #18
0
ファイル: test_image.c プロジェクト: KelseyGeiger/PPM-Render
ColorRGB color_field(Point2D point)
{
	ColorRGB colors[] = {
		rgb(0, 0, 64),
		rgb(128, 0, 128),
		rgb(128, 0, 255),
		rgb(128, 64, 255),
		rgb(64, 64, 255),
		rgb(0, 128, 255),
		rgb(0, 192, 255),
		rgb(0, 255, 255),
		rgb(0, 255, 128),
		rgb(0, 255, 64),
		rgb(64, 255, 64),
		rgb(64, 255, 0),
		rgb(128, 255, 0),
		rgb(255, 255, 0),
		rgb(255, 128, 0),
		rgb(128, 0, 0),
		rgb(255, 0, 0),
		rgb(255, 64, 64),
		rgb(255, 128, 128),
		rgb(255, 192, 192),
		rgb(255, 255, 255)
	};
	
	float color_percent = Perlin2D(point.x, point.y, 0.5, 10);
	
	if(color_percent < 0) {
		color_percent = 0.0f;
	}
	
	if(color_percent > 1) {
		color_percent = 1.0f;
	}
	
	color_percent *= ((sizeof(colors) / sizeof(colors[0])) - 1);
	
	int rounded = round_i(color_percent);
	float alpha = frac(color_percent);
	
	int bg, fg;
	
	if(alpha > 0.5) {
		bg = rounded - 1;
		fg = rounded;
		alpha = 1.0f - alpha;
	} else {
		bg = rounded;
		fg = rounded + 1;
	}
	
	return blend(colors[bg], colors[fg], alpha);
}
コード例 #19
0
ファイル: dom_times.c プロジェクト: rplantiko/painters
// RAMC, zu der der Ekliptikpunkt der Länge l die mund. Pos. m erhält
double t_koch(  double m, double ee, double l, double phi ) {
  int ostpunkt,i;
  double admc,t,t0,ascdiff,ra,d,a,_oa;
  m = frac(m,360.); // Wert auf 0-360 reduzieren
  ostpunkt = (fabs(ArcDiff(m,0))<90.); 
  ekq( ee, l, 0., &ra, &d);
// Hilfsfaktor a  
  a = ostpunkt ? (m/90.) : (m/90.-2.);
// Für Ostpunkte OA, für Westpunkte OD berechnen  
  _oa = oa( ra, d, (ostpunkt ? phi : -phi) );
// Iterativ Formel (58) auflösen
  t0 = frac( (_oa - 90 - m), 360. );
  for (i = 0; i<1000; i++) {
    admc = asn(t1(ee)*t1(phi)*s1(t0));
    t =  frac( (_oa - 90 - m - a*admc), 360. ); 
    if (ArcDiff(t,t0)<PREC) break;
    t0 = frac(t,360.);
    }      
  return frac(t,360.);
  }
コード例 #20
0
ファイル: box_orthorhombic.cpp プロジェクト: trisyoungs/duq
// Return folded fractional coordinate (i.e. inside current Box)
Vec3<double> OrthorhombicBox::foldFrac(const Vec3<double>& r) const
{
	// Convert coordinate to fractional coords
	Vec3<double> frac(r.x*ra_, r.y*rb_, r.z*rc_);
	
	// Fold into Box and divide by integer Cell sizes
	frac.x -= floor(frac.x);
	frac.y -= floor(frac.y);
	frac.z -= floor(frac.z);
	return frac;
}
コード例 #21
0
/**
* @brief Perform a single source of the BC calculation per Brandes.
*
* Note that this follows the approach suggested by Green and Bader in which
* parent lists are not maintained, but instead the neighbors are searched
* to rediscover parents.
*
* Note also that found count will not include the source and that increments
* to this array are handled atomically.
*
* Operations to the bc array are NOT ATOMIC
*
* @param S The STINGER graph
* @param nv The maximum vertex ID in the graph plus one.
* @param source The vertex from where this search will start.
* @param bc The array into which the partial BCs will be added.
* @param found_count  An array to track how many times a vertex is found for normalization.
*/
void
single_bc_search(stinger_t * S, int64_t nv, int64_t source, double * bc, int64_t * found_count)
{
  int64_t * paths = (int64_t * )xcalloc(nv * 2, sizeof(int64_t));
  int64_t * q = paths + nv;
  double * partial = (double *)xcalloc(nv, sizeof(double));

  int64_t * d = (int64_t *)xmalloc(nv * sizeof(int64_t));
  for(int64_t i = 0; i < nv; i ++) d[i] = -1;

  int64_t q_front = 1;
  int64_t q_rear = 0;
  q[0] = source;
  d[source] = 0;
  paths[source] = 1;

  while(q_rear != q_front) {
    int64_t v = q[q_rear++];
    int64_t d_next = d[v] + 1;

    STINGER_FORALL_EDGES_OF_VTX_BEGIN(S, v) {

      if(d[STINGER_EDGE_DEST] < 0) {
	d[STINGER_EDGE_DEST]     = d_next;
	paths[STINGER_EDGE_DEST] = paths[v];
	q[q_front++]             = STINGER_EDGE_DEST;

	stinger_int64_fetch_add(found_count + STINGER_EDGE_DEST, 1);
      }

      else if(d[STINGER_EDGE_DEST] == d_next) {
	paths[STINGER_EDGE_DEST] += paths[v];
      }

    } STINGER_FORALL_EDGES_OF_VTX_END();
  }

  /* don't process source */
  while(q_front > 1) {
    int64_t w = q[--q_front];

    /* don't maintain parents, do search instead */
    STINGER_FORALL_EDGES_OF_VTX_BEGIN(S, w) {
      if(d[STINGER_EDGE_DEST] == (d[w] - 1)) {
	partial[STINGER_EDGE_DEST] += frac(paths[STINGER_EDGE_DEST],paths[w]) * (1 + partial[w]);
      }
    } STINGER_FORALL_EDGES_OF_VTX_END();
    bc[w] += partial[w];
  }

  free(d);
  free(partial);
  free(paths);
}
コード例 #22
0
ファイル: texture2d.cpp プロジェクト: nyue/embree
inline Vec2i nearest_coords(const Texture2D *self, const Vec2f p)
{
  // repeat: get remainder within [0..1] parameter space
  Vec2f tc = frac(p);
  tc = max(tc, Vec2f(0.0f)); // filter out inf/NaN

  // scale by texture size
  tc = tc * self->sizef;

  // nearest
  return Vec2i(tc);
}
コード例 #23
0
ファイル: mainloop.cpp プロジェクト: OS2World/APP-MATH-Euler
int frac_out0 (double x)
{   long n,d;
	if (x==0.0) output1hold(-1,"0");
	else
	{	if (frac(fabs(x),&n,&d,fraceps)<0) return 0;
		if (x<0) output1hold(-1,"-");
		else output1hold(-1,"");
		if (d>1) output1hold(-1,"%ld/%ld",n,d);
		else output1hold(-1,"%ld",n);
	}
	return 1;
}
コード例 #24
0
size_t map_count_to_color(int cnt, int min, int max, int num_colors,
                          double P, double Q) {
  auto cnt_d = static_cast<double>(cnt);
  auto min_d = static_cast<double>(min);
  auto max_d = static_cast<double>(max);
//  auto u = (cnt_d - min_d) / (max_d - min_d);                         // linear
//  auto u = (sqrt(cnt_d) - sqrt(min_d)) / (sqrt(max_d) - sqrt(min_d)); // sqrt
  auto u = (cbrt(cnt_d) - cbrt(min_d)) / (cbrt(max_d) - cbrt(min_d)); // cbrt
//  auto u = (log(cnt_d) - log(min_d)) / (log(max_d) - log(min_d));     // log
//  auto u = (log(cnt_d / min_d)) / (log(max_d / min_d));               // log
  u = frac(u * P + Q);
  return static_cast<size_t>(u * static_cast<double>(num_colors));
}
コード例 #25
0
ファイル: SunRise.c プロジェクト: tebrown/wxpro
double SinH(int year, int month, int day, double UT){

    double	TU0, TU, TU2, TU3, LambdaMoon, BetaMoon, R, AGE, frac(), jd();
    double	RA_Sun, DEC_Sun, T0, gmst, lmst, Tau, epsilon;
    double	M, DL, L, SL, X, Y, Z, RHO;
    

    TU0 = (jd(year, month, day, 0.0) - 2451545.0)/36525.0;

    TU = (jd(year, month, day, UT+62.0/3600.0) - 2451545.0)/36525.0;
    TU2 = TU*TU;
    TU3 = TU2*TU;

    M = P2*frac(0.993133 + 99.997361*TU);
    DL = 6893.0*sin(M) + 72.0*sin(2.0*M);
    L = P2*frac(0.7859453 + M/P2 + (6191.2*TU+DL)/1296e3);
    SL = sin(L);
    X = cos(L); Y = cosEPS*SL; Z = sinEPS*SL; RHO = sqrt(1.0-Z*Z);
    DEC_Sun = atan2(Z, RHO);
    RA_Sun = (48.0/P2)*atan(Y/(X+RHO));
    if (RA_Sun < 0) RA_Sun += 24.0;

    RA_Sun = RA_Sun*15.0*RadPerDeg;

    /*
     *  Compute Greenwich Mean Sidereal Time (gmst)
     */
    UT = 24.0*frac( UT/24.0 );
/*
    gmst = 6.697374558 + 1.0027379093*UT + (8640184.812866*TU0 +(0.093104-6.2e-6*TU)*TU2)/3600.0;
*/
    gmst = 6.697374558 + 1.0*UT + (8640184.812866+(0.093104-6.2e-6*TU)*TU)*TU/3600.0;
    lmst = 24.0*frac( (gmst-Glon/15.0) / 24.0 );

    Tau = 15.0*lmst*RadPerDeg - RA_Sun;
    return( SinGlat*sin(DEC_Sun) + CosGlat*cos(DEC_Sun)*cos(Tau) );


}
コード例 #26
0
int main(){
	float num, fra;
	int inteiro;

	printf("Insira o numero\n");
	scanf("%f", &num);
	
	frac(num, &inteiro, &fra);
	
	printf("Parte inteira: %d, parte fracionaria: %f\n", inteiro, fra);
	
	return 1;
}
コード例 #27
0
const char *doubleexp(RooWorkspace *wspace, RooRealVar &x,std::string ext = ""){ 
   // Double exponential model
   RooRealVar frac(Form("f_%s",ext.c_str()),"f",0.9,0.,1.);
   RooRealVar m1(Form("m1_%s",ext.c_str()),"m1",-0.02,-0.2,0.);
   RooRealVar m2(Form("m2_%s",ext.c_str()),"m2",-0.01,-0.2,0.);

   RooExponential exp1(Form("exp1_%s",ext.c_str()),Form("exp1_%s",ext.c_str()),x,m1);
   RooExponential exp2(Form("exp2_%s",ext.c_str()),Form("exp2_%s",ext.c_str()),x,m2);

   RooAddPdf *sumexp = new RooAddPdf(Form("doubleExponential_%s",ext.c_str()), Form("doubleExponential_%s",ext.c_str()),RooArgList(exp1,exp2),RooArgList(frac));
   wspace->import(*sumexp);
   return sumexp->GetName(); 
}
コード例 #28
0
ファイル: MoonRise.c プロジェクト: cneira/dockapps
double SinH(int year, int month, int day, double UT) {

    double	TU, frac(), jd();
    double	RA_Moon, DEC_Moon, gmst, lmst, Tau, Moon();
    double	angle2pi();

    TU = (jd(year, month, day, UT) - 2451545.0)/36525.0;

    /* this is more accurate, but wasteful for this -- use low res approx.
    TU2 = TU*TU;
    TU3 = TU2*TU;
    Moon(TU, &LambdaMoon, &BetaMoon, &R, &AGE);
    LambdaMoon *= RadPerDeg;
    BetaMoon *= RadPerDeg;
    epsilon = (23.43929167 - 0.013004166*TU - 1.6666667e-7*TU2 - 5.0277777778e-7*TU3)*RadPerDeg;
    RA_Moon  = angle2pi(atan2(sin(LambdaMoon)*cos(epsilon)-tan(BetaMoon)*sin(epsilon), cos(LambdaMoon)));
    DEC_Moon = asin( sin(BetaMoon)*cos(epsilon) + cos(BetaMoon)*sin(epsilon)*sin(LambdaMoon));
    */

    MiniMoon(TU, &RA_Moon, &DEC_Moon);
    RA_Moon *= 15.0*RadPerDeg;
    DEC_Moon *= RadPerDeg;

    /*
     *  Compute Greenwich Mean Sidereal Time (gmst)
     */
    UT = 24.0*frac( UT/24.0 );
    /* this is for the ephemeris meridian???
    gmst = 6.697374558 + 1.0027379093*UT + (8640184.812866+(0.093104-6.2e-6*TU)*TU)*TU/3600.0;
    */
    gmst = UT + 6.697374558 + (8640184.812866+(0.093104-6.2e-6*TU)*TU)*TU/3600.0;
    lmst = 24.0*frac( (gmst-Glon/15.0) / 24.0 );

    Tau = 15.0*lmst*RadPerDeg - RA_Moon;
    return( SinGlat*sin(DEC_Moon) + CosGlat*cos(DEC_Moon)*cos(Tau) );


}
コード例 #29
0
ファイル: sampler_state.cpp プロジェクト: HenrYxZ/GraphicsII
float4 __CGsampler_state::minify(int ndx, float4 strq, float1 lod)
{
    assert(lod > 0);  // Otherwise should be in minify
    switch (minFilter) {
    default:
        assert(!"unexpected minification filter");
    case GL_NEAREST:
        return nearestFilter(trueBaseLevel, strq);
    case GL_NEAREST_MIPMAP_NEAREST:
        {
            int level = clamp(int1(trueBaseLevel + round(lod)), trueBaseLevel, effectiveMaxLevel);
            return nearestFilter(level, strq);
        }
    case GL_LINEAR_MIPMAP_NEAREST:
        {
            int level = clamp(int1(trueBaseLevel + round(lod)), trueBaseLevel, effectiveMaxLevel);
            return linearFilter(level, strq);
        }
    case GL_NEAREST_MIPMAP_LINEAR:
        {
            int level0 = max(trueBaseLevel + int(floor(lod)), effectiveMaxLevel);
            int level1 = max(level0 + 1, effectiveMaxLevel);
            float4 tex0 = nearestFilter(level0, strq);
            float4 tex1 = nearestFilter(level1, strq);
            return lerp(tex0, tex1, frac(lod));
        }
    case GL_LINEAR_MIPMAP_LINEAR:
        {
            int level0 = max(trueBaseLevel + int(floor(lod)), effectiveMaxLevel);
            int level1 = max(level0 + 1, effectiveMaxLevel);
            float4 tex0 = linearFilter(level0, strq);
            float4 tex1 = linearFilter(level1, strq);
            return lerp(tex0, tex1, frac(lod));
        }
    case GL_LINEAR:
        return linearFilter(trueBaseLevel, strq);
    }
}
コード例 #30
-2
ファイル: draw.c プロジェクト: ushmal/ugl
void line(struct fb *dst, int x0, int y0, int x1, int y1, int cl)
{
	int len;
	fixed x, y, dx, dy;

	len = imax(iabs(x1 - x0), iabs(y1 - y0));
	if(!len) {
		putpixel(dst, x0, y0, cl);
		return;
	}
	x = itofix(x0);
	y = itofix(y0);
	dx = frac(x1 - x0, len);
	dy = frac(y1 - y0, len);

	for(; len >= 0; len--) {
		putpixel(dst, fixtoi(x), fixtoi(y), cl);
		x += dx;
		y += dy;
	}
}