void PrayerTimes::compute_times(double times[])
{
day_portion(times);
times[Parameters::Fajr] = compute_time(180.0 - method_params[calc_method].fajr_angle, times[Parameters::Fajr]);
times[Parameters::Sunrise] = compute_time(180.0 - 0.833, times[Parameters::Sunrise]);
times[Parameters::Dhuhr] = compute_mid_day(times[Parameters::Dhuhr]);
times[Parameters::Asr] = compute_asr(1 + asr_juristic, times[Parameters::Asr]);
times[Parameters::Sunset] = compute_time(0.833, times[Parameters::Sunset]);
times[Parameters::Maghrib] = compute_time(method_params[calc_method].maghrib_value, times[Parameters::Maghrib]);
times[Parameters::Isha] = compute_time(method_params[calc_method].isha_value, times[Parameters::Isha]);
}
/* compute prayer times at given julian date */
void compute_times(double times[])
{
day_portion(times);
times[Fajr] = compute_time(180.0 - method_params[calc_method].fajr_angle, times[Fajr]);
times[Sunrise] = compute_time(180.0 - 0.833, times[Sunrise]);
times[Dhuhr] = compute_mid_day(times[Dhuhr]);
times[Asr] = compute_asr(1 + asr_juristic, times[Asr]);
times[Sunset] = compute_time(0.833, times[Sunset]);
times[Maghrib] = compute_time(method_params[calc_method].maghrib_value, times[Maghrib]);
times[Isha] = compute_time(method_params[calc_method].isha_value, times[Isha]);
}
void loop() {
while (running) {
compute_time();
handle_input();
draw();
}
}
Timespec
gncBillTermComputeDiscountDate (const GncBillTerm *term, Timespec post_date)
{
Timespec res = post_date;
if (!term) return res;
return compute_time (term, post_date, term->disc_days);
}
/* compute the time of Asr */
double compute_asr(int step, double t) // Shafii: step=1, Hanafi: step=2
{
double d = sun_declination(julian_date + t);
double g = -darccot(step + dtan(fabs(latitude - d)));
return compute_time(g, t);
}
double PrayerTimes::compute_asr(int step, double t) // Shafii: step=1, Hanafi: step=2
{
double d = sun_declination(julian_date + t);
double g = -TrigHelper::darccot(step + TrigHelper::dtan(fabs(latitude - d)));
return compute_time(g, t);
}
int main(void) {
SDL_Surface *screen;
SDL_Surface *frame_buf;
SDL_Event evt;
MulticastDestination dest;
Picture *in_frame;
Picture *png = Picture::from_png("hockey_clock.png");
fixed_png = png->convert_to_format(RGB8);
Picture::free(png);
unsigned int digit_being_initialized = 0;
unsigned int segment_being_initialized = 0;
enum { RUNNING, SETUP_DIGITS } mode = SETUP_DIGITS;
struct digit digits[N_DIGITS];
memset(digits, 0, sizeof(digits));
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) != 0) {
fprintf(stderr, "Failed to initialize SDL!\n");
return 1;
}
screen = SDL_SetVideoMode(320, 240, 24, SDL_HWSURFACE | SDL_DOUBLEBUF);
if (!screen) {
fprintf(stderr, "Failed to create frame buffer!\n");
SDL_Quit( );
return 1;
}
frame_buf = SDL_CreateRGBSurface(SDL_HWSURFACE, 320, 240, 24, 0xff, 0xff00, 0xff0000, 0);
if (!frame_buf) {
fprintf(stderr, "Failed to create frame buffer!\n");
SDL_Quit( );
return 1;
}
for (;;) {
/* read frame */
in_frame = read_image( );
/* draw frame on screen */
blit_picture_to_sdl(in_frame, frame_buf);
Picture::free(in_frame);
if (mode == RUNNING) {
/* do processing */
dest.send(compute_time(in_frame, digits));
} else if (mode == SETUP_DIGITS) {
/* overlay the segment positions selected */
overlay_segments(frame_buf, &digits[digit_being_initialized]);
draw_box(frame_buf, 2, 317, &seg_colors[segment_being_initialized]);
draw_box(frame_buf, 7, 317, &seg_colors[segment_being_initialized]);
}
SDL_BlitSurface(frame_buf, NULL, screen, NULL);
SDL_Flip(screen);
if (SDL_PollEvent(&evt)) {
if (evt.type == SDL_KEYDOWN) {
switch (evt.key.keysym.sym) {
/* keyboard handling */
case SDLK_ESCAPE:
goto end;
case SDLK_s:
digit_being_initialized = 0;
segment_being_initialized = 0;
mode = SETUP_DIGITS;
break;
case SDLK_r:
mode = RUNNING;
break;
case SDLK_n:
digit_being_initialized++;
if (digit_being_initialized == N_DIGITS) {
digit_being_initialized = 0;
}
default:
break;
}
} else if (evt.type == SDL_MOUSEBUTTONDOWN) {
if (mode == SETUP_DIGITS) {
digits[digit_being_initialized]
.segment_pos[segment_being_initialized].x
= evt.button.x;
digits[digit_being_initialized]
.segment_pos[segment_being_initialized].y
= evt.button.y;
segment_being_initialized++;
if (segment_being_initialized == 7) {
segment_being_initialized = 0;
}
}
}
}
}
end:
SDL_FreeSurface(screen);
SDL_Quit( );
}
time64
gncBillTermComputeDueDate (const GncBillTerm *term, time64 post_date)
{
if (!term) return post_date;
return compute_time (term, post_date, term->due_days);
}
/****************************************************************
* Name : main *
* Function: main function *
* Input : argc, argv *
* Output : void *
* The usage of the rock program should be of the *
* form: *
* chameleon N fileName stopClusterNO *
* Each parameter's meanning is : *
* chameleon -- program's name *
* int N -- how many data points does the file has *
* string fileName -- indicate the data file *
* name which *
* contains all the data vectors. *
* int stopClusterNO -- number of remaining clusters *
* at the end of clustering. *
****************************************************************/
int main(int argc, char * argv[]) {
struct node * left;
struct node * right;
int i;
if(gettimeofday(&time_start, NULL)<0)
{
printf("time error \n");
return -1;
}
printf("ALPHA is %f \n", ALPHA);
/* parse the command line */
if (parsingInput(argc, argv)<0)
{
return -1;
}
/* read in data file */
if ( readData()<0 )
{
fclose(fp);
return -1;
}
/* close read in data file */
fclose(fp);
/* for debugging purpose */
/* printData(); */
/* initialize data structure */
if ( initialize()<0 )
{
return -1;
}
/* establish hyperGraph */
if (establish_hyperGraph()<0)
{
return -1;
}
/* Now begin partition */
left = (struct node *)calloc(1, sizeof(struct node));
if(left == NULL)
{
printf("cannot allocate memory for left! \n");
return -1;
}
right = (struct node *)calloc(1, sizeof(struct node));
if(right == NULL)
{
printf("cannot allocate memory for right! \n");
return -1;
}
/* begin partitionning, this is a recursive program */
if(partition(root, left, right)<0)
{
printf("partition error! \n");
return -1;
}
if(phase2()<0)
{
printf("phase2 error! \n");
return -1;
}
if(clusterResult()<0)
{
fclose(out_fp);
printf("clusterResult error! \n");
return -1;
}
fclose(out_fp);
for(i=0; i<groupIndex; i++)
{
free(groups[i]);
groups[i] = NULL;
}
if(gettimeofday(&time_end, NULL)<0){
printf("time error \n");
return -1;
}
/* Now compute the time for sequential sorting */
time_period = compute_time(time_start, time_end);
printf("time spend is : %d \n", time_period);
return 1;
}/* end main */
