void quicksort(int * a)
{
quick(a, 0, N-1);
}
int
main(int argc, char *argv[])
{
int ch;
setlocale(LC_TIME, "");
while ((ch = getopt(argc, argv, "HTabmqsu")) != -1) {
switch (ch) {
case 'H': /* Write column headings */
Hflag = 1;
break;
case 'T': /* Show terminal state */
Tflag = 1;
break;
case 'a': /* Same as -bdlprtTu */
aflag = bflag = Tflag = uflag = 1;
break;
case 'b': /* Show date of the last reboot */
bflag = 1;
break;
case 'm': /* Show info about current terminal */
mflag = 1;
break;
case 'q': /* "Quick" mode */
qflag = 1;
break;
case 's': /* Show name, line, time */
sflag = 1;
break;
case 'u': /* Show idle time */
uflag = 1;
break;
default:
usage();
/*NOTREACHED*/
}
}
argc -= optind;
argv += optind;
if (argc >= 2 && strcmp(argv[0], "am") == 0 &&
(strcmp(argv[1], "i") == 0 || strcmp(argv[1], "I") == 0)) {
/* "who am i" or "who am I", equivalent to -m */
mflag = 1;
argc -= 2;
argv += 2;
}
if (argc > 1)
usage();
if (*argv != NULL) {
if (setutxdb(UTXDB_ACTIVE, *argv) != 0)
err(1, "%s", *argv);
}
if (qflag)
quick();
else {
if (sflag)
Tflag = uflag = 0;
if (Hflag)
heading();
if (mflag)
whoami();
else
process_utmp();
}
endutxent();
exit(0);
}
void read_scene(FILE* fp, int version)
{
if (version > -1 || version < -2)
error("Scene file version %d is not supported", version);
fread(&number_of_cameras, sizeof(int), 1, fp);
if (number_of_cameras)
{
cameras = new OBJECT_3D_SCENE_CAMERA_INFO[number_of_cameras];
for (int camera_count = 0; camera_count < number_of_cameras; camera_count++)
{
cameras[camera_count].camera_name_index = get_camera(fp);
cameras[camera_count].camera_index = read_new_camera(fp);
}
}
else
cameras = NULL;
fread(&number_of_scene_link_objects, sizeof(int), 1, fp);
if (number_of_scene_link_objects)
{
scene_link_objects = new OBJECT_3D_SCENE_LINK_OBJECT [number_of_scene_link_objects];
for (int tmp = 0; tmp < number_of_scene_link_objects; tmp++)
{
scene_link_objects[tmp].scene_index = get_scene(fp);
fread(&scene_link_objects[tmp].x, sizeof(float), 1, fp);
fread(&scene_link_objects[tmp].y, sizeof(float), 1, fp);
fread(&scene_link_objects[tmp].z, sizeof(float), 1, fp);
fread(&scene_link_objects[tmp].heading, sizeof(float), 1, fp);
fread(&scene_link_objects[tmp].pitch, sizeof(float), 1, fp);
fread(&scene_link_objects[tmp].roll, sizeof(float), 1, fp);
}
}
else
scene_link_objects = NULL;
fread(&number_of_sprite_lights, sizeof(int), 1, fp);
number_of_sprite_lights = number_of_sprite_lights;
sprite_lights = NULL;
if (number_of_sprite_lights)
{
sprite_lights = new OBJECT_3D_SPRITE_LIGHT[number_of_sprite_lights];
for (int tmp = 0; tmp < number_of_sprite_lights; tmp++)
{
int red, green, blue;
fread(&sprite_lights[tmp].position.x, sizeof(float), 1, fp);
fread(&sprite_lights[tmp].position.y, sizeof(float), 1, fp);
fread(&sprite_lights[tmp].position.z, sizeof(float), 1, fp);
fread(&sprite_lights[tmp].scale.x, sizeof(float), 1, fp);
fread(&sprite_lights[tmp].scale.y, sizeof(float), 1, fp);
fread(&sprite_lights[tmp].scale.z, sizeof(float), 1, fp);
fread(&red, sizeof(int), 1, fp);
fread(&green, sizeof(int), 1, fp);
fread(&blue, sizeof(int), 1, fp);
sprite_lights[tmp].colour.red = red;
sprite_lights[tmp].colour.green = green;
sprite_lights[tmp].colour.blue = blue;
}
}
if (version <= -2)
fread(&number_of_ambient_lights, sizeof(int), 1, fp);
else
number_of_ambient_lights = 0;
ambient_lights = NULL;
if (number_of_ambient_lights)
{
ambient_lights = new OBJECT_3D_AMBIENT_LIGHT[number_of_ambient_lights];
for (int tmp = 0; tmp < number_of_ambient_lights; tmp++)
{
fread(&ambient_lights[tmp].colour.red, sizeof(float), 1, fp);
fread(&ambient_lights[tmp].colour.green, sizeof(float), 1, fp);
fread(&ambient_lights[tmp].colour.blue, sizeof(float), 1, fp);
ambient_lights[tmp].light_index = get_light(fp);
}
}
if (version <= -2)
fread(&number_of_distant_lights, sizeof(int), 1, fp);
else
number_of_distant_lights = 0;
distant_lights = NULL;
if (number_of_distant_lights)
{
distant_lights = new OBJECT_3D_DISTANT_LIGHT[number_of_distant_lights];
for (int tmp = 0; tmp < number_of_distant_lights; tmp++)
{
fread(&distant_lights[tmp].heading, sizeof(float), 1, fp);
fread(&distant_lights[tmp].pitch, sizeof(float), 1, fp);
fread(&distant_lights[tmp].roll, sizeof(float), 1, fp);
fread(&distant_lights[tmp].colour.red, sizeof(float), 1, fp);
fread(&distant_lights[tmp].colour.green, sizeof(float), 1, fp);
fread(&distant_lights[tmp].colour.blue, sizeof(float), 1, fp);
distant_lights[tmp].light_index = get_light(fp);
}
}
fread(&total_number_of_sub_objects, sizeof(int), 1, fp);
fread(&total_number_of_sub_object_indices, sizeof(int), 1, fp);
if (total_number_of_sub_object_indices)
current_scene_sub_object_index_array = new OBJECT_3D_SUB_OBJECT_INDEX[total_number_of_sub_object_indices];
else
current_scene_sub_object_index_array = NULL;
if (total_number_of_sub_objects)
current_scene_sub_object_array = new OBJECT_3D_DATABASE_ENTRY[total_number_of_sub_objects];
else
current_scene_sub_object_array = NULL;
scene_sub_object_indices_array = current_scene_sub_object_index_array;
scene_sub_object_array = current_scene_sub_object_array;
fread(&number_of_texture_animations, sizeof(int), 1, fp);
if (number_of_texture_animations)
{
texture_animations = new int[number_of_texture_animations];
for (int tmp = 0; tmp < number_of_texture_animations; tmp++)
fread(&texture_animations[tmp], sizeof(int), 1, fp);
}
else
texture_animations = NULL;
fread(&number_of_approximations, sizeof(int), 1, fp);
index = get_object(fp);
if (number_of_approximations)
{
approximations = new OBJECT_3D_APPROXIMATION_INFO[number_of_approximations];
for (int approximation = 0; approximation < number_of_approximations; approximation++)
{
approximations[approximation].object_number = get_object(fp);
fread(&approximations[approximation].distance, sizeof(float), 1, fp);
}
}
fread(&shadow_approximation_index, sizeof(int), 1, fp);
shadow_polygon_object_index = get_object(fp);
fread(&shadow_polygon_object_scale.x, sizeof(float), 1, fp);
fread(&shadow_polygon_object_scale.y, sizeof(float), 1, fp);
fread(&shadow_polygon_object_scale.z, sizeof(float), 1, fp);
collision_object_index = get_object(fp);
if (!collision_object_index)
collision_object_index = -1;
read_keyframes(fp, &number_of_keyframes, &keyframes);
fseek(fp, sizeof(float), SEEK_CUR);
read_value_keyframes(fp, &number_of_object_dissolve_keyframes, &object_dissolve_keyframes);
read_value_keyframes(fp, &number_of_displacement_amplitude_keyframes, &displacement_amplitude_keyframes);
read_indices(fp, &number_of_sub_object_indices, &sub_object_indices);
read_subobjects(fp, &number_of_sub_objects, &sub_objects, NULL);
QuickSearch quick(*this);
}
void sort(int **a,int big,int small)
{
int i,j;
for(i=0;i<=big-1;i++) quick(a[i],0,100000-1);
quick(a[big],0,small);
}
int main ( int argc, const char *argv[] )
{
int *b,*q,n;
clock_t t;
//int i,j;
//struct timeval inicio, final;
//int tmili;
scanf ( "%d", &n );
// cria um vetor desordenado
b=create_vec_rand(n);
t = clock();
bubblesort(b,n);
t = clock()-1;
printf ( "tempo - bubblesort - vetor desordenado: %lf\n", ((double)t)/((CLOCKS_PER_SEC/1000)) );
/*
//print_vec(n,b);
gettimeofday(&inicio, NULL);
bubblesort (b,n); // funcao para organizar vetor desordenado
for ( j = 0; j < 10; j++ )
for ( i = 0; i < 1387634340; i++ );
gettimeofday(&final, NULL);
tmili = (int) (1000 * (final.tv_sec - inicio.tv_sec) + (final.tv_usec - inicio.tv_usec) / 1000);
// imprime o tempo decorrido
printf ( "tempo - bubblesort - vetor desordenado: %d\n", tmili );
*/
t = clock();
bubblesort(b,n);
t = clock()-1;
printf ( "tempo - bubblesort - vetor ordenado: %lf\n", ((double)t)/((CLOCKS_PER_SEC/1000)) );
/*
//print_vec(n,b);
gettimeofday(&inicio,NULL);
bubblesort(b,n); // chama novamente a funcao para um vetor ja ordenado
for ( j = 0; j < 10; j++ )
for ( i = 0; i < 1387634340; i++ );
gettimeofday(&final, NULL);
tmili = (int) (1000 * (final.tv_sec - inicio.tv_sec) + (final.tv_usec - inicio.tv_usec) / 1000);
// imprime o tempo decorrido
printf ( "tempo - bubblesort - vetor ordenado: %d\n", tmili );
//print_vec(n,b);
*/
free(b);
// cria um vetor desordenado
q=create_vec_rand(n);
t = clock();
quick(q,0,n-1);
t = clock()-1;
printf ( "tempo - quicksort - vetor desordenado: %lf\n", ((double)t)/((CLOCKS_PER_SEC/1000)) );
/*
//print_vec(n,q);
gettimeofday(&inicio,NULL);
quick(q,0,n-1); // chama a funcao quick para organizar o vetor desordenado
for ( j = 0; j < 10; j++ )
for ( i = 0; i < 1387634340; i++ );
gettimeofday(&final, NULL);
tmili = (int) (1000 * (final.tv_sec - inicio.tv_sec) + (final.tv_usec - inicio.tv_usec) / 1000);
// imprime o tempo decorrido
printf ( "tempo - quicksort - vetor desordenado: %d\n", tmili );
//print_vec(n,q);
*/
t = clock();
quick(q,0,n-1);
t = clock()-1;
printf ( "tempo - quicksort - vetor ordenado: %lf\n", ((double)t)/((CLOCKS_PER_SEC/1000)) );
/*
gettimeofday(&inicio, NULL);
quick(q,0,n-1); // chama novamente a funcao para um vetor ja ordenado
for ( j = 0; j < 10; j++ )
for ( i = 0; i < 1387634340; i++ );
gettimeofday(&final, NULL);
tmili = (int) (1000 * (final.tv_sec - inicio.tv_sec) + (final.tv_usec - inicio.tv_usec) / 1000);
printf ( "tempo - quicksort - vetor ordenado: %d\n", tmili );
//print_vec(n,q);
*/
free(q);
return 0;
}
/* sort - sort a[0..n-1] into increasing order */
void sort(int a[], int n)
{
quick(xx = a, 0, --n);
}
int main(void) {
int debug = 0; // 実行速度を表示する場合は1にする。提出時は0にすること。
int *a = NULL, *b = NULL, *c = NULL, *d = NULL, *e = NULL;
int seed;
int i;
clock_t start, end;
a = calloc(N, sizeof(int));
b = calloc(N, sizeof(int));
c = calloc(N, sizeof(int));
d = calloc(N, sizeof(int));
e = calloc(N, sizeof(int));
if (a == NULL || b == NULL || c == NULL || d == NULL || e == NULL) {
if (a == NULL) free(a);
if (b == NULL) free(b);
if (c == NULL) free(c);
if (d == NULL) free(d);
if (e == NULL) free(e);
return -1;
}
printf("Input a integer: ");
scanf("%d", &seed);
srand(seed);
for (i = 0; i < N; i++) {
a[i] = b[i] = c[i] = d[i] = e[i] = rand() % 100000;
}
// ソート前の配列を表示したい場合は、次の1行のコメントを外す
//printarray("orig : ", a, N);
start = clock();
quickest(e, 0, N - 1);
end = clock();
printarray("result: ", e, N);
if (debug) printf("%lf sec, ", (double)(end - start)/CLOCKS_PER_SEC);
//debug=1の時実行速度を比較
if(debug){
start = clock();
quick(a, 0, N - 1);
end = clock();
if (debug) printf("%lf sec, ", (double)(end - start)/CLOCKS_PER_SEC);
start = clock();
quicker(d, 0, N - 1);
end = clock();
if (debug) printf("%lf sec, ", (double)(end - start)/CLOCKS_PER_SEC);
start = clock();
qsort(b, N, sizeof(int), comp);
end = clock();
if (debug) printf("%lf sec\n", (double)(end - start)/CLOCKS_PER_SEC);
}
free(a);
free(b);
free(c);
free(d);
free(e);
return 0;
}
/* -------------------------------------------------------------
ElevationSlopeAspect
------------------------------------------------------------- */
void ElevationSlopeAspect(MAPSIZE * Map, TOPOPIX ** TopoMap)
{
const char *Routine = "ElevationSlopeAspect";
int x;
int y;
int n;
int k;
float neighbor_elev[NNEIGHBORS];
int steepestdirection;
float min;
int xn, yn;
/* fill neighbor array */
for (x = 0; x < Map->NX; x++) {
for (y = 0; y < Map->NY; y++) {
if (INBASIN(TopoMap[y][x].Mask)) {
/* Count the number of cells in the basin.
Need this to allocate memory for
the new, smaller Elev[] and Coords[][]. */
Map->NumCells++;
for (n = 0; n < NNEIGHBORS; n++) {
xn = x + xneighbor[n];
yn = y + yneighbor[n];
if (valid_cell(Map, xn, yn)) {
neighbor_elev[n] = ((TopoMap[yn][xn].Mask) ? TopoMap[yn][xn].Dem : (float) OUTSIDEBASIN);
}
else {
neighbor_elev[n] = (float) OUTSIDEBASIN;
}
}
slope_aspect(Map->DX, Map->DY, TopoMap[y][x].Dem, neighbor_elev,
&(TopoMap[y][x].Slope), &(TopoMap[y][x].Aspect));
/* fill Dirs in TopoMap too */
flow_fractions(Map->DX, Map->DY, TopoMap[y][x].Slope,
TopoMap[y][x].Aspect,
neighbor_elev, &(TopoMap[y][x].FlowGrad),
TopoMap[y][x].Dir, &(TopoMap[y][x].TotalDir));
/* If there is a sink, check again to see if there
is a direction of steepest descent. Does not account
for ties.*/
if(TopoMap[y][x].TotalDir == 0) {
steepestdirection = -99;
min = DHSVM_HUGE;
for (n = 0; n < NDIRS; n++) {
xn = x + xdirection[n];
yn = y + ydirection[n];
if (valid_cell(Map, xn, yn)) {
if (INBASIN(TopoMap[yn][xn].Mask)) {
if(TopoMap[yn][xn].Dem < min) {
min = TopoMap[yn][xn].Dem;
steepestdirection = n;
}
}
}
}
if(min < TopoMap[y][x].Dem) {
TopoMap[y][x].Dir[steepestdirection] = (int)(255.0 + 0.5);
TopoMap[y][x].TotalDir = (int)(255.0 + 0.5);
}
else {
/* Last resort: set the Dir of the cell to the cell that is
closest in elevation. This should only happen for the
basin outlet, unless the Dem wasn't filled. */
TopoMap[y][x].Dir[steepestdirection] = (int)(255.0 + 0.5);
TopoMap[y][x].TotalDir = (int)(255.0 + 0.5);
xn = x + xdirection[steepestdirection];
yn = y + ydirection[steepestdirection];
}
}
}
}
}
/* Create a structure to hold elevations of only those cells
within the basin and the y,x of those cells.*/
if (!(Map->OrderedCells = (ITEM *) calloc(Map->NumCells, sizeof(ITEM))))
ReportError((char *) Routine, 1);
k = 0;
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
/* Save the elevation, y, and x in the ITEM structure. */
if (INBASIN(TopoMap[y][x].Mask)) {
Map->OrderedCells[k].Rank = TopoMap[y][x].Dem;
Map->OrderedCells[k].y = y;
Map->OrderedCells[k].x = x;
k++;
}
}
}
/* Sort Elev in descending order-- Elev.x and Elev.y hold indices. */
quick(Map->OrderedCells, Map->NumCells);
/* End of modifications to create ordered cell coordinates. SRW 10/02, LCB 03/03 */
return;
}
void quick_sort(int arr[], int n)
{
quick(arr, 0, n - 1);
}
int make_search(int ndim, FILE *fpout, int *max, int *scheme, int *index,
int *list, int *unique, int *factor, int *error)
{
/*******************************************************************
*
* THIS IS A CONTROLLING ROUTINE TO CONSTRUCT AN ACTUAL SEARCH
* STRATEGY. FOR A FURTHER DESCRIPTION OF THIS ALGORITHM, AS IT
* RELATES TO THE PARALLEL DIRECT SEARCH METHODS, SEE J. E. DENNIS,
* JR. AND VIRGINIA TORCZON, "DIRECT SEARCH METHODS ON PARALLEL
* MACHINES," SIAM J. OPTIMIZATION, VOL. 1, NO. 4, PP. 448-474,
* NOVEMBER 1991.
*
* THE CONSTRUCTION OF THIS SEARCH STRATEGY IS DISCUSSED ON
* PP. 459-462 AND PP. 463-466; THE ALGORITHM IMPLEMENTED BELOW IS
* FORMALLY STATED IN TABLE 3, P. 465.
*
* WRITTEN BY VIRGINIA TORCZON
*
* LAST MODIFICATION: MARCH 11, 1992.
*
* PARAMETERS
*
* NOTE THAT THESE RATHER MESSY DIMENSION STATEMENTS ARE TO ALLOW
* THE MAXIMUM POSSIBLE NUMBER OF COLUMNS IN `SCHEME' GIVEN `N',
* THE DIMENSION OF THE PROBLEM, AND `MAX', THE SIZE OF `SCHEME'
* DECLARED IN THE MAIN PROGRAM.
*
* INPUT
*
* N THE DIMENSION OF THE PROBLEM TO BE SOLVED
*
* MAX THE DECLARED DIMENSION OF THE VECTOR `SCHEME'
*
* FPOUT BMA: replaced OUT with FPOUT which is a file
* pointer to the same (descriptors aren't
* portable); 02/09/2012
*
* OUT UNIT NUMBER FOR THE FILE TO WHICH THE POINTS
* IN THE SEARCH SCHEME ARE TO BE WRITTEN
* WORK
*
* SCHEME A WORK VECTOR PASSED FROM THE MAIN PROGRAM
* THAT IS REPARTITIONED INTO A MATRIX WITH ROWS
* FROM -1 TO N AND AS MANY COLUMNS AS THE
* ORIGINAL DIMENSION OF THE VECTOR WILL ALLOW.
* THIS ARRAY IS USED TO HOLD THE N-TUPLES (IN
* ROWS 1 THROUGH N) FOR EVERY POINT GENERATED
* AS A POSSIBLE POINT IN THE SEARCH STRATEGY.
* IN ROWS -1 AND 0 ARE THE SCALAR `A' AND THE
* POINT `BEST' NECESSARY TO RECONSTRUCT THE
* SIMPLEX ASSOCIATED WITH THAT N-TUPLE.
*
* INDEX ARRAY TO KEEP TRACK OF EACH COLUMN OF
* `SCHEME'
*
* LIST ARRAY TO KEEP TRACK OF A LIST OF DISTINCT
* N-TUPLES IN SCHEME (IF AN N-TUPLE OCCURS MORE
* THAN ONCE IN `SCHEME', `LIST' RECORDS ONLY
* THE FIRST OCCURRENCE)
* OUTPUT
*
* UNIQUE THE FINAL LENGTH OF `LIST' (I.E., THE TOTAL
* NUMBER OF DISTINCT POINTS GENERATED)
*
* FACTOR THE SCALING FACTOR USED TO GENERATE THE LIST;
* `FACTOR' IS CHOSEN TO ALLOW ALL THE WORK TO
* BE DONE IN INTEGER ARITHMETIC BOTH TO SAVE
* STORAGE AND TO ELIMINATE ANY AMBIGUITIES
* ABOUT THE DISTINCTIVENESS OF
* N-TUPLE---AMBIGUITIES THAT COULD POSSIBLE
* OCCUR WHEN USING FLOATING POINT ARITHMETIC
*
* ERROR ERROR FLAG TO SIGNAL WHETHER OR NOT PREMATURE
* TERMINATION OCCURRED. IF `ERROR' IS SET TO
* ZERO, THEN NO ERRORS HAVE BEEN FLAGGED.
* CURRENTLY, THE ONLY ERROR FLAGGED IS WHEN THE
* QUICKSORT ROUTINES RETURN BECAUSE THE LENGTH
* OF THE ARRAY PASSED TO SORT EXCEEDS THE
* CAPACITY OF THE INTERNAL STACK. FOR FURTHER
* INFORMATION ON THIS ERROR, SEE THE COMMENTS
* IN THE ROUTINES `SORT' AND `QUICK'.
*
* LOCAL CONSTANTS
*
* THE PARAMETERS ALPHA, BETA, AND GAMMA SET THE SIZE OF THE *
* REFLECTION, CONTRACTION, AND EXPANSION STEPS, RESPECTIVELY. *
* THESE CONSTANTS ARE CURRENTLY SET TO THE DEFAULT VALUES *
* RECOMMENDED BY NELDER AND MEAD (NOTE THAT WE DIVIDE BY BETA!).
* * THE ALGORITHM BELOW ASSUMES THAT EACH CONSTANT IS A POWER OF
* TWO * SO THAT THE WORK CAN BE DONE IN INTEGER ARITHMETIC. THE
* CRITICAL * "PIECES" OF THE SEARCH SCHEME RESIDE IN THE DATA
* STRUCTURE * `SCHEME'. THE MATRIX `SCHEME' CAN BE THOUGHT OF
* AS TWO VECTORS, * `A', WHICH IS STORED IN THE -1 ROW OF
* `SCHEME', AND `BEST', WHICH * IS STORED IN THE 0 ROW OF
* `SCHEME', AND ONE MATRIX `NTUPLES', * WHICH IS STORED IN THE
* REMAINING ROWS OF `SCHEME'. THE PURPOSE * OF THESE PIECES ARE
* AS FOLLOWS:
*
* A AN INTEGER ARRAY WHICH CONTAINS THE SCALAR NECESSARY
* TO RECONSTRUCT THE SIMPLEX ASSOCIATED WITH A GIVEN
* POINT I
*
* BEST AN INTEGER ARRAY WHICH CONTAINS THE POINTER TO THE
* VERTEX IN THE ORIGINAL SIMPLEX ASSOCIATED WITH A
* GIVEN POINT I
*
* NTUPLES AN INTEGER MATRIX WHICH CONTAINS THE SCALARS
* NECESSARY TO CONSTRUCT POINT I FROM THE N EDGES
* ADJACENT TO THE BEST VERTEX IN THE ORIGINAL SIMPLEX;
* THE N-TUPLES ARE STORED BY COLUMN
*
* NOTE THAT FOR ALL THREE STRUCTURES WE ALSO KEEP INFORMATION
* ABOUT * THE N+1 VERTICES IN THE ORIGINAL SIMPLEX IN
* POSITIONS/COLUMNS -N * THROUGH 0 SO THAT WE HAVE ALL THE
* INFORMATION WE NEED BOTH TO * GENERATE THE NEW POINTS AND TO
* DETECT DUPLICATION.
*
* INITIALIZE THE OPTIMIZATION PROCEDURE BY DETERMINING THE POINTS
* TO BE COMPUTED AT EACH ITERATION ON THE HYPERCUBE.
*
* THERE IS AN UPPER LIMIT ON THE NUMBER OF POINTS WE CAN CONSIDER
* WHICH IS BASED ON THE DIMENSION OF THE PROBLEM `N' AND THE SIZE
* OF `SCHEME'. CALCULATE THAT LIMIT.
*
* WE WILL ALSO RESCALE BY THE "GREATEST COMMON DENOMINATOR"
* (DETERMINED BY `BETA'). IN ESSENCE, WE ARE TRYING TO GUESS HOW
* MANY "LOOK-AHEADS" WE MUST DO TO FILL OUT THE "RAW" LIST OF
* POINTS WE WILL GENERATE. THE SIZE OF THE RAW LIST IS DETERMINED
* BY `LIMIT' (I.E., THE MAXIMUM SIZE OF `SCHEME'). ONCE WE RESCALE
* ACCORDINGLY, WE CAN WORK STRICTLY IN INTEGER ARITHMETIC.
*
*******************************************************************/
/* System generated locals */
int scheme_dim1, scheme_offset, index_offset, i_1, i_2;
/* Local variables */
int beta;
static int leaf;
static int c, i, j, k;
static int limit, total;
/* Parameter adjustments */
scheme_dim1 = ndim + 2;
scheme_offset = scheme_dim1 * (-(ndim)) - 1;
scheme -= scheme_offset;
index_offset = -(ndim);
index -= index_offset;
--list;
/* Function Body */
limit = (*max - ndim * ndim - ndim * 3 - 2) / (ndim + 2);
*factor = depth(ndim, 2, limit);
/* INITIALIZE THE ROOT OF THE TREE, WHICH IS THE CURRENT BEST
* VERTEX. */
leaf = 0;
j = 0;
index[j] = 0;
scheme[j * scheme_dim1 - 1] = *factor;
scheme[j * scheme_dim1] = 0;
i_1 = ndim;
for (k = 1; k <= i_1; ++k) {
scheme[k + leaf * scheme_dim1] = 0;
}
/* INITIALIZE THE REMAINING VERTICES IN THE SIMPLEX SO THAT THEY ARE
* NOT LATER DUPLICATED. */
i_1 = ndim;
for (i = 1; i <= i_1; ++i) {
index[-i] = -i;
scheme[-i * scheme_dim1 - 1] = *factor;
scheme[-i * scheme_dim1] = 0;
i_2 = ndim;
for (k = 1; k <= i_2; ++k) {
scheme[k + -i * scheme_dim1] = 0;
}
scheme[i + -i * scheme_dim1] = *factor;
}
/* CHECK TO PREVENT OVERFLOW (I.E., SO THAT `LIMIT' IS NOT
* EXCEEDED). */
L4000:
if (j <= limit - (ndim * 3 + 1)) {
c = scheme[leaf * scheme_dim1];
/* FIRST COMPUTE ALL N REFLECTION POINTS. */
i_1 = c - 1;
for (i = 0; i <= i_1; ++i) {
++j;
index[j] = j;
scheme[j * scheme_dim1 - 1] = -scheme[leaf * scheme_dim1 - 1];
scheme[j * scheme_dim1] = i;
i_2 = ndim;
for (k = 1; k <= i_2; ++k) {
scheme[k + j * scheme_dim1] = scheme[k + leaf * scheme_dim1];
}
if (i != 0) {
scheme[i + j * scheme_dim1] += scheme[j * scheme_dim1 - 1];
}
scheme[c + j * scheme_dim1] -= scheme[j * scheme_dim1 - 1];
}
i_1 = ndim;
for (i = c + 1; i <= i_1; ++i) {
++j;
index[j] = j;
scheme[j * scheme_dim1 - 1] = -scheme[leaf * scheme_dim1 - 1];
scheme[j * scheme_dim1] = i;
i_2 = ndim;
for (k = 1; k <= i_2; ++k) {
scheme[k + j * scheme_dim1] = scheme[k + leaf * scheme_dim1];
}
scheme[i + j * scheme_dim1] += scheme[j * scheme_dim1 - 1];
if (c != 0) {
scheme[c + j * scheme_dim1] -= scheme[j * scheme_dim1 - 1];
}
}
/* NEXT COMPUTE ALL N + 1 CONTRACTION POINTS. WE INCLUDE THE
* POSSIBILITY THAT THE BEST IS NOT REPLACED. */
i_1 = ndim;
for (i = 0; i <= i_1; ++i) {
++j;
index[j] = j;
scheme[j * scheme_dim1 - 1] = scheme[leaf * scheme_dim1 - 1] / 2;
scheme[j * scheme_dim1] = i;
i_2 = ndim;
for (k = 1; k <= i_2; ++k) {
scheme[k + j * scheme_dim1] = scheme[k + leaf * scheme_dim1];
}
if (i != 0) {
scheme[i + j * scheme_dim1] += scheme[j * scheme_dim1 - 1];
}
if (c != 0) {
scheme[c + j * scheme_dim1] -= scheme[j * scheme_dim1 - 1];
}
}
/* FINALLY, COMPUTE ALL N EXPANSION POINTS. */
i_1 = c - 1;
for (i = 0; i <= i_1; ++i) {
++j;
index[j] = j;
scheme[j * scheme_dim1 - 1] = scheme[leaf * scheme_dim1 - 1] * -2;
scheme[j * scheme_dim1] = i;
i_2 = ndim;
for (k = 1; k <= i_2; ++k) {
scheme[k + j * scheme_dim1] = scheme[k + leaf * scheme_dim1];
}
if (i != 0) {
scheme[i + j * scheme_dim1] += scheme[j * scheme_dim1 - 1];
}
scheme[c + j * scheme_dim1] -= scheme[j * scheme_dim1 - 1];
}
i_1 = ndim;
for (i = c + 1; i <= i_1; ++i) {
++j;
index[j] = j;
scheme[j * scheme_dim1 - 1] = scheme[leaf * scheme_dim1 - 1] * -2;
scheme[j * scheme_dim1] = i;
i_2 = ndim;
for (k = 1; k <= i_2; ++k) {
scheme[k + j * scheme_dim1] = scheme[k + leaf * scheme_dim1];
}
scheme[i + j * scheme_dim1] += scheme[j * scheme_dim1 - 1];
if (c != 0) {
scheme[c + j * scheme_dim1] -= scheme[j * scheme_dim1 - 1];
}
}
++leaf;
goto L4000;
}
total = j;
/* NOW, ELIMINATE ALL THE DUPLICATE POINTS. WHEN THERE ARE
* DUPLICATES, KEEP THE POINT THAT WAS GENERATED FIRST. */
*error = 0;
/* FIRST SORT THE LIST OF "RAW" POINTS; THE SORT IS KEYED ON THE
* N-TUPLES IN `SCHEME'. */
sort(ndim, &total, &index[index_offset], &scheme[scheme_offset], error);
if (*error == 0) {
/* NOW GO THROUGH THIS SORTED LIST AND BUILD A NEW LIST OF UNIQUE
* N-TUPLES (THE INDEX FOR THIS LIST IS STORED IN THE ARRAY
* `LIST'). */
*unique = 0;
i = -(ndim);
i_1 = total;
for (j = -(ndim) + 1; j <= i_1; ++j) {
if (order(ndim, &scheme[index[i] * scheme_dim1 + 1],
&scheme[index[j] * scheme_dim1 + 1]) != 0) {
/* YOU HAVE ANOTHER (UNIQUE) POINT TO ADD TO THE LIST. (MAKE
* SURE YOU ARE NOT ADDING ONE OF THE ORIGINAL VERTICES!) */
if (index[i] > 0) {
++(*unique);
list[*unique] = index[i];
}
i = j;
} else {
/* YOU HAVE A DUPLICATE POINT. */
if (index[i] > index[j]) {
/* KEEP THE POINT WHICH WAS GENERATED "FIRST." */
i = j;
}
}
}
/* ADD THE LAST POINT TO THE LIST. */
if (index[i] > 0) {
/* AGAIN, MAKE SURE YOU ARE NOT ADDING ONE OF THE ORIGINAL
* VERTICES! */
++(*unique);
list[*unique] = index[i];
}
/* NOW RESORT THE LIST OF UNIQUE POINTS, KEYED ON `LIST', SO THAT
* THE POINTS CAN BE LOADED IN THE CORRECT ORDER. */
quick(*unique, &list[1], error);
if (*error == 0) {
/* WRITE ALL THIS INFORMATION OUT TO A FILE FOR LATER USE. */
beta = (int) 2.0;
*error = writes(fpout, ndim, *unique, *factor, beta,
&scheme[scheme_offset], &list[1]);
}
}
return *error;
}
//======================================================================
int main(){
int system_call_return_value;
system_call_return_value = system("clear");
system_call_return_value = system("clear");
//==================================================================
// star camera
//==================================================================
//==============================================================
// intrinsic paramters for star camera
//==============================================================
intrinsic_camera_parameter parameters_for_star_camera;
/*
parameters_for_star_camera.set_names(
"ueye 5MPx CMOS",
"Carl Zeiss Flektogon F2.4 / f35mm");
parameters_for_star_camera.set_FoV_to_pixel_mapping(3.34375E-3);
*/
parameters_for_star_camera.set_names(
"ueye 5MPx CMOS","Flektogon F1.8 / f50mm");
parameters_for_star_camera.set_FoV_to_pixel_mapping(0.002427534);
parameters_for_star_camera.
set_coefficients_for_radiometric_correction_plane(
-1.2185,
1.2021,
0.99303
);
ueye_camera star_camera(13,parameters_for_star_camera);
//==================================================================
// reflector camera
//==================================================================
//==============================================================
// intrinsic paramters for reflector camera
//==============================================================
intrinsic_camera_parameter parameters_for_reflector_camera;
parameters_for_reflector_camera.set_names(
"Thor Labs 1.3MPx CCD",
"M12 the imageing source F2.0 / f4mm"
);
parameters_for_reflector_camera.
set_coefficients_for_radiometric_correction_plane(
-1.1527,
1.0283,
-0.18637
);
ueye_camera reflector_camera(42,parameters_for_reflector_camera);
star_camera.display_camera_information();
reflector_camera.display_camera_information();
//==================================================================
// hanldes
//==================================================================
sccan_point_pair_handler sccan_handle;
sccan_handle.set_cameras(&star_camera,&reflector_camera);
//sccan_handle.acquire_sccan_points(5);
snapshot snap;
snap.add_camera(&star_camera);
snap.add_camera(&reflector_camera);
reflector reflector_instance(&reflector_camera);
quick_align quick(&reflector_instance,&sccan_handle);
//tester
star_recognition_test_environment test_environment;
sccan_point_analysis analysis(
&sccan_handle,&reflector_instance//,&star_camera
);
verbosity_handler verbosity_interaction(
&global_time_stamp_manager_instance,
&star_camera,
&reflector_camera,
&reflector_instance,
&snap,
&sccan_handle,
&quick,
&analysis
);
main_menu menu(
&snap,
&reflector_instance,
&sccan_handle,
&quick,
&analysis,
&verbosity_interaction,
&star_camera,
&reflector_camera,
&test_environment);
menu.interaction();
return 0;
}
int main() {
show(gg_array, 10);
quick(gg_array, 0, 9);
show(gg_array, 10);
return 0;
}
void digui_quick_sort(int *arr, int n)
{
quick(arr, 0, n - 1);
}
