install

基于java的3d开发库。对坐java3d的朋友有很大的帮助。

Lots of informative documentation in here!

flt_hybrid.c - source for performing the simple-split/hybrid
algorithm. The simple-split algorithm work as follows: given
a problem of size N, IMMEDIATELY reduce (i.e. SPLIT) it into
smaller subproblems and apply a seminaive approach to each of
the subproblems. The hybrid algorithm works as follows: apply
the "pure" seminaive algorithm to compute the first X-many
coefficients; then use the simple-split algorithm to compute
the rest. What does X equal? That depends on many things. You
need to determine which value of X works best for you. This
"switch point" will depend on the bandwidth, order of the
transform, and the number of splits (which controls stability)
one does in the simple-split portion of the hybrid algorithm.
The thing which needs to be done is determine those settings
which make the hybrid algorithm a) stable and b) competitive
with the seminaive algorithm.

Look at the documentation in this file and in
precomp_flt_hybrid.c !!! The current settings in the code seem
to work well for us. They may be taken as a starting point.
With the current settings, the hybrid algorithm was faster
(and still stable) than the seminaive algorithm on the DEC
at bw = 1024 for orders m = 0 through (roughly) m = 100;
on an SGI and HP, at the same bandwidth, the hybrid algorithm
was faster (and still stable) for orders m = 0 through
(roughly) m = 512. Again, your mileage may vary!!!

test_flt_hybrid.c - sample main for computing the forward
simple-split/hybrid Legendre transform; used for timing and
stability-testing purposes. For bandwidths through 1024.
Is stable!

Compile the code with the command

 make test_flt_hybrid


######################################################################
######################################################################
######################################################################


CODE RELEVANT FOR SPHERICAL TRANSFORMS
--------------------------------------
--------------------------------------

As the size/bandwidth of the spherical transform increases, so
do the memory requirements, and at a very high (and alarming?)
rate. Please read the BACKGROUND file for important information
concerning this issue.



MathFace.c - code to interface with Mathematica-generated tables.

Fast Fourier Transform (FFT) code
---------------------------------

FFTcode.c - as advertised.

permroots.c - contains the 4096 4096th roots of unity in 
bit-reversed order.

indextables.c - tables containing bit-reverse permutation indices.


FAST SPHERICAL HARMONIC TRANSFORMS
-----------------------------------


FST_semi_memo.c - source code to perform convolutions on the
2-sphere using a semi-naive algorithm; EXPECTS PRECOMPUTED
DATA TO BE IN MEMORY

FST_semi_fly.c - source code to perform convolutions on the
2-sphere using a semi-naive algorithm; COMPUTES PRECOMPUTED
DATA AS NEEDED, ON THE FLY

FST_semi_disk.c - source code to perform convolutions on the
2-sphere using a semi-naive algorithm; EXPECTS TO READ
PRECOMPUTED DATA OFF DISK

FST_hybrid_memo.c - source code to perform convolutions on the
2-sphere using hybrid algorithm in the forward direction and
semi-naive algorithm in the reverse; EXPECTS PRECOMPUTED
DATA TO BE IN MEMORY

FST_hybrid_memoX.c - just like FST_hybrid_memo.c EXCEPT it
writes over the input data during the algorithm (i.e. so
there is less memory to allocate)

FST_hybrid_disk.c - source code to perform convolutions on the
2-sphere using hybrid algorithm in the forward direction and
semi-naive algorithm in the reverse; EXPECTS TO READ
PRECOMPUTED DATA OFF DISK


When we say that the hybrid algorithm was used in the
forward transform direction, this is what we mean.
Suppose we are doing a forward spherical transform of
order BW. For orders m = 0 through m = LIM (where, in
our tests, LIM = BW/4 for BW = 64 through 512, LIM = BW/2
for BW = 1024), the hybrid Legendre transform algorithm
was used. For orders m = LIM + 1 through m = BW - 1,
the seminaive Legendre transform algorithm was used.
The code here uses the above LIM settings. Other LIM
settings may be better for you. Again, it cannot be
stressed enough, see precomp_flt_hybrid.c and flt_hybrid.c
for details!

What follows are now the spherical executables:

1) FST_precomp2disk.c - routine to compute and save to disk
the precomputed data required by the forward and reverse
seminaive spherical transform and the forward hybrid
spherical transform; for bw = 8 for seminaive, bw = 16
for hybrid, through 1024

Compile the code with the command

 make FST_precomp2disk


2) test_FST_semi_memo.c - sample main for computing forward
and reverse spherical transforms using the seminaive algorithm;
used for timing and stability-testing purposes;
for bw = 8 through 512; EXPECTS PRECOMPUTED DATA TO BE
IN MEMORY

Compile the code with the command

 make test_FST_semi_memo


3) test_FST_semi_fly.c - sample main for computing forward
and reverse spherical transforms using the seminaive algorithm;
used for timing and stability-testing purposes;
for bw = 8 through 1024; COMPUTES PRECOMPUTED DATA AS NEEDED,
ON THE FLY

Compile the code with the command

 make test_FST_semi_fly


4) test_FST_semi_disk.c - sample main for computing forward
and reverse spherical transforms using the seminaive algorithm;
used for timing and stability-testing purposes;
for bw = 8 through 1024; EXPECTS TO READ PRECOMPUTED DATA
OFF DISK

Compile the code with the command

 make test_FST_semi_disk


5) test_FST_hybrid_memo.c - sample main for computing forward
spherical transform using the hybrid algorithm and the
reverse spherical transform using the seminaive algorithm;
used for timing and stability-testing purposes;
for bw = 64 through 512; EXPECTS PRECOMPUTED DATA TO BE
IN MEMORY

Compile the code with the command

 make test_FST_hybrid_memo

6) test_FST_hybrid_memoX.c - sample main for computing forward
spherical transform using the hybrid algorithm and the
reverse spherical transform using the seminaive algorithm
(memory-friendly version); used for timing and stability-testing
purposes; for bw = 64 through 512; EXPECTS PRECOMPUTED DATA
TO BE IN MEMORY

Compile the code with the command

 make test_FST_hybrid_memoX

7) test_FST_hybrid_disk.c - sample main for computing forward
spherical transform using the hybrid algorithm and the
reverse spherical transform using the seminaive algorithm;
used for timing and stability-testing purposes; for bw = 16
through 1024; EXPECTS TO READ PRECOMPUTED DATA OFF DISK

Compile the code with the command

 make test_FST_hybrid_disk


8) CONV_SEMI_MEMO.c - sample main for convolving two functions
defined on the 2-sphere using the seminaive algorithm;
for bw = 64 through 512; EXPECTS PRECOMPUTED DATA TO BE
IN MEMORY

Compile the code with the command

 make CONV_SEMI_MEMO

9) CONV_SEMI_FLY.c - sample main for convolving two functions
defined on the 2-sphere using the seminaive algorithm;
for bw = 64 through 1024; COMPUTES PRECOMPUTED DATA AS NEEDED,
ON THE FLY

Compile the code with the command

 make CONV_SEMI_FLY


10) CONV_SEMI_DISK.c - sample main for convolving two functions
defined on the 2-sphere using the seminaive algorithm;
for bw = 64 through 512; EXPECTS TO READ PRECOMPUTED DATA
OFF DISK

Compile the code with the command

 make CONV_SEMI_DISK

11) CONV_HYBRID_MEMO.c - sample main for convolving two functions
defined on the 2-sphere using the hybrid algorithm in the
forward direction and seminaive algorithm in the reverse;
for bw = 64 through 512; EXPECTS PRECOMPUTED DATA TO BE
IN MEMORY

Compile the code with the command

 make CONV_HYBRID_MEMO

11) CONV_HYBRID_DISK.c - sample main for convolving two functions
defined on the 2-sphere using the hybrid algorithm in the
forward direction and seminaive algorithm in the reverse;
for bw = 64 through 1024; EXPECTS TO READ PRECOMPUTED DATA
OFF DISK

Compile the code with the command

 make CONV_HYBRID_DISK



Two sets of data:

sphere_bw64.dat, filter_bw64.dat

sphere_bw128.dat, filter_bw128.dat

are provided as examples of inputs for the convolution routines.
These files were created by Mathematica (tm).