From 1b029507bf016442b45bf7f1eb9949896a77f2c3 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Tue, 13 Oct 2020 23:05:39 +0100 Subject: [PATCH 01/23] Add tests to s2let --- .clang-format | 22 + .gitignore | 2 + .pre-commit-config.yaml | 15 + CMakeLists.txt | 4 + cmake/conan_dependencies.cmake | 6 +- cmake/fetch_cmocka.cmake | 17 + src/test/c/CMakeLists.txt | 6 + src/test/c/s2let_hpx_test.c | 2 +- src/test/c/test_adjoint.c | 517 +++++++++++++++++++ src/test/c/test_axisym_vs_directional.c | 128 +++++ src/test/c/test_back_and_forth.c | 632 ++++++++++++++++++++++++ src/test/c/test_tiling.c | 101 ++++ 12 files changed, 1448 insertions(+), 4 deletions(-) create mode 100644 .clang-format create mode 100644 .pre-commit-config.yaml create mode 100644 cmake/fetch_cmocka.cmake create mode 100644 src/test/c/test_adjoint.c create mode 100644 src/test/c/test_axisym_vs_directional.c create mode 100644 src/test/c/test_back_and_forth.c create mode 100644 src/test/c/test_tiling.c diff --git a/.clang-format b/.clang-format new file mode 100644 index 00000000..8c5efc88 --- /dev/null +++ b/.clang-format @@ -0,0 +1,22 @@ +--- +BasedOnStyle: LLVM +AlignAfterOpenBracket: AlwaysBreak +AllowAllArgumentsOnNextLine: true +BinPackArguments: false +BinPackParameters: false +ColumnLimit: 88 +CompactNamespaces: true +IncludeBlocks: Regroup +IndentWidth: 2 +Language: Cpp +ReflowComments: true +SortIncludes: true +UseTab: Never +IncludeCategories: + - Regex: '^' + Priority: 10 + - Regex: '^".*\.h"' + Priority: 9 + - Regex: '^<.*\.h>' + Priority: 8 +... diff --git a/.gitignore b/.gitignore index 7c71d865..91fca54e 100644 --- a/.gitignore +++ b/.gitignore @@ -27,3 +27,5 @@ CMakeCache.txt CMakeFiles/ dist/ MANIFEST +.clangd/ +compile_commands.json diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 00000000..f79af50f --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,15 @@ +default_language_version: + python: python3.8 +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v3.1.0 + hooks: + - id: check-merge-conflict + - id: debug-statements + - id: no-commit-to-branch + args: ["--branch", "master"] + - repo: https://github.com/prettier/prettier + rev: 2.1.2 + hooks: + - id: prettier + files: '.+\.yaml' diff --git a/CMakeLists.txt b/CMakeLists.txt index 1bd44017..cf4ff1cb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,6 +16,9 @@ option(conan_deps "Download dependencies using conan" OFF) if(WIN32) set(fpic OFF) endif() +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "Debug") +endif() list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) if(conan_deps) @@ -37,6 +40,7 @@ add_subdirectory(src/main/c) if(tests) enable_testing() + include("fetch_cmocka") add_subdirectory(src/test/c) endif() diff --git a/cmake/conan_dependencies.cmake b/cmake/conan_dependencies.cmake index aec1c2e1..de03d09e 100644 --- a/cmake/conan_dependencies.cmake +++ b/cmake/conan_dependencies.cmake @@ -13,7 +13,7 @@ elseif(NOT CONAN_OPTIONS) set(fpic_value "False") endif() if(NOT CONAN_DEPS) - set(CONAN_DEPS "so3/1.2.1@AstroFizz/stable") + set(CONAN_DEPS "so3/1.2.1@astro-informatics/stable") endif() list(APPEND CONAN_OPTIONS "so3:fPIC=${fpic_value}") if(cfitsio) @@ -25,8 +25,8 @@ if(NOT CONAN_BUILD) endif() conan_check(REQUIRED) -conan_add_remote(NAME AstroFizz URL - https://api.bintray.com/conan/mdavezac/AstroFizz) +conan_add_remote(NAME astro-informatics URL + https://api.bintray.com/conan/astro-informatics/astro-informatics) conan_cmake_run( REQUIRES ${CONAN_DEPS} diff --git a/cmake/fetch_cmocka.cmake b/cmake/fetch_cmocka.cmake new file mode 100644 index 00000000..62a820b5 --- /dev/null +++ b/cmake/fetch_cmocka.cmake @@ -0,0 +1,17 @@ +include(FetchContent) + +FetchContent_Declare( + CMocka + GIT_REPOSITORY https://gitlab.com/cmocka/cmocka.git + GIT_TAG cmocka-1.1.5) + +if(NOT cmocka_POPULATED) + # Fetch the content using previously declared details + FetchContent_Populate("cmocka") + file(READ "${cmocka_SOURCE_DIR}/CMakeLists.txt" patch_cmocka) + string(REPLACE "add_subdirectory(src)" "add_subdirectory(src)\nreturn()" + patch_cmocka ${patch_cmocka}) + file(WRITE "${cmocka_SOURCE_DIR}/CMakeLists.txt" ${patch_cmocka}) + + add_subdirectory(${cmocka_SOURCE_DIR} ${cmocka_BINARY_DIR}) +endif() diff --git a/src/test/c/CMakeLists.txt b/src/test/c/CMakeLists.txt index a84bc432..1caf6b49 100644 --- a/src/test/c/CMakeLists.txt +++ b/src/test/c/CMakeLists.txt @@ -1,3 +1,9 @@ add_executable(s2let_test s2let_test.c) target_link_libraries(s2let_test PUBLIC s2let) add_test(NAME s2let_test COMMAND s2let_test) + +foreach(name tiling adjoint back_and_forth axisym_vs_directional) + add_executable(test_${name} test_${name}.c) + target_link_libraries(test_${name} PUBLIC s2let cmocka) + add_test(NAME test_${name} COMMAND test_${name}) +endforeach() diff --git a/src/test/c/s2let_hpx_test.c b/src/test/c/s2let_hpx_test.c index 39853886..7991f3c4 100644 --- a/src/test/c/s2let_hpx_test.c +++ b/src/test/c/s2let_hpx_test.c @@ -11,7 +11,7 @@ #include #include #include -#include +#include void s2let_hpx_spinalm_test(int nside, int spin, int L, int seed) { diff --git a/src/test/c/test_adjoint.c b/src/test/c/test_adjoint.c new file mode 100644 index 00000000..0fb08a42 --- /dev/null +++ b/src/test/c/test_adjoint.c @@ -0,0 +1,517 @@ +#include +#include +#include + +#include "s2let.h" + +#include + +const int seed = 1; + +static complex double +dot_complex(complex double *v1, complex double *v2, int N_length) { + complex long double dot_product = 0.0; + for (int i = 0; i < N_length; i++) + dot_product += conj(v1[i]) * v2[i]; + return dot_product; +} + +static complex double dot_real(double *v1, double *v2, int N_length) { + + long double dot_product = 0.0; + + for (int i = 0; i < N_length; i++) + dot_product += v1[i] * v2[i]; + return dot_product; +} + +void test_wav_analysis_adjoint_lm_lmn(void **state) { + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + + complex double *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + + complex double *f_wav_lmn, *f_scal_lm, *f_wav_lmn_rec, *f_scal_lm_rec; + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); + s2let_allocate_lmn_f_wav(&f_wav_lmn_rec, &f_scal_lm_rec, parameters); + + s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + s2let_lm_random_flm(flm_rec, parameters->L, parameters->spin, seed); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); + s2let_tiling_wavelet(wav_lm, scal_l, parameters); + + // Perform wavelet analysis to make f_wac_rec amd f_scal_rec + s2let_analysis_lm2lmn( + f_wav_lmn_rec, f_scal_lm_rec, flm_rec, wav_lm, scal_l, parameters); + + // Perform wavelet analysis from scratch with all signals given on the sphere (MW + s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, parameters); + s2let_analysis_adjoint_lmn2lm( + flm_rec, f_wav_lmn_rec, f_scal_lm_rec, wav_lm, scal_l, parameters); + + // compute dot products of arrays + complex double error = + dot_complex(f_wav_lmn_rec, f_wav_lmn, s2let_n_lmn_wav(parameters)) + + dot_complex(f_scal_lm_rec, f_scal_lm, s2let_n_lm_scal(parameters)) - + dot_complex(flm_rec, flm, parameters->L * parameters->L); + + assert_float_equal(creal(error), 0, 1e-12); + assert_float_equal(cimag(error), 0, 1e-12); + + free(flm); + free(flm_rec); + free(f_wav_lmn); + free(f_scal_lm); + free(f_wav_lmn_rec); + free(f_scal_lm_rec); +} + +void test_wav_synthesis_adjoint_lm_lmn(void **state) { + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + + complex double *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + + complex double *f_wav_lmn, *f_scal_lm, *f_wav_lmn_rec, *f_scal_lm_rec; + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); + s2let_allocate_lmn_f_wav(&f_wav_lmn_rec, &f_scal_lm_rec, parameters); + + s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + s2let_lm_random_flm(flm_rec, parameters->L, parameters->spin, seed); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); + s2let_tiling_wavelet(wav_lm, scal_l, parameters); + + s2let_analysis_lm2lmn( + f_wav_lmn_rec, f_scal_lm_rec, flm_rec, wav_lm, scal_l, parameters); + + s2let_synthesis_adjoint_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, parameters); + + s2let_synthesis_lmn2lm( + flm_rec, f_wav_lmn_rec, f_scal_lm_rec, wav_lm, scal_l, parameters); + + complex double error = + dot_complex(f_wav_lmn_rec, f_wav_lmn, s2let_n_lmn_wav(parameters)) + + dot_complex(f_scal_lm_rec, f_scal_lm, s2let_n_lm_scal(parameters)) - + dot_complex(flm_rec, flm, parameters->L * parameters->L); + + assert_float_equal(creal(error), 0, 1e-12); + assert_float_equal(cimag(error), 0, 1e-12); + + free(flm); + free(flm_rec); + free(f_wav_lmn); + free(f_scal_lm); + free(f_wav_lmn_rec); + free(f_scal_lm_rec); +} + +void test_wav_analysis_adjoint_mw(void **state) { + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + + complex double *f, *f_rec, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + s2let_allocate_mw(&f, parameters->L); + s2let_allocate_mw(&f_rec, parameters->L); + + complex double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec; + s2let_allocate_f_wav(&f_wav, &f_scal, parameters); + s2let_allocate_f_wav(&f_wav_rec, &f_scal_rec, parameters); + + s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + s2let_lm_random_flm(flm_rec, parameters->L, parameters->spin, seed); + + ssht_core_mw_inverse_sov_sym( + f, + flm, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + ssht_core_mw_inverse_sov_sym( + f_rec, + flm_rec, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + + s2let_analysis_px2wav(f_wav_rec, f_scal_rec, f_rec, parameters); + + s2let_analysis_px2wav(f_wav, f_scal, f, parameters); + + s2let_analysis_adjoint_wav2px(f_rec, f_wav_rec, f_scal_rec, parameters); + + const complex double error = + dot_complex(f_wav_rec, f_wav, s2let_n_wav(parameters)) + + dot_complex(f_scal_rec, f_scal, s2let_n_scal(parameters)) - + dot_complex(f_rec, f, parameters->L * (2 * parameters->L - 1)); + + assert_float_equal(creal(error), 0, 1e-12); + assert_float_equal(cimag(error), 0, 1e-12); + + free(f); + free(f_rec); + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); + free(f_wav_rec); + free(f_scal_rec); +} + +void test_wav_analysis_adjoint_mw_real(void **state) { + s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + parameters.reality = 1; + + double *f, *f_rec; + complex double *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mw_real(&f, parameters.L); + s2let_allocate_mw_real(&f_rec, parameters.L); + + double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec; + s2let_allocate_f_wav_real(&f_wav, &f_scal, ¶meters); + s2let_allocate_f_wav_real(&f_wav_rec, &f_scal_rec, ¶meters); + + s2let_lm_random_flm_real(flm, parameters.L, seed); + s2let_lm_random_flm_real(flm_rec, parameters.L, seed); + + ssht_core_mw_inverse_sov_sym_real( + f, flm, parameters.L, parameters.dl_method, parameters.verbosity); + ssht_core_mw_inverse_sov_sym_real( + f_rec, flm_rec, parameters.L, parameters.dl_method, parameters.verbosity); + + s2let_analysis_px2wav_real(f_wav_rec, f_scal_rec, f_rec, ¶meters); + s2let_analysis_px2wav_real(f_wav, f_scal, f, ¶meters); + + s2let_analysis_adjoint_wav2px_real(f_rec, f_wav_rec, f_scal_rec, ¶meters); + + const double error = dot_real(f_wav_rec, f_wav, s2let_n_wav(¶meters)) + + dot_real(f_scal_rec, f_scal, s2let_n_scal(¶meters)) - + dot_real(f_rec, f, parameters.L * (2 * parameters.L - 1)); + + assert_float_equal(error, 0, 1e-12); + + free(f); + free(f_rec); + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); + free(f_wav_rec); + free(f_scal_rec); +} + +void test_wav_synthesis_adjoint_lm2wav(void **state) { + skip(); + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + + complex double *f, *f_rec, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + s2let_allocate_mw(&f, parameters->L); + s2let_allocate_mw(&f_rec, parameters->L); + + complex double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec; + s2let_allocate_f_wav(&f_wav, &f_scal, parameters); + s2let_allocate_f_wav(&f_wav_rec, &f_scal_rec, parameters); + + s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + s2let_lm_random_flm(flm_rec, parameters->L, parameters->spin, seed); + + ssht_core_mw_inverse_sov_sym( + f, + flm, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + ssht_core_mw_inverse_sov_sym( + f_rec, + flm_rec, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + + s2let_analysis_px2wav(f_wav_rec, f_scal_rec, f_rec, parameters); + s2let_synthesis_adjoint_lm2wav(f_wav, f_scal, flm, parameters); + s2let_synthesis_wav2lm(flm_rec, f_wav_rec, f_scal_rec, parameters); + + const complex double error = + dot_complex(f_wav_rec, f_wav, s2let_n_wav(parameters)) + + dot_complex(f_scal_rec, f_scal, s2let_n_scal(parameters)) - + dot_complex(f_rec, f, parameters->L * parameters->L); + + assert_float_equal(creal(error), 0, 1e-12); + assert_float_equal(cimag(error), 0, 1e-12); + + free(f); + free(f_rec); + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); + free(f_wav_rec); + free(f_scal_rec); +} + +void test_wav_synthesis_adjoint_mw(void **state) { + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + + complex double *f, *f_rec, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + s2let_allocate_mw(&f, parameters->L); + s2let_allocate_mw(&f_rec, parameters->L); + + complex double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec; + s2let_allocate_f_wav(&f_wav, &f_scal, parameters); + s2let_allocate_f_wav(&f_wav_rec, &f_scal_rec, parameters); + + s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + s2let_lm_random_flm(flm_rec, parameters->L, parameters->spin, seed); + + ssht_core_mw_inverse_sov_sym( + f, + flm, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + ssht_core_mw_inverse_sov_sym( + f_rec, + flm_rec, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + + s2let_analysis_lm2wav(f_wav_rec, f_scal_rec, flm_rec, parameters); + + s2let_synthesis_adjoint_px2wav(f_wav, f_scal, f, parameters); + s2let_synthesis_wav2px(f_rec, f_wav_rec, f_scal_rec, parameters); + + const complex double error = + dot_complex(f_wav_rec, f_wav, s2let_n_wav(parameters)) + + dot_complex(f_scal_rec, f_scal, s2let_n_scal(parameters)) - + dot_complex(f_rec, f, parameters->L * (2 * parameters->L - 1)); + + assert_float_equal(creal(error), 0, 1e-12); + assert_float_equal(cimag(error), 0, 1e-12); + + free(f); + free(f_rec); + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); + free(f_wav_rec); + free(f_scal_rec); +} + +void test_wav_synthesis_adjoint_mw_real(void **state) { + s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + parameters.reality = 1; + + double *f, *f_rec; + complex double *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mw_real(&f, parameters.L); + s2let_allocate_mw_real(&f_rec, parameters.L); + + double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec; + s2let_allocate_f_wav_real(&f_wav, &f_scal, ¶meters); + s2let_allocate_f_wav_real(&f_wav_rec, &f_scal_rec, ¶meters); + + s2let_lm_random_flm_real(flm, parameters.L, seed); + s2let_lm_random_flm_real(flm_rec, parameters.L, seed); + + ssht_core_mw_inverse_sov_sym_real( + f, flm, parameters.L, parameters.dl_method, parameters.verbosity); + ssht_core_mw_inverse_sov_sym_real( + f_rec, flm_rec, parameters.L, parameters.dl_method, parameters.verbosity); + + s2let_analysis_px2wav_real(f_wav_rec, f_scal_rec, f_rec, ¶meters); + + s2let_synthesis_adjoint_px2wav_real(f_wav, f_scal, f, ¶meters); + + s2let_synthesis_wav2px_real(f_rec, f_wav_rec, f_scal_rec, ¶meters); + + const double error = dot_real(f_wav_rec, f_wav, s2let_n_wav(¶meters)) + + dot_real(f_scal_rec, f_scal, s2let_n_scal(¶meters)) - + dot_real(f_rec, f, parameters.L * (2 * parameters.L - 1)); + + assert_float_equal(error, 0, 1e-12); + + free(f); + free(f_rec); + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); + free(f_wav_rec); + free(f_scal_rec); +} + +void gen_flmn_complex( + complex double *flmn, const so3_parameters_t *parameters, int seed) { + int L0, L, N; + int i, el, m, n, n_start, n_stop, n_inc, ind; + + L0 = parameters->L0; + L = parameters->L; + N = parameters->N; + + for (i = 0; i < (2 * N - 1) * L * L; ++i) + flmn[i] = 0.0; + + switch (parameters->n_mode) { + case SO3_N_MODE_ALL: + n_start = -N + 1; + n_stop = N - 1; + n_inc = 1; + break; + case SO3_N_MODE_EVEN: + n_start = ((N - 1) % 2 == 0) ? -N + 1 : -N + 2; + n_stop = ((N - 1) % 2 == 0) ? N - 1 : N - 2; + n_inc = 2; + break; + case SO3_N_MODE_ODD: + n_start = ((N - 1) % 2 != 0) ? -N + 1 : -N + 2; + n_stop = ((N - 1) % 2 != 0) ? N - 1 : N - 2; + n_inc = 2; + break; + case SO3_N_MODE_MAXIMUM: + n_start = -N + 1; + n_stop = N - 1; + n_inc = 2 * N - 2; + break; + default: + SO3_ERROR_GENERIC("Invalid n-mode."); + } + + for (n = n_start; n <= n_stop; n += n_inc) { + for (el = MAX(L0, abs(n)); el < L; ++el) { + for (m = -el; m <= el; ++m) { + so3_sampling_elmn2ind(&ind, el, m, n, parameters); + flmn[ind] = (2.0 * ran2_dp(seed) - 1.0) + I * (2.0 * ran2_dp(seed) - 1.0); + } + } + } +} + +void test_wav_so3_forward_adjoint(void **state) { + const s2let_parameters_t *parameters = (const s2let_parameters_t *)*state; + + so3_parameters_t so3_parameters; + fill_so3_parameters(&so3_parameters, parameters); + + complex double *f, *f_rec, *flmn, *flmn_rec; + flmn = malloc((2 * parameters->N - 1) * parameters->L * parameters->L * sizeof *flmn); + SO3_ERROR_MEM_ALLOC_CHECK(flmn); + flmn_rec = malloc( + (2 * parameters->N - 1) * parameters->L * parameters->L * sizeof *flmn_rec); + SO3_ERROR_MEM_ALLOC_CHECK(flmn_rec); + + f = malloc( + (2 * parameters->L - 1) * (parameters->L) * (2 * parameters->N - 1) * sizeof *f); + SO3_ERROR_MEM_ALLOC_CHECK(f); + f_rec = malloc( + (2 * parameters->L - 1) * (parameters->L) * (2 * parameters->N - 1) * + sizeof *f_rec); + SO3_ERROR_MEM_ALLOC_CHECK(f_rec); + + gen_flmn_complex(flmn, &so3_parameters, seed); + gen_flmn_complex(flmn_rec, &so3_parameters, seed); + + so3_core_inverse_direct(f_rec, flmn_rec, &so3_parameters); + + so3_adjoint_forward_direct(f, flmn, &so3_parameters); + so3_core_forward_direct(flmn_rec, f_rec, &so3_parameters); + + const complex double error = + dot_complex( + f_rec, + f, + (2 * parameters->L - 1) * (parameters->L) * (2 * parameters->N - 1)) - + dot_complex( + flmn_rec, flmn, parameters->L * parameters->L * (2 * parameters->N - 1)); + + assert_float_equal(creal(error), 0, 1e-12); + assert_float_equal(cimag(error), 0, 1e-12); + + free(f); + free(f_rec); + free(flmn); + free(flmn_rec); +} + +static s2let_parameters_t state(int spin, int upsample) { + const s2let_parameters_t parameters = { + .L = 16, + .N = 4, + .B = 2, + .J_min = 2, + .spin = spin, + .original_spin = 0, + .upsample = upsample, + .dl_method = SSHT_DL_RISBO, + .reality = 0, + .sampling_scheme = S2LET_SAMPLING_MW, + }; + return parameters; +}; + +int main(void) { + const s2let_parameters_t spinzero = state(0, 1); + const s2let_parameters_t spintwo = state(2, 1); + const s2let_parameters_t noupsample = state(2, 0); + const struct CMUnitTest tests[] = { + cmocka_unit_test_prestate(test_wav_analysis_adjoint_lm_lmn, (void *)&spinzero), + cmocka_unit_test_prestate(test_wav_analysis_adjoint_lm_lmn, (void *)&spintwo), + cmocka_unit_test_prestate(test_wav_analysis_adjoint_lm_lmn, (void *)&noupsample), + + cmocka_unit_test_prestate(test_wav_analysis_adjoint_mw, (void *)&spinzero), + cmocka_unit_test_prestate(test_wav_analysis_adjoint_mw, (void *)&spintwo), + cmocka_unit_test_prestate(test_wav_analysis_adjoint_mw, (void *)&noupsample), + + cmocka_unit_test_prestate(test_wav_analysis_adjoint_mw_real, (void *)&spinzero), + cmocka_unit_test_prestate(test_wav_analysis_adjoint_mw_real, (void *)&spintwo), + cmocka_unit_test_prestate(test_wav_analysis_adjoint_mw_real, (void *)&noupsample), + + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_lm_lmn, (void *)&spinzero), + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_lm_lmn, (void *)&spintwo), + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_lm_lmn, (void *)&noupsample), + + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_lm2wav, (void *)&spinzero), + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_lm2wav, (void *)&spintwo), + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_lm2wav, (void *)&noupsample), + + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_mw, (void *)&spinzero), + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_mw, (void *)&spintwo), + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_mw, (void *)&noupsample), + + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_mw_real, (void *)&spinzero), + cmocka_unit_test_prestate(test_wav_synthesis_adjoint_mw_real, (void *)&spintwo), + cmocka_unit_test_prestate( + test_wav_synthesis_adjoint_mw_real, (void *)&noupsample), + + cmocka_unit_test_prestate(test_wav_so3_forward_adjoint, (void *)&spinzero), + cmocka_unit_test_prestate(test_wav_so3_forward_adjoint, (void *)&spintwo), + cmocka_unit_test_prestate(test_wav_so3_forward_adjoint, (void *)&noupsample), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/src/test/c/test_axisym_vs_directional.c b/src/test/c/test_axisym_vs_directional.c new file mode 100644 index 00000000..9096d37c --- /dev/null +++ b/src/test/c/test_axisym_vs_directional.c @@ -0,0 +1,128 @@ +#include +#include +#include + +#include "s2let.h" + +#include + +const int seed = 1; + +_Bool min(int a, int b) { return a > b ? b : a; } + +void test_transform_axisym_vs_directional_mw(void **state) { + s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + parameters.upsample = 1; + + int J = s2let_j_max(¶meters); + + double wav_error, scal_error; + + complex double *f, *flm; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_mw(&f, parameters.L); + s2let_lm_random_flm(flm, parameters.L, parameters.spin, seed); + + ssht_core_mw_inverse_sov_sym( + f, + flm, + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); + + complex double *f_wav_axisym, *f_scal_axisym, *f_wav_dir, *f_scal_dir; + s2let_transform_axisym_allocate_mw_f_wav(&f_wav_axisym, &f_scal_axisym, ¶meters); + s2let_allocate_f_wav(&f_wav_dir, &f_scal_dir, ¶meters); + + s2let_transform_axisym_wav_analysis_mw(f_wav_axisym, f_scal_axisym, f, ¶meters); + s2let_analysis_px2wav(f_wav_dir, f_scal_dir, f, ¶meters); + + // Compute the maximum absolute error in the computed wavelet transform + for (int i = 0; + i < (J - parameters.J_min + 1) * parameters.L * (2 * parameters.L - 1); + i += 1) { + assert_float_equal(creal(f_wav_axisym[i]), creal(f_wav_dir[i]), 1e-12); + assert_float_equal(cimag(f_wav_axisym[i]), cimag(f_wav_dir[i]), 1e-12); + } + for (int i = 0; i < parameters.L * (2 * parameters.L - 1); i += 1) { + assert_float_equal(creal(f_scal_axisym[i]), creal(f_scal_dir[i]), 1e-12); + assert_float_equal(cimag(f_scal_axisym[i]), cimag(f_scal_dir[i]), 1e-12); + } +} + +void test_transform_axisym_vs_directional_mw_multires(void **state) { + const s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + + const int J = s2let_j_max(¶meters); + double wav_error, scal_error; + complex double *f, *flm; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_mw(&f, parameters.L); + s2let_lm_random_flm(flm, parameters.L, parameters.spin, seed); + + ssht_core_mw_inverse_sov_sym( + f, + flm, + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); + + complex double *f_wav_axisym, *f_scal_axisym, *f_wav_dir, *f_scal_dir; + s2let_transform_axisym_allocate_mw_f_wav_multires( + &f_wav_axisym, &f_scal_axisym, ¶meters); + s2let_allocate_f_wav(&f_wav_dir, &f_scal_dir, ¶meters); + + s2let_transform_axisym_wav_analysis_mw_multires( + f_wav_axisym, f_scal_axisym, f, ¶meters); + s2let_analysis_px2wav(f_wav_dir, f_scal_dir, f, ¶meters); + + int samples = 0; + for (int j = parameters.J_min; j <= J; ++j) { + const int bandlim = min(s2let_bandlimit(j, ¶meters), parameters.L); + samples += bandlim * (2 * bandlim - 1); + } + + // Compute the maximum absolute error in the computed wavelet transform + for (int i = 0; i < samples; i += 1) { + assert_float_equal(creal(f_wav_axisym[i]), creal(f_wav_dir[i]), 1e-12); + assert_float_equal(cimag(f_wav_axisym[i]), cimag(f_wav_dir[i]), 1e-12); + } + const int bandlimit = + min(s2let_bandlimit(parameters.J_min - 1, ¶meters), parameters.L); + for (int i = 0; i < bandlimit * (2 * bandlimit - 1); i += 1) { + assert_float_equal(creal(f_scal_axisym[i]), creal(f_scal_dir[i]), 1e-12); + assert_float_equal(cimag(f_scal_axisym[i]), cimag(f_scal_dir[i]), 1e-12); + } + + free(flm); + free(f); + free(f_wav_axisym); + free(f_scal_axisym); + free(f_wav_dir); + free(f_scal_dir); +} + +int main(void) { + const s2let_parameters_t state = { + .L = 16, + .N = 1, + .B = 2, + .J_min = 2, + .spin = 0, + .original_spin = 0, + .upsample = 0, + .dl_method = SSHT_DL_RISBO, + .reality = 0, + .sampling_scheme = S2LET_SAMPLING_MW, + }; + const struct CMUnitTest tests[] = { + cmocka_unit_test_prestate( + test_transform_axisym_vs_directional_mw, (void **)&state), + cmocka_unit_test_prestate( + test_transform_axisym_vs_directional_mw_multires, (void **)&state), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/src/test/c/test_back_and_forth.c b/src/test/c/test_back_and_forth.c new file mode 100644 index 00000000..978cea89 --- /dev/null +++ b/src/test/c/test_back_and_forth.c @@ -0,0 +1,632 @@ +#include +#include +#include + +#include "s2let.h" + +#include + +const int seed = 1; + +void test_transform_axisym_lm_wav(void **state) { + const s2let_parameters_t *const parameters = (const s2let_parameters_t *)*state; + + double *wav_lm, *scal_lm; + + // Allocate the wavelet kernels + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + + // Compute the wavelet kernels + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *f_wav_lm, *f_scal_lm, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + + // Generate a random spherical harmonic decomposition + s2let_lm_random_flm(flm, parameters->L, 0, seed); + + // Allocate space for the wavelet scales (their harmonic coefficients) + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + + // Perform the wavelet transform through exact harmonic tiling + s2let_transform_axisym_lm_wav_analysis( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + + // Reconstruct the initial harmonic coefficients from those of the wavelets + s2let_transform_axisym_lm_wav_synthesis( + flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + + // Compute the maximum absolute error on the harmonic coefficients + for (int i = 0; i < parameters->L * parameters->L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(flm); + free(flm_rec); + free(f_wav_lm); + free(f_scal_lm); + free(wav_lm); + free(scal_lm); +} + +void test_transform_axisym_lm_wav_multires(void **state) { + const s2let_parameters_t *const parameters = (const s2let_parameters_t *)*state; + + double *wav_lm, *scal_lm; + + // Allocate the wavelet kernels + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + + // Compute the wavelet kernels + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *f_wav_lm, *f_scal_lm, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + + // Generate a random spherical harmonic decomposition + s2let_lm_random_flm(flm, parameters->L, 0, seed); + + // Allocate space for the wavelet scales (their harmonic coefficients) + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + + // Perform the wavelet transform through exact harmonic tiling + s2let_transform_axisym_lm_wav_analysis_multires( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + + // Reconstruct the initial harmonic coefficients from those of the wavelets + s2let_transform_axisym_lm_wav_synthesis_multires( + flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + + // Compute the maximum absolute error on the harmonic coefficients + for (int i = 0; i < parameters->L * parameters->L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(flm); + free(flm_rec); + free(f_wav_lm); + free(f_scal_lm); + free(wav_lm); + free(scal_lm); +} + +void test_wav_transform_wavlm_manual(void **state) { + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + + const int J = s2let_j_max(parameters) - parameters->J_min; + + complex double *psi; + double *phi; + s2let_tiling_wavelet_allocate(&psi, &phi, parameters); + s2let_tiling_wavelet(psi, phi, parameters); + + const int scal_bandlimit = + parameters->upsample + ? parameters->L + : MIN(s2let_bandlimit(parameters->J_min - 1, parameters), parameters->L); + + complex double *wav_l = (complex double *)calloc( + (J + 1) * parameters->L * parameters->L, sizeof(complex double)); + int *wav_bandlimits = (int *)calloc(J + 1, sizeof(int)); + for (int j = 0; j <= J; ++j) { + wav_bandlimits[j] = + parameters->upsample + ? parameters->L + : MIN(s2let_bandlimit(parameters->J_min + j, parameters), parameters->L); + for (int i = 0; i < parameters->L * parameters->L; ++i) + wav_l[j * parameters->L * parameters->L + i] = + psi[(parameters->J_min + j) * parameters->L * parameters->L + i]; + } + + complex double *f_wav, *f_scal, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + + // Generate a random spherical harmonic decomposition + s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + + // Allocate space for the wavelet scales (their harmonic/Wigner coefficients) + s2let_allocate_f_wav_manual( + &f_wav, &f_scal, wav_bandlimits, scal_bandlimit, parameters->N, J, parameters); + + // Perform the wavelet transform through exact harmonic tiling + s2let_analysis_lm2wav_manual( + f_wav, + f_scal, + flm, + phi, + wav_l, + scal_bandlimit, + wav_bandlimits, + J, + parameters->L, + parameters->spin, + parameters->N); + + // Reconstruct the initial harmonic coefficients from those of the wavelets + s2let_synthesis_wav2lm_manual( + flm_rec, + f_wav, + f_scal, + phi, + wav_l, + scal_bandlimit, + wav_bandlimits, + J, + parameters->L, + parameters->spin, + parameters->N); + + for (int i = 0; i < parameters->L * parameters->L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); + free(psi); + free(phi); +} + +void test_wav_transform_harmonic(void **state) { + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + complex double *psi; + double *phi; + s2let_tiling_wavelet_allocate(&psi, &phi, parameters); + s2let_tiling_wavelet(psi, phi, parameters); + + complex double *f_wav_lmn, *f_scal_lm, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); + s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, psi, phi, parameters); + s2let_synthesis_lmn2lm(flm_rec, f_wav_lmn, f_scal_lm, psi, phi, parameters); + + for (int i = 0; i < parameters->L * parameters->L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(flm); + free(flm_rec); + free(f_wav_lmn); + free(f_scal_lm); + free(psi); + free(phi); +} + +void test_transform_axisym_wav(void **state) { + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + if (parameters->spin != 0) + skip(); + + complex double *f, *f_rec, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + s2let_allocate_mw(&f, parameters->L); + s2let_allocate_mw(&f_rec, parameters->L); + s2let_lm_random_flm(flm, parameters->L, 0, seed); + + ssht_core_mw_inverse_sov_sym( + f, + flm, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + + complex double *f_wav, *f_scal; + s2let_transform_axisym_allocate_mw_f_wav(&f_wav, &f_scal, parameters); + s2let_transform_axisym_wav_analysis_mw(f_wav, f_scal, f, parameters); + s2let_transform_axisym_wav_synthesis_mw(f_rec, f_wav, f_scal, parameters); + + ssht_core_mw_forward_sov_conv_sym( + flm_rec, + f_rec, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + + for (int i = 0; i < parameters->L * parameters->L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(f); + free(f_rec); + free(f_wav); + free(f_scal); +} + +void test_transform_axisym_wav_real(void **state) { + s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + parameters.reality = 1; + + complex double *flm, *flm_rec; + double *f, *f_rec; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mw_real(&f, parameters.L); + s2let_allocate_mw_real(&f_rec, parameters.L); + + s2let_lm_random_flm_real(flm, parameters.L, seed); + + ssht_core_mw_inverse_sov_sym_real( + f, flm, parameters.L, parameters.dl_method, parameters.verbosity); + + double *f_wav, *f_scal; + s2let_transform_axisym_allocate_mw_f_wav_real(&f_wav, &f_scal, ¶meters); + s2let_transform_axisym_wav_analysis_mw_real(f_wav, f_scal, f, ¶meters); + s2let_transform_axisym_wav_synthesis_mw_real(f_rec, f_wav, f_scal, ¶meters); + + ssht_core_mw_forward_sov_conv_sym_real( + flm_rec, f_rec, parameters.L, parameters.dl_method, parameters.verbosity); + + for (int i = 0; i < parameters.L * parameters.L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(f); + free(f_rec); + free(f_wav); + free(f_scal); +} + +void test_transform_axisym_wav_multires(void **state) { + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + if (parameters->spin != 0) + skip(); + + complex double *f, *f_rec, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + s2let_allocate_mw(&f, parameters->L); + s2let_allocate_mw(&f_rec, parameters->L); + s2let_lm_random_flm(flm, parameters->L, 0, seed); + + ssht_core_mw_inverse_sov_sym( + f, + flm, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + + complex double *f_wav, *f_scal; + s2let_transform_axisym_allocate_mw_f_wav_multires(&f_wav, &f_scal, parameters); + s2let_transform_axisym_wav_analysis_mw_multires(f_wav, f_scal, f, parameters); + s2let_transform_axisym_wav_synthesis_mw_multires(f_rec, f_wav, f_scal, parameters); + + ssht_core_mw_forward_sov_conv_sym( + flm_rec, + f_rec, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + + for (int i = 0; i < parameters->L * parameters->L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(f); + free(f_rec); + free(f_wav); + free(f_scal); +} + +void test_transform_axisym_wav_multires_real(void **state) { + s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + parameters.reality = 1; + + complex double *flm, *flm_rec; + double *f, *f_rec; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mw_real(&f, parameters.L); + s2let_allocate_mw_real(&f_rec, parameters.L); + + s2let_lm_random_flm_real(flm, parameters.L, seed); + + ssht_core_mw_inverse_sov_sym_real( + f, flm, parameters.L, parameters.dl_method, parameters.verbosity); + + double *f_wav, *f_scal; + s2let_transform_axisym_allocate_mw_f_wav_multires_real(&f_wav, &f_scal, ¶meters); + s2let_transform_axisym_wav_analysis_mw_multires_real(f_wav, f_scal, f, ¶meters); + s2let_transform_axisym_wav_synthesis_mw_multires_real( + f_rec, f_wav, f_scal, ¶meters); + + ssht_core_mw_forward_sov_conv_sym_real( + flm_rec, f_rec, parameters.L, parameters.dl_method, parameters.verbosity); + + for (int i = 0; i < parameters.L * parameters.L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(f); + free(f_rec); + free(f_wav); + free(f_scal); +} + +void test_wav_transform_mw(void **state) { + s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + + complex double *f, *f_rec, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters->L); + s2let_allocate_lm(&flm_rec, parameters->L); + s2let_allocate_mw(&f, parameters->L); + s2let_allocate_mw(&f_rec, parameters->L); + + s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + + ssht_core_mw_inverse_sov_sym( + f, + flm, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + + complex double *f_wav, *f_scal; + s2let_allocate_f_wav(&f_wav, &f_scal, parameters); + s2let_analysis_px2wav(f_wav, f_scal, f, parameters); + s2let_synthesis_wav2px(f_rec, f_wav, f_scal, parameters); + + ssht_core_mw_forward_sov_conv_sym( + flm_rec, + f_rec, + parameters->L, + parameters->spin, + parameters->dl_method, + parameters->verbosity); + + for (int i = 0; i < parameters->L * parameters->L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(f); + free(f_rec); + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); +} + +void test_wav_transform_mw_real(void **state) { + s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + parameters.reality = 1; + if (parameters.spin != 0) + skip(); + + double *f, *f_rec; + complex double *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mw_real(&f, parameters.L); + s2let_allocate_mw_real(&f_rec, parameters.L); + + s2let_lm_random_flm_real(flm, parameters.L, seed); + + ssht_core_mw_inverse_sov_sym_real( + f, flm, parameters.L, parameters.dl_method, parameters.verbosity); + + double *f_wav, *f_scal; + s2let_allocate_f_wav_real(&f_wav, &f_scal, ¶meters); + s2let_analysis_px2wav_real(f_wav, f_scal, f, ¶meters); + s2let_synthesis_wav2px_real(f_rec, f_wav, f_scal, ¶meters); + + ssht_core_mw_forward_sov_conv_sym_real( + flm_rec, f_rec, parameters.L, parameters.dl_method, parameters.verbosity); + + for (int i = 0; i < parameters.L * parameters.L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(f); + free(f_rec); + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); +} + +void test_wav_transform_mwss(void **state) { + skip(); + s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + parameters.sampling_scheme = S2LET_SAMPLING_MW_SS; + + complex double *f, *f_rec, *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mwss(&f, parameters.L); + s2let_allocate_mwss(&f_rec, parameters.L); + + s2let_lm_random_flm(flm, parameters.L, parameters.spin, seed); + + ssht_core_mw_inverse_sov_sym_ss( + f, + flm, + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); + + complex double *f_wav, *f_scal; + s2let_allocate_f_wav(&f_wav, &f_scal, ¶meters); + s2let_analysis_px2wav(f_wav, f_scal, f, ¶meters); + s2let_synthesis_wav2px(f_rec, f_wav, f_scal, ¶meters); + + ssht_core_mw_forward_sov_conv_sym_ss( + flm_rec, + f_rec, + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); + + for (int i = 0; i < parameters.L * parameters.L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(f); + free(f_rec); + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); +} + +void test_wav_transform_mwss_real(void **state) { + s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + parameters.sampling_scheme = S2LET_SAMPLING_MW_SS; + if (parameters.spin != 0) + skip(); + + double *f, *f_rec; + complex double *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mwss_real(&f, parameters.L); + s2let_allocate_mwss_real(&f_rec, parameters.L); + + s2let_lm_random_flm_real(flm, parameters.L, seed); + ssht_core_mw_inverse_sov_sym_ss_real( + f, flm, parameters.L, parameters.dl_method, parameters.verbosity); + + double *f_wav, *f_scal; + s2let_allocate_f_wav_real(&f_wav, &f_scal, ¶meters); + s2let_analysis_px2wav_real(f_wav, f_scal, f, ¶meters); + s2let_synthesis_wav2px_real(f_rec, f_wav, f_scal, ¶meters); + + ssht_core_mw_forward_sov_conv_sym_ss_real( + flm_rec, f_rec, parameters.L, parameters.dl_method, parameters.verbosity); + + for (int i = 0; i < parameters.L * parameters.L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(f); + free(f_rec); + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); +} + +void test_wav_transform_lm2wav(void **state) { + const s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + complex double *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_lm_random_flm(flm, parameters.L, parameters.spin, seed); + + complex double *f_wav, *f_scal; + s2let_allocate_f_wav(&f_wav, &f_scal, ¶meters); + + s2let_analysis_lm2wav(f_wav, f_scal, flm, ¶meters); + s2let_synthesis_wav2lm(flm_rec, f_wav, f_scal, ¶meters); + + for (int i = 0; i < parameters.L * parameters.L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); +} + +void test_wav_transform_lm2wav_real(void **state) { + s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + parameters.reality = 1; + if (parameters.spin != 0) + skip(); + + complex double *flm, *flm_rec; + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_lm_random_flm_real(flm, parameters.L, seed); + + double *f_wav, *f_scal; + s2let_allocate_f_wav_real(&f_wav, &f_scal, ¶meters); + s2let_analysis_lm2wav_real(f_wav, f_scal, flm, ¶meters); + s2let_synthesis_wav2lm_real(flm_rec, f_wav, f_scal, ¶meters); + + for (int i = 0; i < parameters.L * parameters.L; i += 1) { + assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); + assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); + } + + free(flm); + free(flm_rec); + free(f_wav); + free(f_scal); +} + +static s2let_parameters_t state(int spin, int upsample) { + const s2let_parameters_t parameters = { + .L = 16, + .N = 4, + .B = 2, + .J_min = 2, + .spin = spin, + .original_spin = 0, + .upsample = upsample, + .dl_method = SSHT_DL_RISBO, + .reality = 0, + .sampling_scheme = S2LET_SAMPLING_MW, + }; + return parameters; +}; + +int main(void) { + const s2let_parameters_t spinzero = state(0, 1); + const s2let_parameters_t spinzero_noupsample = state(0, 0); + const s2let_parameters_t spintwo = state(2, 1); + const s2let_parameters_t spintwo_noupsample = state(2, 0); + +#define S2LET_TESTS(name) \ + cmocka_unit_test_prestate(name, (void *)&spinzero_noupsample), \ + cmocka_unit_test_prestate(name, (void *)&spinzero), \ + cmocka_unit_test_prestate(name, (void *)&spintwo), \ + cmocka_unit_test_prestate(name, (void *)&spintwo_noupsample) + + const struct CMUnitTest tests[] = { + S2LET_TESTS(test_transform_axisym_lm_wav), + S2LET_TESTS(test_transform_axisym_lm_wav_multires), + S2LET_TESTS(test_wav_transform_wavlm_manual), + S2LET_TESTS(test_wav_transform_harmonic), + S2LET_TESTS(test_transform_axisym_wav), + S2LET_TESTS(test_transform_axisym_wav_multires), + S2LET_TESTS(test_transform_axisym_wav_real), + S2LET_TESTS(test_transform_axisym_wav_multires_real), + S2LET_TESTS(test_wav_transform_mw), + S2LET_TESTS(test_wav_transform_mw_real), + S2LET_TESTS(test_wav_transform_mwss), + S2LET_TESTS(test_wav_transform_mwss_real), + S2LET_TESTS(test_wav_transform_lm2wav), + S2LET_TESTS(test_wav_transform_lm2wav_real), + }; +#undef S2LET_TESTS + + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/src/test/c/test_tiling.c b/src/test/c/test_tiling.c new file mode 100644 index 00000000..95b65ed8 --- /dev/null +++ b/src/test/c/test_tiling.c @@ -0,0 +1,101 @@ +#include +#include +#include + +#include "s2let.h" + +#include + +const int seed = 1; + +/*! Identity relation of the wavelet tiling in harmonic space */ +void test_tiling_axisym(void **state) { + const s2let_parameters_t *const parameters = (const s2let_parameters_t *)*state; + + double *kappa, *kappa0; + + // Allocate the kernels corresponding to the parameters B, L + s2let_tiling_axisym_allocate(&kappa, &kappa0, parameters); + + // Construct the tiling of harmonic space + s2let_tiling_axisym(kappa, kappa0, parameters); + + // Check that they recover the identity relation, + // ensuring exactness of the wavelet transform. + double res = s2let_tiling_axisym_check_identity(kappa, kappa0, parameters); + assert_float_equal(res, 0, 1e-12); + + free(kappa); + free(kappa0); +} + +/*! Identity relation of the directionality components for tiling in harmonic space. */ +void test_tiling_direction(void **state) { + const s2let_parameters_t *const parameters = (const s2let_parameters_t *)*state; + + complex double *s_elm; + double error; + + // Allocate space for the harmonic coefficients + s2let_tiling_direction_allocate(&s_elm, parameters); + + // Construct the harmonic coefficients + s2let_tiling_direction(s_elm, parameters); + + // Check that they recover the identity relation, + // ensuring exactness of the wavelet transform. + error = s2let_tiling_direction_check_identity(s_elm, parameters); + assert_float_equal(error, 0, 1e-12); + + free(s_elm); +} + +/*! Identity relation of the directional wavelets for tiling in harmonic space. */ +void test_tiling_wavelet(void **state) { + const s2let_parameters_t *const parameters = (const s2let_parameters_t *)*state; + + complex double *phi; + double *psi; + double error; + + // Allocate space for the harmonic coefficients + s2let_tiling_wavelet_allocate(&phi, &psi, parameters); + + // Construct the harmonic coefficients + s2let_tiling_wavelet(phi, psi, parameters); + + // Check that they recover the identity relation, + // ensuring exactness of the wavelet transform. + error = s2let_tiling_wavelet_check_identity(phi, psi, parameters); + assert_float_equal(error, 0, 1e-12); + + free(phi); + free(psi); +} + +void test_binomial_coefficient(void **state) { + for (int n = 1; n <= 62; ++n) + for (int k = 0; k <= n / 2; ++k) + assert_float_equal( + binomial_coefficient(n, k, 0), binomial_coefficient(n, k, 1), 1e-12); +} + +int main(void) { + const s2let_parameters_t state = { + .L = 16, + .N = 4, + .B = 2, + .J_min = 2, + .spin = 0, + .original_spin = 0, + }; + + const struct CMUnitTest tests[] = { + cmocka_unit_test_prestate(test_tiling_axisym, (void *)&state), + cmocka_unit_test_prestate(test_tiling_direction, (void *)&state), + cmocka_unit_test_prestate(test_tiling_wavelet, (void *)&state), + cmocka_unit_test(test_binomial_coefficient), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +} From 89345713d297d90cb48d46020381ae07deb52e6d Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Wed, 14 Oct 2020 23:01:51 +0100 Subject: [PATCH 02/23] Missing const specifier --- include/s2let_alloc.h | 2 +- src/main/c/s2let_alloc.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/s2let_alloc.h b/include/s2let_alloc.h index 28f114eb..bb70e3ca 100644 --- a/include/s2let_alloc.h +++ b/include/s2let_alloc.h @@ -48,7 +48,7 @@ void s2let_allocate_f_wav_manual( int scal_bandlimit, int N, int J, - s2let_parameters_t* parameters); + const s2let_parameters_t* parameters); #ifdef __cplusplus } diff --git a/src/main/c/s2let_alloc.c b/src/main/c/s2let_alloc.c index 05685867..c218b750 100644 --- a/src/main/c/s2let_alloc.c +++ b/src/main/c/s2let_alloc.c @@ -160,7 +160,7 @@ void s2let_allocate_f_wav_manual( int scal_bandlimit, int N, int J, - s2let_parameters_t *parameters + const s2let_parameters_t *parameters ) { so3_parameters_t so3_parameters = {}; From 9c7b7b619a14a72763585425a03a7c495c2880cc Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Wed, 14 Oct 2020 23:02:01 +0100 Subject: [PATCH 03/23] Simplified and removed some tests --- src/test/c/test_back_and_forth.c | 242 +++++++++++++++---------------- 1 file changed, 118 insertions(+), 124 deletions(-) diff --git a/src/test/c/test_back_and_forth.c b/src/test/c/test_back_and_forth.c index 978cea89..849494d9 100644 --- a/src/test/c/test_back_and_forth.c +++ b/src/test/c/test_back_and_forth.c @@ -9,36 +9,36 @@ const int seed = 1; void test_transform_axisym_lm_wav(void **state) { - const s2let_parameters_t *const parameters = (const s2let_parameters_t *)*state; + const s2let_parameters_t parameters = *(s2let_parameters_t *)*state; double *wav_lm, *scal_lm; // Allocate the wavelet kernels - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, ¶meters); // Compute the wavelet kernels - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, ¶meters); complex double *f_wav_lm, *f_scal_lm, *flm, *flm_rec; - s2let_allocate_lm(&flm, parameters->L); - s2let_allocate_lm(&flm_rec, parameters->L); + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); // Generate a random spherical harmonic decomposition - s2let_lm_random_flm(flm, parameters->L, 0, seed); + s2let_lm_random_flm(flm, parameters.L, 0, seed); // Allocate space for the wavelet scales (their harmonic coefficients) - s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, ¶meters); // Perform the wavelet transform through exact harmonic tiling s2let_transform_axisym_lm_wav_analysis( - f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, ¶meters); // Reconstruct the initial harmonic coefficients from those of the wavelets s2let_transform_axisym_lm_wav_synthesis( - flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, ¶meters); // Compute the maximum absolute error on the harmonic coefficients - for (int i = 0; i < parameters->L * parameters->L; i += 1) { + for (int i = 0; i < parameters.L * parameters.L; i += 1) { assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); } @@ -52,36 +52,36 @@ void test_transform_axisym_lm_wav(void **state) { } void test_transform_axisym_lm_wav_multires(void **state) { - const s2let_parameters_t *const parameters = (const s2let_parameters_t *)*state; + const s2let_parameters_t parameters = *(s2let_parameters_t *)*state; double *wav_lm, *scal_lm; // Allocate the wavelet kernels - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, ¶meters); // Compute the wavelet kernels - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, ¶meters); complex double *f_wav_lm, *f_scal_lm, *flm, *flm_rec; - s2let_allocate_lm(&flm, parameters->L); - s2let_allocate_lm(&flm_rec, parameters->L); + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); // Generate a random spherical harmonic decomposition - s2let_lm_random_flm(flm, parameters->L, 0, seed); + s2let_lm_random_flm(flm, parameters.L, 0, seed); // Allocate space for the wavelet scales (their harmonic coefficients) - s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, ¶meters); // Perform the wavelet transform through exact harmonic tiling s2let_transform_axisym_lm_wav_analysis_multires( - f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, ¶meters); // Reconstruct the initial harmonic coefficients from those of the wavelets s2let_transform_axisym_lm_wav_synthesis_multires( - flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, ¶meters); // Compute the maximum absolute error on the harmonic coefficients - for (int i = 0; i < parameters->L * parameters->L; i += 1) { + for (int i = 0; i < parameters.L * parameters.L; i += 1) { assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); } @@ -95,43 +95,43 @@ void test_transform_axisym_lm_wav_multires(void **state) { } void test_wav_transform_wavlm_manual(void **state) { - s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + const s2let_parameters_t parameters = *(s2let_parameters_t *)*state; - const int J = s2let_j_max(parameters) - parameters->J_min; + const int J = s2let_j_max(¶meters) - parameters.J_min; complex double *psi; double *phi; - s2let_tiling_wavelet_allocate(&psi, &phi, parameters); - s2let_tiling_wavelet(psi, phi, parameters); + s2let_tiling_wavelet_allocate(&psi, &phi, ¶meters); + s2let_tiling_wavelet(psi, phi, ¶meters); const int scal_bandlimit = - parameters->upsample - ? parameters->L - : MIN(s2let_bandlimit(parameters->J_min - 1, parameters), parameters->L); + parameters.upsample + ? parameters.L + : MIN(s2let_bandlimit(parameters.J_min - 1, ¶meters), parameters.L); complex double *wav_l = (complex double *)calloc( - (J + 1) * parameters->L * parameters->L, sizeof(complex double)); + (J + 1) * parameters.L * parameters.L, sizeof(complex double)); int *wav_bandlimits = (int *)calloc(J + 1, sizeof(int)); for (int j = 0; j <= J; ++j) { wav_bandlimits[j] = - parameters->upsample - ? parameters->L - : MIN(s2let_bandlimit(parameters->J_min + j, parameters), parameters->L); - for (int i = 0; i < parameters->L * parameters->L; ++i) - wav_l[j * parameters->L * parameters->L + i] = - psi[(parameters->J_min + j) * parameters->L * parameters->L + i]; + parameters.upsample + ? parameters.L + : MIN(s2let_bandlimit(parameters.J_min + j, ¶meters), parameters.L); + for (int i = 0; i < parameters.L * parameters.L; ++i) + wav_l[j * parameters.L * parameters.L + i] = + psi[(parameters.J_min + j) * parameters.L * parameters.L + i]; } complex double *f_wav, *f_scal, *flm, *flm_rec; - s2let_allocate_lm(&flm, parameters->L); - s2let_allocate_lm(&flm_rec, parameters->L); + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); // Generate a random spherical harmonic decomposition - s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + s2let_lm_random_flm(flm, parameters.L, parameters.spin, seed); // Allocate space for the wavelet scales (their harmonic/Wigner coefficients) s2let_allocate_f_wav_manual( - &f_wav, &f_scal, wav_bandlimits, scal_bandlimit, parameters->N, J, parameters); + &f_wav, &f_scal, wav_bandlimits, scal_bandlimit, parameters.N, J, ¶meters); // Perform the wavelet transform through exact harmonic tiling s2let_analysis_lm2wav_manual( @@ -143,9 +143,9 @@ void test_wav_transform_wavlm_manual(void **state) { scal_bandlimit, wav_bandlimits, J, - parameters->L, - parameters->spin, - parameters->N); + parameters.L, + parameters.spin, + parameters.N); // Reconstruct the initial harmonic coefficients from those of the wavelets s2let_synthesis_wav2lm_manual( @@ -157,11 +157,11 @@ void test_wav_transform_wavlm_manual(void **state) { scal_bandlimit, wav_bandlimits, J, - parameters->L, - parameters->spin, - parameters->N); + parameters.L, + parameters.spin, + parameters.N); - for (int i = 0; i < parameters->L * parameters->L; i += 1) { + for (int i = 0; i < parameters.L * parameters.L; i += 1) { assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); } @@ -175,22 +175,22 @@ void test_wav_transform_wavlm_manual(void **state) { } void test_wav_transform_harmonic(void **state) { - s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + const s2let_parameters_t parameters = *(s2let_parameters_t *)*state; complex double *psi; double *phi; - s2let_tiling_wavelet_allocate(&psi, &phi, parameters); - s2let_tiling_wavelet(psi, phi, parameters); + s2let_tiling_wavelet_allocate(&psi, &phi, ¶meters); + s2let_tiling_wavelet(psi, phi, ¶meters); complex double *f_wav_lmn, *f_scal_lm, *flm, *flm_rec; - s2let_allocate_lm(&flm, parameters->L); - s2let_allocate_lm(&flm_rec, parameters->L); - s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_lm_random_flm(flm, parameters.L, parameters.spin, seed); - s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); - s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, psi, phi, parameters); - s2let_synthesis_lmn2lm(flm_rec, f_wav_lmn, f_scal_lm, psi, phi, parameters); + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, ¶meters); + s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, psi, phi, ¶meters); + s2let_synthesis_lmn2lm(flm_rec, f_wav_lmn, f_scal_lm, psi, phi, ¶meters); - for (int i = 0; i < parameters->L * parameters->L; i += 1) { + for (int i = 0; i < parameters.L * parameters.L; i += 1) { assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); } @@ -204,39 +204,37 @@ void test_wav_transform_harmonic(void **state) { } void test_transform_axisym_wav(void **state) { - s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; - if (parameters->spin != 0) - skip(); + const s2let_parameters_t parameters = *(s2let_parameters_t *)*state; complex double *f, *f_rec, *flm, *flm_rec; - s2let_allocate_lm(&flm, parameters->L); - s2let_allocate_lm(&flm_rec, parameters->L); - s2let_allocate_mw(&f, parameters->L); - s2let_allocate_mw(&f_rec, parameters->L); - s2let_lm_random_flm(flm, parameters->L, 0, seed); + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mw(&f, parameters.L); + s2let_allocate_mw(&f_rec, parameters.L); + s2let_lm_random_flm(flm, parameters.L, parameters.spin, seed); ssht_core_mw_inverse_sov_sym( f, flm, - parameters->L, - parameters->spin, - parameters->dl_method, - parameters->verbosity); + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); complex double *f_wav, *f_scal; - s2let_transform_axisym_allocate_mw_f_wav(&f_wav, &f_scal, parameters); - s2let_transform_axisym_wav_analysis_mw(f_wav, f_scal, f, parameters); - s2let_transform_axisym_wav_synthesis_mw(f_rec, f_wav, f_scal, parameters); + s2let_transform_axisym_allocate_mw_f_wav(&f_wav, &f_scal, ¶meters); + s2let_transform_axisym_wav_analysis_mw(f_wav, f_scal, f, ¶meters); + s2let_transform_axisym_wav_synthesis_mw(f_rec, f_wav, f_scal, ¶meters); ssht_core_mw_forward_sov_conv_sym( flm_rec, f_rec, - parameters->L, - parameters->spin, - parameters->dl_method, - parameters->verbosity); + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); - for (int i = 0; i < parameters->L * parameters->L; i += 1) { + for (int i = 0; i < parameters.L * parameters.L; i += 1) { assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); } @@ -283,39 +281,39 @@ void test_transform_axisym_wav_real(void **state) { } void test_transform_axisym_wav_multires(void **state) { - s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; - if (parameters->spin != 0) + const s2let_parameters_t parameters = *(s2let_parameters_t *)*state; + if (parameters.spin != 0) skip(); complex double *f, *f_rec, *flm, *flm_rec; - s2let_allocate_lm(&flm, parameters->L); - s2let_allocate_lm(&flm_rec, parameters->L); - s2let_allocate_mw(&f, parameters->L); - s2let_allocate_mw(&f_rec, parameters->L); - s2let_lm_random_flm(flm, parameters->L, 0, seed); + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mw(&f, parameters.L); + s2let_allocate_mw(&f_rec, parameters.L); + s2let_lm_random_flm(flm, parameters.L, 0, seed); ssht_core_mw_inverse_sov_sym( f, flm, - parameters->L, - parameters->spin, - parameters->dl_method, - parameters->verbosity); + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); complex double *f_wav, *f_scal; - s2let_transform_axisym_allocate_mw_f_wav_multires(&f_wav, &f_scal, parameters); - s2let_transform_axisym_wav_analysis_mw_multires(f_wav, f_scal, f, parameters); - s2let_transform_axisym_wav_synthesis_mw_multires(f_rec, f_wav, f_scal, parameters); + s2let_transform_axisym_allocate_mw_f_wav_multires(&f_wav, &f_scal, ¶meters); + s2let_transform_axisym_wav_analysis_mw_multires(f_wav, f_scal, f, ¶meters); + s2let_transform_axisym_wav_synthesis_mw_multires(f_rec, f_wav, f_scal, ¶meters); ssht_core_mw_forward_sov_conv_sym( flm_rec, f_rec, - parameters->L, - parameters->spin, - parameters->dl_method, - parameters->verbosity); + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); - for (int i = 0; i < parameters->L * parameters->L; i += 1) { + for (int i = 0; i < parameters.L * parameters.L; i += 1) { assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); } @@ -363,38 +361,38 @@ void test_transform_axisym_wav_multires_real(void **state) { } void test_wav_transform_mw(void **state) { - s2let_parameters_t *const parameters = (s2let_parameters_t *)*state; + const s2let_parameters_t parameters = *(s2let_parameters_t *)*state; complex double *f, *f_rec, *flm, *flm_rec; - s2let_allocate_lm(&flm, parameters->L); - s2let_allocate_lm(&flm_rec, parameters->L); - s2let_allocate_mw(&f, parameters->L); - s2let_allocate_mw(&f_rec, parameters->L); + s2let_allocate_lm(&flm, parameters.L); + s2let_allocate_lm(&flm_rec, parameters.L); + s2let_allocate_mw(&f, parameters.L); + s2let_allocate_mw(&f_rec, parameters.L); - s2let_lm_random_flm(flm, parameters->L, parameters->spin, seed); + s2let_lm_random_flm(flm, parameters.L, parameters.spin, seed); ssht_core_mw_inverse_sov_sym( f, flm, - parameters->L, - parameters->spin, - parameters->dl_method, - parameters->verbosity); + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); complex double *f_wav, *f_scal; - s2let_allocate_f_wav(&f_wav, &f_scal, parameters); - s2let_analysis_px2wav(f_wav, f_scal, f, parameters); - s2let_synthesis_wav2px(f_rec, f_wav, f_scal, parameters); + s2let_allocate_f_wav(&f_wav, &f_scal, ¶meters); + s2let_analysis_px2wav(f_wav, f_scal, f, ¶meters); + s2let_synthesis_wav2px(f_rec, f_wav, f_scal, ¶meters); ssht_core_mw_forward_sov_conv_sym( flm_rec, f_rec, - parameters->L, - parameters->spin, - parameters->dl_method, - parameters->verbosity); + parameters.L, + parameters.spin, + parameters.dl_method, + parameters.verbosity); - for (int i = 0; i < parameters->L * parameters->L; i += 1) { + for (int i = 0; i < parameters.L * parameters.L; i += 1) { assert_float_equal(creal(flm[i]), creal(flm_rec[i]), 1e-12); assert_float_equal(cimag(flm[i]), cimag(flm_rec[i]), 1e-12); } @@ -410,8 +408,6 @@ void test_wav_transform_mw(void **state) { void test_wav_transform_mw_real(void **state) { s2let_parameters_t parameters = *(s2let_parameters_t *)*state; parameters.reality = 1; - if (parameters.spin != 0) - skip(); double *f, *f_rec; complex double *flm, *flm_rec; @@ -496,8 +492,6 @@ void test_wav_transform_mwss(void **state) { void test_wav_transform_mwss_real(void **state) { s2let_parameters_t parameters = *(s2let_parameters_t *)*state; parameters.sampling_scheme = S2LET_SAMPLING_MW_SS; - if (parameters.spin != 0) - skip(); double *f, *f_rec; complex double *flm, *flm_rec; @@ -558,8 +552,6 @@ void test_wav_transform_lm2wav(void **state) { void test_wav_transform_lm2wav_real(void **state) { s2let_parameters_t parameters = *(s2let_parameters_t *)*state; parameters.reality = 1; - if (parameters.spin != 0) - skip(); complex double *flm, *flm_rec; s2let_allocate_lm(&flm, parameters.L); @@ -604,29 +596,31 @@ int main(void) { const s2let_parameters_t spintwo = state(2, 1); const s2let_parameters_t spintwo_noupsample = state(2, 0); + const struct CMUnitTest tests[] = { #define S2LET_TESTS(name) \ cmocka_unit_test_prestate(name, (void *)&spinzero_noupsample), \ cmocka_unit_test_prestate(name, (void *)&spinzero), \ cmocka_unit_test_prestate(name, (void *)&spintwo), \ cmocka_unit_test_prestate(name, (void *)&spintwo_noupsample) - - const struct CMUnitTest tests[] = { S2LET_TESTS(test_transform_axisym_lm_wav), S2LET_TESTS(test_transform_axisym_lm_wav_multires), S2LET_TESTS(test_wav_transform_wavlm_manual), S2LET_TESTS(test_wav_transform_harmonic), + S2LET_TESTS(test_wav_transform_mw), + S2LET_TESTS(test_wav_transform_mwss), + S2LET_TESTS(test_wav_transform_lm2wav), +#undef S2LET_TESTS + +#define S2LET_TESTS(name) cmocka_unit_test_prestate(name, (void *)&spinzero) S2LET_TESTS(test_transform_axisym_wav), S2LET_TESTS(test_transform_axisym_wav_multires), S2LET_TESTS(test_transform_axisym_wav_real), S2LET_TESTS(test_transform_axisym_wav_multires_real), - S2LET_TESTS(test_wav_transform_mw), S2LET_TESTS(test_wav_transform_mw_real), - S2LET_TESTS(test_wav_transform_mwss), S2LET_TESTS(test_wav_transform_mwss_real), - S2LET_TESTS(test_wav_transform_lm2wav), S2LET_TESTS(test_wav_transform_lm2wav_real), - }; #undef S2LET_TESTS + }; return cmocka_run_group_tests(tests, NULL, NULL); } From 4c76ec25df399d337288bd41b8816d139d1c3471 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Wed, 14 Oct 2020 23:02:20 +0100 Subject: [PATCH 04/23] Using latest so3 version on bintray --- cmake/conan_dependencies.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/conan_dependencies.cmake b/cmake/conan_dependencies.cmake index de03d09e..18ba5475 100644 --- a/cmake/conan_dependencies.cmake +++ b/cmake/conan_dependencies.cmake @@ -13,7 +13,7 @@ elseif(NOT CONAN_OPTIONS) set(fpic_value "False") endif() if(NOT CONAN_DEPS) - set(CONAN_DEPS "so3/1.2.1@astro-informatics/stable") + set(CONAN_DEPS "so3/1.3.0@astro-informatics/stable") endif() list(APPEND CONAN_OPTIONS "so3:fPIC=${fpic_value}") if(cfitsio) From 43816d6c36be605b3c251055c6831c2c0b0b441a Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Thu, 15 Oct 2020 22:40:52 +0100 Subject: [PATCH 05/23] Adding python testing frameworks --- .github/workflows/python.yml | 7 +- pyproject.toml | 13 +- setup.cfg | 15 ++ setup.py | 12 +- src/main/pys2let/__init__.py | 2 +- src/main/pys2let/plots.py | 2 + .../{tests_axisym_hpx.py => axisym_hpx.py} | 10 +- .../{tests_directional.py => directional.py} | 74 ++++-- src/test/python/directional_manual.py | 229 ++++++++++++++++++ src/test/python/{tests_mw.py => mw.py} | 33 ++- src/test/python/tests_axisym_adjoints.py | 93 ++++--- src/test/python/tests_directional_adjoint.py | 49 ---- src/test/python/tests_directional_manual.py | 158 ------------ 13 files changed, 412 insertions(+), 285 deletions(-) rename src/test/python/{tests_axisym_hpx.py => axisym_hpx.py} (89%) rename src/test/python/{tests_directional.py => directional.py} (69%) create mode 100644 src/test/python/directional_manual.py rename src/test/python/{tests_mw.py => mw.py} (77%) delete mode 100644 src/test/python/tests_directional_adjoint.py delete mode 100644 src/test/python/tests_directional_manual.py diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index 0e8f066b..879339f6 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -22,10 +22,15 @@ jobs: python-version: ${{ matrix.python-version }} - name: Install build packages - run: python -m pip install --upgrade pip scikit-build + run: python -m pip install --upgrade pip scikit-build wheel - name: Create sdist package run: python setup.py sdist - name: Install pys2let run: pip install dist/pys2let-2.1.0.tar.gz + + - name: Run pytest + run: | + pip install pytest + pytest src/test/python diff --git a/pyproject.toml b/pyproject.toml index be01232f..ab81c24c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,4 +4,15 @@ requires = [ "numpy", "conan" ] [tool.black] -line-length = 79 +line-length = 88 + +[tool.isort] +multi_line_output = 3 +include_trailing_comma = true +force_grid_wrap = 0 +use_parentheses = true +ensure_newline_before_comments = true +line_length = 88 + +[tool.pylint.format] +max-line-length = 88 diff --git a/setup.cfg b/setup.cfg index 7b13cbcd..652c8636 100644 --- a/setup.cfg +++ b/setup.cfg @@ -18,3 +18,18 @@ tag = False [bumpversion:file:.github/workflows/python.yml] search = dist/pys2let-{current_version}.tar.gz replace = dist/pys2let-{new_version}.tar.gz + +[flake8] +max-line-length = 88 +extend-ignore = E203, W503 +exclude = + .tox, + .git, + build, + __pycache__, + docs/, + +[pycodestyle] +count = False +max-line-length = 88 +statistics = True diff --git a/setup.py b/setup.py index 7424bb9a..d56f016a 100644 --- a/setup.py +++ b/setup.py @@ -22,17 +22,11 @@ setup( name="pys2let", version="2.1.0", - author=[ - "Boris Leistedt", - "Martin Büttner", - "Jennifer Chan", - "Jason McEwen", - ], + author=["Boris Leistedt", "Martin Büttner", "Jennifer Chan", "Jason McEwen"], install_requires=["numpy"], extras_require={ - "build": build_requirements, - "dev": build_requirements, - "plots": ["scipy"], + "dev": build_requirements + ["pytest", "black"], + "plots": ["scipy", "healpy"], }, description="Fast spin spherical transforms", url="http://astro-informatics.github.io/s2let/", diff --git a/src/main/pys2let/__init__.py b/src/main/pys2let/__init__.py index 6bcd78c5..1f81821d 100644 --- a/src/main/pys2let/__init__.py +++ b/src/main/pys2let/__init__.py @@ -1 +1 @@ -from .pys2let import * +from .pys2let import * diff --git a/src/main/pys2let/plots.py b/src/main/pys2let/plots.py index d04bc89b..677d9538 100644 --- a/src/main/pys2let/plots.py +++ b/src/main/pys2let/plots.py @@ -1,8 +1,10 @@ import numpy as np import os + def read_matfile(wavelet_type): from scipy import io as sio + matfile = os.path.join( os.environ["S2LET"], "src", "main", "matlab", "kappas_" + wavelet_type ) diff --git a/src/test/python/tests_axisym_hpx.py b/src/test/python/axisym_hpx.py similarity index 89% rename from src/test/python/tests_axisym_hpx.py rename to src/test/python/axisym_hpx.py index a256d263..49145d96 100644 --- a/src/test/python/tests_axisym_hpx.py +++ b/src/test/python/axisym_hpx.py @@ -11,8 +11,14 @@ J = pys2let_j_max(B, L, J_min) # The filename of some random healpix map -fname = os.path.join(os.path.dirname(__file__), os.pardir, - os.pardir, os.pardir, 'data', 'somecmbsimu_hpx_128.fits') +fname = os.path.join( + os.path.dirname(__file__), + os.pardir, + os.pardir, + os.pardir, + "data", + "somecmbsimu_hpx_128.fits", +) # Read healpix map and compute alms. # f_lm has size L*(L+1)/2 diff --git a/src/test/python/tests_directional.py b/src/test/python/directional.py similarity index 69% rename from src/test/python/tests_directional.py rename to src/test/python/directional.py index 207cc2de..4d37678f 100644 --- a/src/test/python/tests_directional.py +++ b/src/test/python/directional.py @@ -14,12 +14,18 @@ upsample = 1 # 1 means all scales at full resolution L # 0 means multiresolution wavelet transform J = pys2let_j_max(B, L, J_min) # Compute maximum scale -print('Jmax =', J) +print("Jmax =", J) # The filename of some random healpix map # fname = '/Users/bl/Dropbox/Astrodata/SDSS/Fields/Planck_EBV_256rQ.fits' -fname = os.path.join(os.path.dirname(__file__), os.pardir, - os.pardir, os.pardir, 'data', 'somecmbsimu_hpx_128.fits') +fname = os.path.join( + os.path.dirname(__file__), + os.pardir, + os.pardir, + os.pardir, + "data", + "somecmbsimu_hpx_128.fits", +) # Read healpix map and compute alms. # f_lm has size L*(L+1)/2 @@ -30,16 +36,16 @@ # Call pys2let and compute directional wavelet transform. # Returns an array of MW maps # The way to ac,cess them is described below. -print('Running analysis_lm2wav') +print("Running analysis_lm2wav") f_wav, f_scal = analysis_lm2wav(f_lm, B, L, J_min, N, spin, upsample) -print('Done') +print("Done") -print('size f_scal f_wav', f_scal.size, f_wav.size, f_wav.size / f_scal.size) +print("size f_scal f_wav", f_scal.size, f_wav.size, f_wav.size / f_scal.size) # Uses synthesis to reconstruct the input alms. -print('Running synthesis_wav2lm') +print("Running synthesis_wav2lm") f_lm_rec = synthesis_wav2lm(f_wav, f_scal, B, L, J_min, N, spin, upsample) -print('Done') +print("Done") f_rec = hp.alm2map(f_lm_rec, nside=nside, lmax=L - 1) # plot to compare the input/output maps # hp.mollview(f) @@ -53,7 +59,7 @@ # Home made plotting routine! inputs : function f (1D array of MW signal), bandlimit L, plot axis ax, and title -def myplot(f, L, ax, title=''): +def myplot(f, L, ax, title=""): # Compute the theta and phi values of the MW equiangular grid. thetas, phis = mw_sampling(L) ntheta = len(thetas) @@ -73,21 +79,21 @@ def myplot(f, L, ax, title=''): selec = np.arange(0, nphi, step_phi) # subset of phi tick labels ax.set_xticks(selec) - ax.set_xticklabels(['%.1f' % x for x in phis[selec]]) - ax.set_xlabel(r'$\phi$') + ax.set_xticklabels(["%.1f" % x for x in phis[selec]]) + ax.set_xlabel(r"$\phi$") selec = np.arange(0, ntheta, step_theta) # subset of theta tick labels ax.set_yticks(selec) - ax.set_yticklabels(['%.1f' % x for x in thetas[selec]]) - ax.set_ylabel(r'$\theta$') + ax.set_yticklabels(["%.1f" % x for x in thetas[selec]]) + ax.set_ylabel(r"$\theta$") ax.set_title(title) # Plot equiangular map fig, ax = plt.subplots(1, 1) -myplot(f_mw, L, ax, 'Input map converted to MW') +myplot(f_mw, L, ax, "Input map converted to MW") fig, ax = plt.subplots(1, 1) -myplot(f_mw_rec, L, ax, 'Input map converted to MW (reconstructed)') -fig.savefig('test_directional_python_wrappers_1.png') +myplot(f_mw_rec, L, ax, "Input map converted to MW (reconstructed)") +fig.savefig("test_directional_python_wrappers_1.png") # Create giant array figure fig, axs = plt.subplots(J - J_min + 1, N, figsize=(4 * N, 3 * (J - J_min))) @@ -96,18 +102,40 @@ def myplot(f, L, ax, title=''): for j in range(J_min, J + 1): for n in range(0, N): # Retreive the boundaries and positions of the right wavelet scale in the giant f_wav array! - offset, bandlimit, nelem, nelem_wav = wav_ind( - j, n, B, L, N, J_min, upsample) + offset, bandlimit, nelem, nelem_wav = wav_ind(j, n, B, L, N, J_min, upsample) # The right wavelet map corresponding to (j,n) will be f_wav[offset:offset+nelem]. # It has a band-limit bandlimit # nelem_wav is the total number of elements in the j-th scale (i.e., sum of all directions). It's a safety check to verify that we are not forgetting anlsy directions. - print('plot id', (j - J_min) * N + n, 'j=', j, 'n=', n, 'bounds=', - offset, 'to', offset + nelem, 'Total elems:', nelem_wav) + print( + "plot id", + (j - J_min) * N + n, + "j=", + j, + "n=", + n, + "bounds=", + offset, + "to", + offset + nelem, + "Total elems:", + nelem_wav, + ) # Make the plot! - myplot(f_wav[offset:offset + nelem], bandlimit, axs[(j - J_min) * N + n], title='Scale ' + - str(j + 1 - J_min) + '/' + str(J - J_min + 1) + ', direction ' + str(n + 1) + '/' + str(N)) + myplot( + f_wav[offset : offset + nelem], + bandlimit, + axs[(j - J_min) * N + n], + title="Scale " + + str(j + 1 - J_min) + + "/" + + str(J - J_min + 1) + + ", direction " + + str(n + 1) + + "/" + + str(N), + ) # Pretty adjustment fig.subplots_adjust(hspace=0.4, wspace=0.5) -fig.savefig('test_directional_python_wrappers_2.png') +fig.savefig("test_directional_python_wrappers_2.png") plt.show() diff --git a/src/test/python/directional_manual.py b/src/test/python/directional_manual.py new file mode 100644 index 00000000..e9049af9 --- /dev/null +++ b/src/test/python/directional_manual.py @@ -0,0 +1,229 @@ +from __future__ import print_function +import healpy as hp +from pys2let import * +import math +import matplotlib.pyplot as plt +from copy import copy +import os + +L = 3024 +J_min = 3 + +Bs = np.array([2, 1.4, 1.2, 1.1]) +L_transitions = np.array([200, 1100, 1900]) +( + hybrid_scal_l, + hybrid_wav_l, + hybrid_scal_bandlimit, + hybrid_wav_bandlimits, + J, + L_bounds, +) = construct_hybrid_tiling(L, J_min, Bs, L_transitions) + +print("Bs", Bs) +print("L_bounds", L_bounds) +fig, axs = plt.subplots(Bs.size + 2, 1, figsize=(8, 14)) +axs = axs.ravel() +J_mins = np.zeros((Bs.size,), dtype=np.int32) +J_mins[0] = J_min +for k in range(Bs.size): + scal_l, wav_l = axisym_wav_l(Bs[k], L, J_mins[k]) + Jt = pys2let_j_max(Bs[k], L, 0) + axs[k].plot(scal_l, lw=2, ls="dashed") + for j in range(0, Jt + 1 - J_mins[k]): + axs[k].plot(wav_l[:, j], lw=2, ls="solid") + for kk in range(Bs.size): + axs[k].axvline(L_bounds[kk], c="k", ls="dashed") + axs[k].set_xscale("log") + axs[k].set_ylim([0, 1.2]) + axs[k].set_xlim([1, L]) + axs[k].set_title( + "Tiling %i" % (k + 1) + + " on %i" % Bs.size + + ", with B=%.2f" % Bs[k] + + ", Jmin=0, and defined at %i" % L_bounds[k] + + " 10: + step_phi = int(L / 4) + step_theta = int(L / 4) + else: + step_phi = 3 + step_theta = 3 + selec = np.arange(0, nphi, step_phi) # subset of phi tick labels + ax.set_xticks(selec) + ax.set_xticklabels(["%.1f" % x for x in phis[selec]]) + ax.set_xlabel(r"$\phi$") + selec = np.arange(0, ntheta, step_theta) # subset of theta tick labels + ax.set_yticks(selec) + ax.set_yticklabels(["%.1f" % x for x in thetas[selec]]) + ax.set_ylabel(r"$\theta$") + ax.set_title(title) + + +# Plot equiangular map +fig, ax = plt.subplots(1, 1) +myplot(f_mw, L, ax, "Input map converted to MW") +fig, ax = plt.subplots(1, 1) +myplot(f_mw_rec, L, ax, "Input map converted to MW (reconstructed)") +fig.savefig("test_directional_python_wrappers_1.png") + +# Create giant array figure +fig, axs = plt.subplots(J + 1, N, figsize=(4 * N, 3 * J)) +axs = axs.ravel() +# Loop through scales j and directions n +offset = 0 +for j in range(0, J + 1): + for n in range(0, N): + bandlimit = hybrid_wav_bandlimits[j] + nelem = bandlimit * (2 * bandlimit - 1) + # offset, bandlimit, nelem, nelem_wav = wav_ind(j, n, B, L, N, J_min, upsample) + print( + "plot id", + j * N + n, + "j=", + j, + "n=", + n, + "bounds=", + offset, + "to", + offset + nelem, + ) + # Make the plot! + myplot( + f_wav[offset : offset + nelem], + bandlimit, + axs[(j) * N + n], + title="Scale " + + str(j + 1) + + "/" + + str(J + 1) + + ", direction " + + str(n + 1) + + "/" + + str(N), + ) + offset += nelem + +# Pretty adjustment +fig.subplots_adjust(hspace=0.4, wspace=0.5) +fig.savefig("test_directional_python_wrappers_2.png") +plt.show() diff --git a/src/test/python/tests_mw.py b/src/test/python/mw.py similarity index 77% rename from src/test/python/tests_mw.py rename to src/test/python/mw.py index 7973d0c6..6bd9e9d3 100644 --- a/src/test/python/tests_mw.py +++ b/src/test/python/mw.py @@ -1,16 +1,22 @@ - import healpy as hp from pys2let import * import math import matplotlib.pyplot as plt import os +import numpy as np L = 32 spin = 0 # fname = '/Users/bl/Dropbox/Astrodata/SDSS/Fields/Planck_EBV_256rQ.fits' -fname = os.path.join(os.path.dirname(__file__), os.pardir, - os.pardir, os.pardir, 'data', 'somecmbsimu_hpx_128.fits') +fname = os.path.join( + os.path.dirname(__file__), + os.pardir, + os.pardir, + os.pardir, + "data", + "somecmbsimu_hpx_128.fits", +) # Read healpix map and compute alms. # f_lm has size L*(L+1)/2 @@ -30,7 +36,12 @@ def zeropad(flm, Lin, Lout): - f_lm_out = np.zeros([int(Lout * (Lout + 1) / 2), ], dtype=complex) + f_lm_out = np.zeros( + [ + int(Lout * (Lout + 1) / 2), + ], + dtype=complex, + ) for el in range(Lin): for em in range(el + 1): f_lm_out[healpy_lm(el, em, Lout)] = f_lm[healpy_lm(el, em, Lin)] @@ -46,7 +57,7 @@ def zeropad(flm, Lin, Lout): # Home made plotting routine! inputs : function f (1D array of MW signal), bandlimit L, plot axis ax, and title -def myplot(f, L, ax, title=''): +def myplot(f, L, ax, title=""): # Compute the theta and phi values of the MW equiangular grid. thetas, phis = mw_sampling(L) ntheta = len(thetas) @@ -61,20 +72,20 @@ def myplot(f, L, ax, title=''): step_theta = 3 selec = np.arange(0, nphi, step_phi) # subset of phi tick labels ax.set_xticks(selec) - ax.set_xticklabels(['%.1f' % x for x in phis[selec]]) - ax.set_xlabel(r'$\phi$') + ax.set_xticklabels(["%.1f" % x for x in phis[selec]]) + ax.set_xlabel(r"$\phi$") selec = np.arange(0, ntheta, step_theta) # subset of theta tick labels ax.set_yticks(selec) - ax.set_yticklabels(['%.1f' % x for x in thetas[selec]]) - ax.set_ylabel(r'$\theta$') + ax.set_yticklabels(["%.1f" % x for x in thetas[selec]]) + ax.set_ylabel(r"$\theta$") ax.set_title(title) # Plot equiangular map fig, axs = plt.subplots(1, 2) axs = axs.ravel() -myplot(f_mw, L, axs[0], 'L') -myplot(f_mw_ext, Lpix, axs[1], 'Lpix') +myplot(f_mw, L, axs[0], "L") +myplot(f_mw_ext, Lpix, axs[1], "Lpix") # myplot(f_mw_ext2, Lpix, axs[2], 'Lpix') # myplot(f_mw_rec2, L, axs[3], 'L') plt.show() diff --git a/src/test/python/tests_axisym_adjoints.py b/src/test/python/tests_axisym_adjoints.py index c8622ab1..6b9ad2f5 100644 --- a/src/test/python/tests_axisym_adjoints.py +++ b/src/test/python/tests_axisym_adjoints.py @@ -1,41 +1,74 @@ -from pys2let import * +from functools import partial + import numpy as np +from pytest import approx, fixture, mark + +from pys2let import ( + analysis_adjoint_axisym_wav_mw, + analysis_adjoint_wav2px, + analysis_axisym_wav_mw, + analysis_px2wav, + synthesis_adjoint_axisym_wav_mw, + synthesis_adjoint_px2wav, + synthesis_axisym_wav_mw, + synthesis_wav2px, +) + + +@fixture +def rng(request): + return np.random.default_rng(getattr(request.config.option, "randomly_seed", None)) + -def random_lms(L): - return np.random.rand(L * L).astype(np.complex) +def random_mw_map(rng, L, spin): + from pys2let import alm2map_mw -def random_mw_map(L): - return alm2map_mw(random_lms(L), L, 0) + return alm2map_mw(rng.uniform(size=(L * L, 2)) @ [1, 1j], L, spin) -def random_wavlet_maps(L, nwvlts): - f_scal = random_mw_map(L) - f_wav = np.concatenate([random_mw_map(L) for _ in range(nwvlts)]) - return f_scal, f_wav -L = 10 -B = 2 -J_min = 2 -nwvlts = pys2let_j_max(B, L, J_min) - J_min + 1 +def random_wavlet_maps(rng, L, spin, nwvlts): + maps = [random_mw_map(rng, L, spin) for _ in range(nwvlts + 1)] + return maps[0], np.concatenate(maps[1:]) -#### as on website http://sepwww.stanford.edu/sep/prof/pvi/conj/paper_html/node9.html -x = random_mw_map(L) -y_scal, y_wav = random_wavlet_maps(L, nwvlts) -y = analysis_adjoint_axisym_wav_mw(y_wav, y_scal, B, L, J_min) -x_wav, x_scal = analysis_axisym_wav_mw(x, B, L, J_min) +@mark.parametrize( + "px2wav,wav2px,spin", + [ + (analysis_axisym_wav_mw, analysis_adjoint_axisym_wav_mw, 0), + (synthesis_adjoint_axisym_wav_mw, synthesis_axisym_wav_mw, 0), + ( + partial(analysis_px2wav, spin=0, upsample=1, N=1), + partial(analysis_adjoint_wav2px, spin=0, upsample=1, N=1), + 0, + ), + ( + partial(analysis_px2wav, spin=2, upsample=1, N=1), + partial(analysis_adjoint_wav2px, spin=2, upsample=1, N=1), + 2, + ), + ( + partial(synthesis_adjoint_px2wav, spin=0, upsample=1, N=1), + partial(synthesis_wav2px, spin=0, upsample=1, N=1), + 0, + ), + ( + partial(synthesis_adjoint_px2wav, spin=2, upsample=1, N=1), + partial(synthesis_wav2px, spin=2, upsample=1, N=1), + 2, + ), + ], +) +def test_axisym_adjoint( + px2wav, wav2px, spin, rng: np.random.Generator, L=10, B=2, J_min=2 +): + from pys2let import pys2let_j_max -dot_product_error = y_wav.conj().dot(x_wav) -dot_product_error += y_scal.conj().dot(x_scal) -dot_product_error -= y.conj().dot(x) -print(f"ANALYSIS Dot product error: {dot_product_error}") + nwvlts = pys2let_j_max(B, L, J_min) - J_min + 1 -x_scal, x_wav = random_wavlet_maps(L, nwvlts) -y = random_mw_map(L) + x = random_mw_map(rng, L, spin) + y_scal, y_wav = random_wavlet_maps(rng, L, spin, nwvlts) -x = synthesis_axisym_wav_mw(x_wav, x_scal, B, L, J_min) -y_wav, y_scal = synthesis_adjoint_axisym_wav_mw(y, B, L, J_min) + y = wav2px(y_wav, y_scal, B, L, J_min) + x_wav, x_scal = px2wav(x, B, L, J_min) -dot_product_error = y.conj().dot(x) -dot_product_error -= y_wav.conj().dot(x_wav) -dot_product_error -= y_scal.conj().dot(x_scal) -print(f"SYNTHESIS Dot product error: {dot_product_error}") + assert y_wav.conj().T @ x_wav + y_scal.conj() @ x_scal == approx(y.conj().T @ x) diff --git a/src/test/python/tests_directional_adjoint.py b/src/test/python/tests_directional_adjoint.py deleted file mode 100644 index 50a1f4c9..00000000 --- a/src/test/python/tests_directional_adjoint.py +++ /dev/null @@ -1,49 +0,0 @@ -from pys2let import * -import numpy as np - - -def random_lms(L): - return np.random.rand(L * L).astype(np.complex) - - -def random_mw_map(L, spin): - return alm2map_mw(random_lms(L), L, spin) - - -def random_wavlet_maps(L, spin, nwvlts): - f_scal = random_mw_map(L, spin) - f_wav = np.concatenate([random_mw_map(L, spin) for _ in range(nwvlts)]) - return f_scal, f_wav - - -L = 10 -B = 2 -J_min = 2 -N = 1 -spin = 0 -upsample = 1 -nwvlts = pys2let_j_max(B, L, J_min) - J_min + 1 - - -#### as on website http://sepwww.stanford.edu/sep/prof/pvi/conj/paper_html/node9.html -x = random_mw_map(L, spin) -y_scal, y_wav = random_wavlet_maps(L, spin, nwvlts) - -y = analysis_adjoint_wav2px(y_wav, y_scal, B, L, J_min, N, spin, upsample) -x_wav, x_scal = analysis_px2wav(x, B, L, J_min, N, spin, upsample) - -dot_product_error = y_wav.conj().dot(x_wav) -dot_product_error += y_scal.conj().dot(x_scal) -dot_product_error -= y.conj().dot(x) -print(f"ANALYSIS Dot product error: {dot_product_error}") - -x_scal, x_wav = random_wavlet_maps(L, spin, nwvlts) -y = random_mw_map(L, spin) - -x = synthesis_wav2px(x_wav, x_scal, B, L, J_min, N, spin, upsample) -y_wav, y_scal = synthesis_adjoint_px2wav(y, B, L, J_min, N, spin, upsample) - -dot_product_error = y.conj().dot(x) -dot_product_error -= y_wav.conj().dot(x_wav) -dot_product_error -= y_scal.conj().dot(x_scal) -print(f"SYNTHESIS Dot product error: {dot_product_error}") diff --git a/src/test/python/tests_directional_manual.py b/src/test/python/tests_directional_manual.py deleted file mode 100644 index 320cb3a4..00000000 --- a/src/test/python/tests_directional_manual.py +++ /dev/null @@ -1,158 +0,0 @@ -from __future__ import print_function -import healpy as hp -from pys2let import * -import math -import matplotlib.pyplot as plt -from copy import copy -import os - -L = 3024 -J_min = 3 - -Bs = np.array([2, 1.4, 1.2, 1.1]) -L_transitions = np.array([200, 1100, 1900]) -hybrid_scal_l, hybrid_wav_l, hybrid_scal_bandlimit, hybrid_wav_bandlimits, J, L_bounds = construct_hybrid_tiling( - L, J_min, Bs, L_transitions) - -print('Bs', Bs) -print('L_bounds', L_bounds) -fig, axs = plt.subplots(Bs.size + 2, 1, figsize=(8, 14)) -axs = axs.ravel() -J_mins = np.zeros((Bs.size,), dtype=np.int32) -J_mins[0] = J_min -for k in range(Bs.size): - scal_l, wav_l = axisym_wav_l(Bs[k], L, J_mins[k]) - Jt = pys2let_j_max(Bs[k], L, 0) - axs[k].plot(scal_l, lw=2, ls='dashed') - for j in range(0, Jt + 1 - J_mins[k]): - axs[k].plot(wav_l[:, j], lw=2, ls='solid') - for kk in range(Bs.size): - axs[k].axvline(L_bounds[kk], c='k', ls='dashed') - axs[k].set_xscale('log') - axs[k].set_ylim([0, 1.2]) - axs[k].set_xlim([1, L]) - axs[k].set_title( - 'Tiling %i' % (k + 1) + ' on %i' % Bs.size + ', with B=%.2f' % Bs[k] + ', Jmin=0, and defined at %i' % L_bounds[k] + ' 10: - step_phi = int(L / 4) - step_theta = int(L / 4) - else: - step_phi = 3 - step_theta = 3 - selec = np.arange(0, nphi, step_phi) # subset of phi tick labels - ax.set_xticks(selec) - ax.set_xticklabels(['%.1f' % x for x in phis[selec]]) - ax.set_xlabel(r'$\phi$') - selec = np.arange(0, ntheta, step_theta) # subset of theta tick labels - ax.set_yticks(selec) - ax.set_yticklabels(['%.1f' % x for x in thetas[selec]]) - ax.set_ylabel(r'$\theta$') - ax.set_title(title) - - -# Plot equiangular map -fig, ax = plt.subplots(1, 1) -myplot(f_mw, L, ax, 'Input map converted to MW') -fig, ax = plt.subplots(1, 1) -myplot(f_mw_rec, L, ax, 'Input map converted to MW (reconstructed)') -fig.savefig('test_directional_python_wrappers_1.png') - -# Create giant array figure -fig, axs = plt.subplots(J + 1, N, figsize=(4 * N, 3 * J)) -axs = axs.ravel() -# Loop through scales j and directions n -offset = 0 -for j in range(0, J + 1): - for n in range(0, N): - bandlimit = hybrid_wav_bandlimits[j] - nelem = bandlimit * (2 * bandlimit - 1) - # offset, bandlimit, nelem, nelem_wav = wav_ind(j, n, B, L, N, J_min, upsample) - print('plot id', j * N + n, 'j=', j, 'n=', n, - 'bounds=', offset, 'to', offset + nelem) - # Make the plot! - myplot(f_wav[offset:offset + nelem], bandlimit, axs[(j) * N + n], - title='Scale ' + str(j + 1) + '/' + str(J + 1) + ', direction ' + str(n + 1) + '/' + str(N)) - offset += nelem - -# Pretty adjustment -fig.subplots_adjust(hspace=0.4, wspace=0.5) -fig.savefig('test_directional_python_wrappers_2.png') -plt.show() From 166055529ac8757bba87967090ead02e1daa3660 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Thu, 15 Oct 2020 22:42:20 +0100 Subject: [PATCH 06/23] Reformats all c files --- include/s2let.h | 2 +- include/s2let_alloc.h | 1 + src/main/c/s2let_about.c | 1 - src/main/c/s2let_alloc.c | 94 +- src/main/c/s2let_analysis.c | 768 ++++----- src/main/c/s2let_analysis_adjoint.c | 842 +++++----- src/main/c/s2let_axisym_denoising_demo.c | 107 +- src/main/c/s2let_denoising_demo.c | 135 +- src/main/c/s2let_fits.c | 607 ++++--- src/main/c/s2let_helper.c | 171 +- src/main/c/s2let_hpx.c | 45 +- src/main/c/s2let_hpx_demo.c | 50 +- src/main/c/s2let_idl_hpx.c | 113 +- src/main/c/s2let_idl_mw.c | 236 ++- src/main/c/s2let_lm.c | 62 +- src/main/c/s2let_math.c | 313 ++-- src/main/c/s2let_mw.c | 17 +- src/main/c/s2let_spin_denoising_demo.c | 177 +- src/main/c/s2let_synthesis.c | 806 +++++---- src/main/c/s2let_synthesis_adjoint.c | 787 +++++---- src/main/c/s2let_tiling.c | 655 ++++---- ...s2let_transform_axisym_analysis_hpx_real.c | 36 +- .../s2let_transform_axisym_analysis_mw_real.c | 47 +- src/main/c/s2let_transform_axisym_hpx.c | 45 +- src/main/c/s2let_transform_axisym_lm.c | 330 ++-- src/main/c/s2let_transform_axisym_mw.c | 1459 ++++++++--------- ...2let_transform_axisym_synthesis_hpx_real.c | 31 +- ...s2let_transform_axisym_synthesis_mw_real.c | 70 +- 28 files changed, 3891 insertions(+), 4116 deletions(-) diff --git a/include/s2let.h b/include/s2let.h index c1e45403..e2a095b1 100644 --- a/include/s2let.h +++ b/include/s2let.h @@ -1,7 +1,6 @@ #ifndef S2LET #define S2LET #include -#include "s2let_types.h" #include "s2let_alloc.h" #include "s2let_analysis.h" @@ -22,5 +21,6 @@ #include "s2let_transform_axisym_hpx.h" #include "s2let_transform_axisym_lm.h" #include "s2let_transform_axisym_mw.h" +#include "s2let_types.h" #endif diff --git a/include/s2let_alloc.h b/include/s2let_alloc.h index bb70e3ca..edc3915b 100644 --- a/include/s2let_alloc.h +++ b/include/s2let_alloc.h @@ -6,6 +6,7 @@ #define S2LET_ALLOC #include +#include "s2let_types.h" #ifdef __cplusplus extern "C" { diff --git a/src/main/c/s2let_about.c b/src/main/c/s2let_about.c index 5689fd6b..0a27510a 100644 --- a/src/main/c/s2let_about.c +++ b/src/main/c/s2let_about.c @@ -27,5 +27,4 @@ int main(int argc, char *argv[]) { printf("%s\n", "=========================================================="); return 0; - } diff --git a/src/main/c/s2let_alloc.c b/src/main/c/s2let_alloc.c index c218b750..ea0a9319 100644 --- a/src/main/c/s2let_alloc.c +++ b/src/main/c/s2let_alloc.c @@ -2,22 +2,22 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" -#include -#include #include #include -#include +#include +#include #include +#include + +#include "s2let.h" /*! * Allocate map for a complex signal in pixel space using MW sampling. * \param[out] f Allocated map * \param[in] L Harmonic band-limit */ -void s2let_allocate_mw(complex double **f, int L) -{ - *f = calloc(L * (2*L-1), sizeof **f); +void s2let_allocate_mw(complex double **f, int L) { + *f = calloc(L * (2 * L - 1), sizeof **f); } /*! @@ -25,9 +25,8 @@ void s2let_allocate_mw(complex double **f, int L) * \param[out] f Allocated map * \param[in] L Harmonic band-limit */ -void s2let_allocate_mw_real(double **f, int L) -{ - *f = calloc(L * (2*L-1), sizeof **f); +void s2let_allocate_mw_real(double **f, int L) { + *f = calloc(L * (2 * L - 1), sizeof **f); } /*! @@ -35,9 +34,8 @@ void s2let_allocate_mw_real(double **f, int L) * \param[out] f Allocated map * \param[in] L Harmonic band-limit */ -void s2let_allocate_mwss(complex double **f, int L) -{ - *f = calloc((2*L)*(L+1), sizeof **f); +void s2let_allocate_mwss(complex double **f, int L) { + *f = calloc((2 * L) * (L + 1), sizeof **f); } /*! @@ -45,9 +43,8 @@ void s2let_allocate_mwss(complex double **f, int L) * \param[out] f Allocated map * \param[in] L Harmonic band-limit */ -void s2let_allocate_mwss_real(double **f, int L) -{ - *f = calloc((2*L)*(L+1), sizeof **f); +void s2let_allocate_mwss_real(double **f, int L) { + *f = calloc((2 * L) * (L + 1), sizeof **f); } /*! @@ -59,9 +56,8 @@ void s2let_allocate_mwss_real(double **f, int L) * \param[in] L Angular harmonic band-limit. * \retval none */ -void s2let_allocate_lm(complex double **flm, int L) -{ - *flm = calloc(L * L, sizeof **flm); +void s2let_allocate_lm(complex double **flm, int L) { + *flm = calloc(L * L, sizeof **flm); } /*! @@ -82,10 +78,9 @@ void s2let_allocate_lm(complex double **flm, int L) void s2let_allocate_lmn_f_wav( complex double **f_wav_lmn, complex double **f_scal_lm, - const s2let_parameters_t *parameters -) { - *f_wav_lmn = calloc(s2let_n_lmn_wav(parameters), sizeof **f_wav_lmn); - *f_scal_lm = calloc(s2let_n_lm_scal(parameters), sizeof **f_scal_lm); + const s2let_parameters_t *parameters) { + *f_wav_lmn = calloc(s2let_n_lmn_wav(parameters), sizeof **f_wav_lmn); + *f_scal_lm = calloc(s2let_n_lm_scal(parameters), sizeof **f_scal_lm); } /*! @@ -105,10 +100,9 @@ void s2let_allocate_lmn_f_wav( void s2let_allocate_f_wav( complex double **f_wav, complex double **f_scal, - const s2let_parameters_t *parameters -) { - *f_wav = calloc(s2let_n_wav(parameters), sizeof **f_wav); - *f_scal = calloc(s2let_n_scal(parameters), sizeof **f_scal); + const s2let_parameters_t *parameters) { + *f_wav = calloc(s2let_n_wav(parameters), sizeof **f_wav); + *f_scal = calloc(s2let_n_scal(parameters), sizeof **f_scal); } /*! @@ -126,12 +120,9 @@ void s2let_allocate_f_wav( * \retval none */ void s2let_allocate_f_wav_real( - double **f_wav, - double **f_scal, - const s2let_parameters_t *parameters -) { - *f_wav = calloc(s2let_n_wav(parameters), sizeof **f_wav); - *f_scal = calloc(s2let_n_scal(parameters), sizeof **f_scal); + double **f_wav, double **f_scal, const s2let_parameters_t *parameters) { + *f_wav = calloc(s2let_n_wav(parameters), sizeof **f_wav); + *f_scal = calloc(s2let_n_scal(parameters), sizeof **f_scal); } /*! @@ -142,15 +133,16 @@ void s2let_allocate_f_wav_real( * maps, using MW sampling. * \param[out] f_scal Pointer to allocated space for scaling function * map, using MW sampling. - * \param[in] wav_bandlimits Array of integers containing the band-limits + * \param[in] wav_bandlimits Array of integers containing the band-limits of the wavelets. Will be used to do the multiresolution. These must make sense and define a valid invertible transform as no extra checks are performed. * \param[in] scal_bandlimit Same as wav_bandlimits but only one integer: the band-limit of the scaling function. * \param[in] N Azimuthal band-limit for the directional transform - * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. - * \param[in] parameters A parameters object containing all s2let and so3 sampling options. + * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. + * \param[in] parameters A parameters object containing all s2let and so3 sampling + options. * \retval none */ void s2let_allocate_f_wav_manual( @@ -160,25 +152,23 @@ void s2let_allocate_f_wav_manual( int scal_bandlimit, int N, int J, - const s2let_parameters_t *parameters -) { + const s2let_parameters_t *parameters) { - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); - int j, total=0; - for (j = 0; j <= J; ++j) - { - if (!parameters->upsample) - { - so3_parameters.L = wav_bandlimits[j]; - } - total += so3_sampling_f_size(&so3_parameters); + int j, total = 0; + for (j = 0; j <= J; ++j) { + if (!parameters->upsample) { + so3_parameters.L = wav_bandlimits[j]; } + total += so3_sampling_f_size(&so3_parameters); + } - s2let_parameters_t bl_parameters = *parameters; - bl_parameters.L = scal_bandlimit; + s2let_parameters_t bl_parameters = *parameters; + bl_parameters.L = scal_bandlimit; - *f_wav = calloc(total, sizeof **f_wav); - *f_scal = calloc(s2let_n_phi(&bl_parameters) * s2let_n_theta(&bl_parameters), sizeof **f_scal); + *f_wav = calloc(total, sizeof **f_wav); + *f_scal = calloc( + s2let_n_phi(&bl_parameters) * s2let_n_theta(&bl_parameters), sizeof **f_scal); } diff --git a/src/main/c/s2let_analysis.c b/src/main/c/s2let_analysis.c index 4bc7a980..1f6e9970 100644 --- a/src/main/c/s2let_analysis.c +++ b/src/main/c/s2let_analysis.c @@ -2,21 +2,22 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" -#include -#include #include #include -#include +#include +#include #include +#include + +#include "s2let.h" /*! * Wavelet analysis from harmonic space to Wigner space for complex signals. * - * \param[out] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet contribution). - * \param[out] f_scal_lm Wavelet transform (Spherical harmonic coefficients of scaling contribution). - * \param[in] flm Spherical harmonic coefficients of input function. - * \param[in] wav_lm Wavelet kernels in harmonic space. + * \param[out] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet + * contribution). \param[out] f_scal_lm Wavelet transform (Spherical harmonic + * coefficients of scaling contribution). \param[in] flm Spherical harmonic + * coefficients of input function. \param[in] wav_lm Wavelet kernels in harmonic space. * \param[in] scal_l Scaling function kernels in harmonic space. * \param[in] parameters A fully populated parameters object. The \link * s2let_parameters_t::reality reality\endlink flag @@ -30,84 +31,73 @@ void s2let_analysis_lm2lmn( const complex double *flm, const complex double *wav_lm, const double *scal_l, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - int spin = parameters->spin; - - int j, el, m ,n; - int J = s2let_j_max(parameters); - int bandlimit = L; - int Nj = N; - - int lm_ind, lmn_ind; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - complex double psi; - double phi; - - int offset = 0; - - for (j = J_min; j <= J; ++j) - { - - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - Nj = MIN(N,bandlimit); - // ensure N and Nj are both even or both odd - Nj += (Nj+N)%2; - so3_parameters.N = Nj; - } + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + int spin = parameters->spin; + + int j, el, m, n; + int J = s2let_j_max(parameters); + int bandlimit = L; + int Nj = N; + + int lm_ind, lmn_ind; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + complex double psi; + double phi; + + int offset = 0; + + for (j = J_min; j <= J; ++j) { + + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + Nj = MIN(N, bandlimit); + // ensure N and Nj are both even or both odd + Nj += (Nj + N) % 2; + so3_parameters.N = Nj; + } - for (n = -Nj+1; n < Nj; n+=2) - { - for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = 8*PI*PI/(2*el+1) * conj(wav_lm[j*L*L + lm_ind]); - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); - f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi; - } - } + for (n = -Nj + 1; n < Nj; n += 2) { + for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = 8 * PI * PI / (2 * el + 1) * conj(wav_lm[j * L * L + lm_ind]); + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); + f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi; } - offset += so3_sampling_flmn_size(&so3_parameters); + } } + offset += so3_sampling_flmn_size(&so3_parameters); + } - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); - for (el = ABS(spin); el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - f_scal_lm[lm_ind] = flm[lm_ind] * phi; - } + for (el = ABS(spin); el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + f_scal_lm[lm_ind] = flm[lm_ind] * phi; } + } } /*! * Wavelet analysis from harmonic space to Wigner space for real signals. * - * \param[out] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet contribution). - * \param[out] f_scal_lm Wavelet transform (spherical harmonic coefficients of scaling contribution). - * \param[in] flm Spherical harmonic coefficients of input function. - * \param[in] wav_lm Wavelet kernels. - * \param[in] scal_l Scaling function kernels. - * \param[in] parameters A fully populated parameters object. The \link - * s2let_parameters_t::reality reality\endlink flag - * is ignored. Use \link s2let_analysis_lm2lmn - * \endlink instead for complex signals. - * \retval none + * \param[out] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet + * contribution). \param[out] f_scal_lm Wavelet transform (spherical harmonic + * coefficients of scaling contribution). \param[in] flm Spherical harmonic + * coefficients of input function. \param[in] wav_lm Wavelet kernels. \param[in] scal_l + * Scaling function kernels. \param[in] parameters A fully populated parameters object. + * The \link s2let_parameters_t::reality reality\endlink flag is ignored. Use \link + * s2let_analysis_lm2lmn \endlink instead for complex signals. \retval none */ void s2let_analysis_lm2lmn_real( complex double *f_wav_lmn, @@ -115,92 +105,83 @@ void s2let_analysis_lm2lmn_real( const complex double *flm, const complex double *wav_lm, const double *scal_l, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - - int j, el, m ,n; - int J = s2let_j_max(parameters); - int bandlimit = L; - int Nj = N; - - int lm_ind, lmn_ind; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - complex double psi; - double phi; - - int offset = 0; - - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - // ensure N and Nj are both even or both odd - Nj += (Nj+N)%2; - so3_parameters.N = Nj; - } + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + + int j, el, m, n; + int J = s2let_j_max(parameters); + int bandlimit = L; + int Nj = N; + + int lm_ind, lmn_ind; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + complex double psi; + double phi; + + int offset = 0; + + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + // ensure N and Nj are both even or both odd + Nj += (Nj + N) % 2; + so3_parameters.N = Nj; + } - for (n = 1-Nj%2; n < Nj; n+=2) - { - for (el = n; el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = 8*PI*PI/(2*el+1) * conj(wav_lm[j*L*L + lm_ind]); - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters); - f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi; - } - } + for (n = 1 - Nj % 2; n < Nj; n += 2) { + for (el = n; el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = 8 * PI * PI / (2 * el + 1) * conj(wav_lm[j * L * L + lm_ind]); + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters); + f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi; } - offset += so3_sampling_flmn_size(&so3_parameters); + } } + offset += so3_sampling_flmn_size(&so3_parameters); + } - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); - for (el = 0; el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - f_scal_lm[lm_ind] = flm[lm_ind] * phi; - } + for (el = 0; el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + f_scal_lm[lm_ind] = flm[lm_ind] * phi; } + } } - /*! * Wavelet analysis from harmonic space to wavelet space for complex signals. - * with fully manual wavelet tiling, using multiresolution as default with + * with fully manual wavelet tiling, using multiresolution as default with * the band-limits provided in input. * * \param[out] f_wav Array of wavelet maps * \param[out] f_scal Scaling function map * \param[in] flm Spherical harmonic coefficients of the signal - * \param[in] scal_l Array of size L containing the \ell space tiling for the scaling fct. - It is only \ell because it is assumed to be axisymmetric. - * \param[in] wav_lm Array of size (J+1)*L*L containing the (\ell, space) harmonic coefs - of the wavelets. They can be directional. These must make sense and - define a valid invertible transform as no extra checks are performed. + * \param[in] scal_l Array of size L containing the \ell space tiling for the scaling + fct. It is only \ell because it is assumed to be axisymmetric. + * \param[in] wav_lm Array of size (J+1)*L*L containing the (\ell, space) harmonic + coefs of the wavelets. They can be directional. These must make sense and define a + valid invertible transform as no extra checks are performed. * \param[in] scal_bandlimit Same as wav_bandlimits but only one integer: the band-limit of the scaling function. - * \param[in] wav_bandlimits Array of integers of size J+1 containing the band-limits + * \param[in] wav_bandlimits Array of integers of size J+1 containing the band-limits of the wavelets. Will be used to do the multiresolution. These must make sense and define a valid invertible transform as no extra checks are performed. - * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. + * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. * \param[in] L Band-limit for the transform: defines the size of all awways. - * \param[in] spin Spin (integer) to perform the transform + * \param[in] spin Spin (integer) to perform the transform * \param[in] N Azimuthal band-limit for the directional transform * \retval none */ @@ -215,96 +196,84 @@ void s2let_analysis_lm2wav_manual( int J, int L, int spin, - int N -) { - s2let_parameters_t parameters = {}; - parameters.L = L; - parameters.J_min = 0; - parameters.B = pow(L, 1.0/(float)(J+2)); - parameters.N = N; - parameters.dl_method = SSHT_DL_RISBO; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, ¶meters); - - int j, offset, offset_lmn; - complex double *f_wav_lmn, *f_scal_lm; - complex double psi, npsi; - double phi; - int el, m, n, lm_ind, lmn_ind; - - int Nj = N; - - bandlimit = MIN(scal_bandlimit, L); - f_scal_lm = (complex double*)calloc(bandlimit*bandlimit, sizeof(complex double)); - - for (el = ABS(spin); el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - f_scal_lm[lm_ind] = flm[lm_ind] * phi; - } - } - - switch (parameters.sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_inverse_sov_sym_ss(f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); + int N) { + s2let_parameters_t parameters = {}; + parameters.L = L; + parameters.J_min = 0; + parameters.B = pow(L, 1.0 / (float)(J + 2)); + parameters.N = N; + parameters.dl_method = SSHT_DL_RISBO; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, ¶meters); + + int j, offset, offset_lmn; + complex double *f_wav_lmn, *f_scal_lm; + complex double psi, npsi; + double phi; + int el, m, n, lm_ind, lmn_ind; + + int Nj = N; + + bandlimit = MIN(scal_bandlimit, L); + f_scal_lm = (complex double *)calloc(bandlimit * bandlimit, sizeof(complex double)); + + for (el = ABS(spin); el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + f_scal_lm[lm_ind] = flm[lm_ind] * phi; } - - free(f_scal_lm); - - offset = 0; - for (j = 0; j <= J; ++j) - { - bandlimit = MIN(wav_bandlimits[j], L); - so3_parameters.L = bandlimit; - int Nj = MIN(N, bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - so3_parameters.L0 = 0; - - f_wav_lmn = (complex double*)calloc(so3_sampling_flmn_size(&so3_parameters), sizeof(complex double)); - - for (n = -Nj+1; n < Nj; n+=2) - { - for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = 8*PI*PI/(2*el+1) * conj(wav_lm[j*L*L + lm_ind]); - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); - f_wav_lmn[lmn_ind] = flm[lm_ind] * psi; - } - } + } + + switch (parameters.sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_inverse_sov_sym( + f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_inverse_sov_sym_ss( + f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + free(f_scal_lm); + + offset = 0; + for (j = 0; j <= J; ++j) { + bandlimit = MIN(wav_bandlimits[j], L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; + so3_parameters.L0 = 0; + + f_wav_lmn = (complex double *)calloc( + so3_sampling_flmn_size(&so3_parameters), sizeof(complex double)); + + for (n = -Nj + 1; n < Nj; n += 2) { + for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = 8 * PI * PI / (2 * el + 1) * conj(wav_lm[j * L * L + lm_ind]); + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); + f_wav_lmn[lmn_ind] = flm[lm_ind] * psi; } - -// so3_core_inverse_via_ssht( - so3_core_inverse_direct( - f_wav + offset, - f_wav_lmn, - &so3_parameters - ); - - free(f_wav_lmn); - offset += so3_sampling_f_size(&so3_parameters); - + } } -} + // so3_core_inverse_via_ssht( + so3_core_inverse_direct(f_wav + offset, f_wav_lmn, &so3_parameters); + free(f_wav_lmn); + offset += so3_sampling_f_size(&so3_parameters); + } +} /*! * Wavelet analysis from harmonic space to wavelet space for complex signals. @@ -322,76 +291,69 @@ void s2let_analysis_lm2wav( complex double *f_wav, complex double *f_scal, const complex double *flm, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - ssht_dl_method_t dl_method = parameters->dl_method; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - int j, offset, offset_lmn; - int J = s2let_j_max(parameters); - - complex double *wav_lm; - double *scal_l; - s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); - s2let_tiling_wavelet(wav_lm, scal_l, parameters); - - complex double *f_wav_lmn, *f_scal_lm; - - s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); - s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, parameters); - - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - - // Note, this is a spin-0 transform! - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_inverse_sov_sym_ss(f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + ssht_dl_method_t dl_method = parameters->dl_method; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + int j, offset, offset_lmn; + int J = s2let_j_max(parameters); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); + s2let_tiling_wavelet(wav_lm, scal_l, parameters); + + complex double *f_wav_lmn, *f_scal_lm; + + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); + s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, parameters); + + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + + // Note, this is a spin-0 transform! + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_inverse_sov_sym_ss( + f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + offset = 0; + offset_lmn = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; } - offset = 0; - offset_lmn = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } + so3_parameters.L0 = s2let_L0(j, parameters); - so3_parameters.L0 = s2let_L0(j, parameters); - -// so3_core_inverse_via_ssht( - so3_core_inverse_direct( - f_wav + offset, - f_wav_lmn + offset_lmn, - &so3_parameters - ); - offset_lmn += so3_sampling_flmn_size(&so3_parameters); - offset += so3_sampling_f_size(&so3_parameters); - } + // so3_core_inverse_via_ssht( + so3_core_inverse_direct(f_wav + offset, f_wav_lmn + offset_lmn, &so3_parameters); + offset_lmn += so3_sampling_flmn_size(&so3_parameters); + offset += so3_sampling_f_size(&so3_parameters); + } - free(wav_lm); - free(scal_l); - free(f_scal_lm); - free(f_wav_lmn); + free(wav_lm); + free(scal_l); + free(f_scal_lm); + free(f_wav_lmn); } /*! @@ -410,77 +372,73 @@ void s2let_analysis_lm2wav_real( double *f_wav, double *f_scal, const complex double *flm, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - ssht_dl_method_t dl_method = parameters->dl_method; - - s2let_parameters_t real_parameters = *parameters; - real_parameters.reality = 1; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, &real_parameters); - - int j, offset, offset_lmn; - int J = s2let_j_max(&real_parameters); - - complex double *wav_lm; - double *scal_l; - s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters); - s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters); - - complex double *f_wav_lmn, *f_scal_lm; - - s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters); - s2let_analysis_lm2lmn_real(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, &real_parameters); - - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, &real_parameters), L); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_inverse_sov_sym_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_inverse_sov_sym_ss_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + ssht_dl_method_t dl_method = parameters->dl_method; + + s2let_parameters_t real_parameters = *parameters; + real_parameters.reality = 1; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, &real_parameters); + + int j, offset, offset_lmn; + int J = s2let_j_max(&real_parameters); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters); + s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters); + + complex double *f_wav_lmn, *f_scal_lm; + + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters); + s2let_analysis_lm2lmn_real( + f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, &real_parameters); + + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, &real_parameters), L); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_inverse_sov_sym_real( + f_scal, f_scal_lm, bandlimit, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_inverse_sov_sym_ss_real( + f_scal, f_scal_lm, bandlimit, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + offset = 0; + offset_lmn = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; } - offset = 0; - offset_lmn = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } - - so3_parameters.L0 = s2let_L0(j, parameters); + so3_parameters.L0 = s2let_L0(j, parameters); - so3_core_inverse_via_ssht_real( - f_wav + offset, - f_wav_lmn + offset_lmn, - &so3_parameters - ); - offset_lmn += so3_sampling_flmn_size(&so3_parameters); - offset += so3_sampling_f_size(&so3_parameters); - } + so3_core_inverse_via_ssht_real( + f_wav + offset, f_wav_lmn + offset_lmn, &so3_parameters); + offset_lmn += so3_sampling_flmn_size(&so3_parameters); + offset += so3_sampling_f_size(&so3_parameters); + } - free(wav_lm); - free(scal_l); - free(f_scal_lm); - free(f_wav_lmn); + free(wav_lm); + free(scal_l); + free(f_scal_lm); + free(f_wav_lmn); } /*! @@ -499,31 +457,29 @@ void s2let_analysis_px2wav( complex double *f_wav, complex double *f_scal, const complex double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int spin = parameters->spin; - ssht_dl_method_t dl_method = parameters->dl_method; - int verbosity = parameters->verbosity; - - complex double *flm; - s2let_allocate_lm(&flm, L); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_forward_sov_conv_sym_ss(flm, f, L, spin, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - s2let_analysis_lm2wav(f_wav, f_scal, flm, parameters); - - free(flm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int spin = parameters->spin; + ssht_dl_method_t dl_method = parameters->dl_method; + int verbosity = parameters->verbosity; + + complex double *flm; + s2let_allocate_lm(&flm, L); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_forward_sov_conv_sym_ss(flm, f, L, spin, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + s2let_analysis_lm2wav(f_wav, f_scal, flm, parameters); + + free(flm); } /*! @@ -542,28 +498,26 @@ void s2let_analysis_px2wav_real( double *f_wav, double *f_scal, const double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - ssht_dl_method_t dl_method = parameters->dl_method; - int verbosity = 0; - - complex double *flm; - s2let_allocate_lm(&flm, L); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_forward_sov_conv_sym_ss_real(flm, f, L, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - s2let_analysis_lm2wav_real(f_wav, f_scal, flm, parameters); - - free(flm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + ssht_dl_method_t dl_method = parameters->dl_method; + int verbosity = 0; + + complex double *flm; + s2let_allocate_lm(&flm, L); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_forward_sov_conv_sym_ss_real(flm, f, L, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + s2let_analysis_lm2wav_real(f_wav, f_scal, flm, parameters); + + free(flm); } diff --git a/src/main/c/s2let_analysis_adjoint.c b/src/main/c/s2let_analysis_adjoint.c index ee58cd1b..4540cf6f 100644 --- a/src/main/c/s2let_analysis_adjoint.c +++ b/src/main/c/s2let_analysis_adjoint.c @@ -2,27 +2,25 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" -#include -#include #include #include -#include +#include +#include #include +#include + +#include "s2let.h" /*! * Wavelet analysis adjoint from Wigner space to harmonic space for complex signals. * * \param[out] flm Spherical harmonic coefficients of input function. - * \param[in] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet contribution). - * \param[in] f_scal_lm Wavelet transform (spherical harmonic coefficients of scaling contribution). - * \param[in] wav_lm Wavelet kernels. - * \param[in] scal_l Scaling function kernels. - * \param[in] parameters A fully populated parameters object. The \link - * s2let_parameters_t::reality reality\endlink flag - * is ignored. Use \link s2let_synthesis_lmn2lm_real - * \endlink instead for real signals. - * \retval none + * \param[in] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet + * contribution). \param[in] f_scal_lm Wavelet transform (spherical harmonic + * coefficients of scaling contribution). \param[in] wav_lm Wavelet kernels. \param[in] + * scal_l Scaling function kernels. \param[in] parameters A fully populated parameters + * object. The \link s2let_parameters_t::reality reality\endlink flag is ignored. Use + * \link s2let_synthesis_lmn2lm_real \endlink instead for real signals. \retval none */ void s2let_analysis_adjoint_lmn2lm( complex double *flm, @@ -30,86 +28,75 @@ void s2let_analysis_adjoint_lmn2lm( const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - int spin = parameters->spin; - - int j, el, m ,n; - int J = s2let_j_max(parameters); - int bandlimit = L; - int Nj = N; - - int lm_ind, lmn_ind; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - complex double psi; - double phi; - - int offset = 0; - - // Clear output - for (el = 0; el < L*L; ++el) - flm[el] = 0; - - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + int spin = parameters->spin; + + int j, el, m, n; + int J = s2let_j_max(parameters); + int bandlimit = L; + int Nj = N; + + int lm_ind, lmn_ind; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + complex double psi; + double phi; + + int offset = 0; + + // Clear output + for (el = 0; el < L * L; ++el) + flm[el] = 0; + + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; + } - for (n = -Nj+1; n < Nj; n+=2) - { - for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = 8*PI*PI/(2*el+1) * (wav_lm[j*L*L + lm_ind]); - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); - flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi; - } - } + for (n = -Nj + 1; n < Nj; n += 2) { + for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = 8 * PI * PI / (2 * el + 1) * (wav_lm[j * L * L + lm_ind]); + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); + flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi; } - offset += so3_sampling_flmn_size(&so3_parameters); + } } + offset += so3_sampling_flmn_size(&so3_parameters); + } - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); - for (el = ABS(spin); el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - flm[lm_ind] += f_scal_lm[lm_ind] * phi; - } + for (el = ABS(spin); el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + flm[lm_ind] += f_scal_lm[lm_ind] * phi; } + } } /*! * Wavelet analysis adjoint from Wigner space to harmonic space for real signals. * * \param[out] flm Spherical harmonic coefficients of input function. - * \param[in] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet contribution). - * \param[in] f_scal_lm Wavelet transform (spherical harmonic coefficients of scaling contribution). - * \param[in] wav_lm Wavelet kernels. - * \param[in] scal_l Scaling function kernels. - * \param[in] parameters A fully populated parameters object. The \link - * s2let_parameters_t::reality reality\endlink flag - * is ignored. Use \link s2let_synthesis_lmn2lm - * \endlink instead for complex signals. - * \retval none + * \param[in] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet + * contribution). \param[in] f_scal_lm Wavelet transform (spherical harmonic + * coefficients of scaling contribution). \param[in] wav_lm Wavelet kernels. \param[in] + * scal_l Scaling function kernels. \param[in] parameters A fully populated parameters + * object. The \link s2let_parameters_t::reality reality\endlink flag is ignored. Use + * \link s2let_synthesis_lmn2lm \endlink instead for complex signals. \retval none */ void s2let_analysis_adjoint_lmn2lm_real( complex double *flm, @@ -117,108 +104,98 @@ void s2let_analysis_adjoint_lmn2lm_real( const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - - int j, el, m ,n; - int J = s2let_j_max(parameters); - int bandlimit = L; - int Nj = N; - - int lm_ind, lmn_ind; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - complex double psi, npsi; - double phi; - - int offset = 0; - - // Clear output - for (el = 0; el < L*L; ++el) - flm[el] = 0; - - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + + int j, el, m, n; + int J = s2let_j_max(parameters); + int bandlimit = L; + int Nj = N; + + int lm_ind, lmn_ind; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + complex double psi, npsi; + double phi; + + int offset = 0; + + // Clear output + for (el = 0; el < L * L; ++el) + flm[el] = 0; + + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; + } + + for (n = 1 - Nj % 2; n < Nj; n += 2) { + for (el = n; el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = 8 * PI * PI / (2 * el + 1) * wav_lm[j * L * L + lm_ind]; + + if (n) { + ssht_sampling_elm2ind(&lm_ind, el, -n); + npsi = 8 * PI * PI / (2 * el + 1) * wav_lm[j * L * L + lm_ind]; } - for (n = 1-Nj%2; n < Nj; n+=2) - { - for (el = n; el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = 8*PI*PI/(2*el+1) * wav_lm[j*L*L + lm_ind]; - - if (n) - { - ssht_sampling_elm2ind(&lm_ind, el, -n); - npsi = 8*PI*PI/(2*el+1) * wav_lm[j*L*L + lm_ind]; - } - - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters); - flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi; - - if (n) - { - so3_sampling_elmn2ind_real(&lmn_ind, el, -m, n, &so3_parameters); - int sign = (m+n)%2 ? -1 : 1; - flm[lm_ind] += sign * conj(f_wav_lmn[offset + lmn_ind]) * npsi; - } - } - } + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters); + flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi; + + if (n) { + so3_sampling_elmn2ind_real(&lmn_ind, el, -m, n, &so3_parameters); + int sign = (m + n) % 2 ? -1 : 1; + flm[lm_ind] += sign * conj(f_wav_lmn[offset + lmn_ind]) * npsi; + } } - offset += so3_sampling_flmn_size(&so3_parameters); + } } + offset += so3_sampling_flmn_size(&so3_parameters); + } - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); - for (el = 0; el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - flm[lm_ind] += f_scal_lm[lm_ind] * phi; - } + for (el = 0; el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + flm[lm_ind] += f_scal_lm[lm_ind] * phi; } + } } /*! * Wavelet analysis adjoint from wavelet space to harmonic space for complex signals. - * with fully manual wavelet tiling, using multiresolution as default with + * with fully manual wavelet tiling, using multiresolution as default with * the band-limits provided in input. * * \param[out] flm Spherical harmonic coefficients of the signal * \param[in] f_wav Array of wavelets maps * \param[in] f_scal Scaling function map - * \param[in] scal_l Array of size L containing the \ell space tiling for the scaling fct. - It is only \ell because it is assumed to be axisymmetric. - * \param[in] wav_lm Array of size (J+1)*L*L containing the (\ell, space) harmonic coefs - of the wavelets. They can be directional. These must make sense and - define a valid invertible transform as no extra checks are performed. + * \param[in] scal_l Array of size L containing the \ell space tiling for the scaling + fct. It is only \ell because it is assumed to be axisymmetric. + * \param[in] wav_lm Array of size (J+1)*L*L containing the (\ell, space) harmonic + coefs of the wavelets. They can be directional. These must make sense and define a + valid invertible transform as no extra checks are performed. * \param[in] scal_bandlimit Same as wav_bandlimits but only one integer: the band-limit of the scaling function. - * \param[in] wav_bandlimits Array of integers of size J+1 containing the band-limits + * \param[in] wav_bandlimits Array of integers of size J+1 containing the band-limits of the wavelets. Will be used to do the multiresolution. These must make sense and define a valid invertible transform as no extra checks are performed. - * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. + * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. * \param[in] L Band-limit for the transform: defines the size of all awways. - * \param[in] spin Spin (integer) to perform the transform + * \param[in] spin Spin (integer) to perform the transform * \param[in] N Azimuthal band-limit for the directional transform * \retval none */ @@ -233,97 +210,85 @@ void s2let_analysis_adjoint_wav2lm_manual( int J, int L, int spin, - int N -) { - s2let_parameters_t parameters = {}; - parameters.L = L; - parameters.J_min = 0; - parameters.B = pow(L, 1.0/(float)J); - parameters.N = N; - parameters.dl_method = SSHT_DL_RISBO; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, ¶meters); - - int j, offset; - complex double *f_wav_lmn, *f_scal_lm; - complex double psi; - double phi; - int el, m, n, lm_ind, lmn_ind; - - bandlimit = MIN(scal_bandlimit, L); - - f_scal_lm = (complex double*)calloc(bandlimit*bandlimit, sizeof(complex double)); - - // Note, this is a spin-0 transform! - switch (parameters.sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_inverse_sov_sym(f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_inverse_sov_sym_ss(f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - for (el = ABS(spin); el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - flm[lm_ind] += f_scal_lm[lm_ind] * phi; - } + int N) { + s2let_parameters_t parameters = {}; + parameters.L = L; + parameters.J_min = 0; + parameters.B = pow(L, 1.0 / (float)J); + parameters.N = N; + parameters.dl_method = SSHT_DL_RISBO; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, ¶meters); + + int j, offset; + complex double *f_wav_lmn, *f_scal_lm; + complex double psi; + double phi; + int el, m, n, lm_ind, lmn_ind; + + bandlimit = MIN(scal_bandlimit, L); + + f_scal_lm = (complex double *)calloc(bandlimit * bandlimit, sizeof(complex double)); + + // Note, this is a spin-0 transform! + switch (parameters.sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_inverse_sov_sym( + f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_inverse_sov_sym_ss( + f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + for (el = ABS(spin); el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + flm[lm_ind] += f_scal_lm[lm_ind] * phi; } - - free(f_scal_lm); - - offset = 0; - for (j = 0; j <= J; ++j) - { - bandlimit = MIN(wav_bandlimits[j], L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - so3_parameters.L0 = 0; - - f_wav_lmn = (complex double*)calloc(so3_sampling_flmn_size(&so3_parameters), sizeof(complex double)); - -// so3_core_forward_direct( - so3_adjoint_inverse_direct( - f_wav_lmn, - f_wav + offset, - &so3_parameters - ); - - for (n = -Nj+1; n < Nj; n+=2) - { - for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = 8*PI*PI/(2*el+1) * conj(wav_lm[j*L*L + lm_ind]); - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); - flm[lm_ind] += f_wav_lmn[lmn_ind] * psi; - } - } + } + + free(f_scal_lm); + + offset = 0; + for (j = 0; j <= J; ++j) { + bandlimit = MIN(wav_bandlimits[j], L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; + so3_parameters.L0 = 0; + + f_wav_lmn = (complex double *)calloc( + so3_sampling_flmn_size(&so3_parameters), sizeof(complex double)); + + // so3_core_forward_direct( + so3_adjoint_inverse_direct(f_wav_lmn, f_wav + offset, &so3_parameters); + + for (n = -Nj + 1; n < Nj; n += 2) { + for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = 8 * PI * PI / (2 * el + 1) * conj(wav_lm[j * L * L + lm_ind]); + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); + flm[lm_ind] += f_wav_lmn[lmn_ind] * psi; } - - free(f_wav_lmn); - offset += so3_sampling_f_size(&so3_parameters); - + } } + free(f_wav_lmn); + offset += so3_sampling_f_size(&so3_parameters); + } } - /*! * Wavelet analysis adjoint from wavelet space to harmonic space for complex signals. * @@ -340,89 +305,86 @@ void s2let_analysis_adjoint_wav2lm( complex double *flm, const complex double *f_wav, const complex double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - ssht_dl_method_t dl_method = parameters->dl_method; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - int j, offset, offset_lmn; - int J = s2let_j_max(parameters); - - complex double *wav_lm; - double *scal_l; - s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); - s2let_tiling_wavelet(wav_lm, scal_l, parameters); - - complex double *f_wav_lmn, *f_scal_lm; - s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); - - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - - // Note, this is a spin-0 transform! - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_inverse_sov_sym(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_inverse_sov_sym_ss(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - // switch (parameters->sampling_scheme) - // { - // case S2LET_SAMPLING_MW: - // ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); - // break; - // case S2LET_SAMPLING_MW_SS: - // ssht_core_mw_forward_sov_conv_sym_ss(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); - // break; - // default: - // S2LET_ERROR_GENERIC("Sampling scheme not supported."); - // } - - offset = 0; - offset_lmn = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } - - so3_parameters.L0 = s2let_L0(j, parameters); - - so3_adjoint_inverse_direct( -// so3_core_forward_direct( -// so3_core_forward_via_ssht( - f_wav_lmn + offset_lmn, - f_wav + offset, - &so3_parameters - ); - offset_lmn += so3_sampling_flmn_size(&so3_parameters); - offset += so3_sampling_f_size(&so3_parameters); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + ssht_dl_method_t dl_method = parameters->dl_method; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + int j, offset, offset_lmn; + int J = s2let_j_max(parameters); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); + s2let_tiling_wavelet(wav_lm, scal_l, parameters); + + complex double *f_wav_lmn, *f_scal_lm; + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); + + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + + // Note, this is a spin-0 transform! + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_inverse_sov_sym( + f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_inverse_sov_sym_ss( + f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + // switch (parameters->sampling_scheme) + // { + // case S2LET_SAMPLING_MW: + // ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, bandlimit, 0, dl_method, + // verbosity); break; + // case S2LET_SAMPLING_MW_SS: + // ssht_core_mw_forward_sov_conv_sym_ss(f_scal_lm, f_scal, bandlimit, 0, + // dl_method, verbosity); break; + // default: + // S2LET_ERROR_GENERIC("Sampling scheme not supported."); + // } + + offset = 0; + offset_lmn = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; } - s2let_analysis_adjoint_lmn2lm(flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, parameters); -// s2let_synthesis_lmn2lm(flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, parameters); - - free(wav_lm); - free(scal_l); - free(f_scal_lm); - free(f_wav_lmn); + so3_parameters.L0 = s2let_L0(j, parameters); + + so3_adjoint_inverse_direct( + // so3_core_forward_direct( + // so3_core_forward_via_ssht( + f_wav_lmn + offset_lmn, + f_wav + offset, + &so3_parameters); + offset_lmn += so3_sampling_flmn_size(&so3_parameters); + offset += so3_sampling_f_size(&so3_parameters); + } + + s2let_analysis_adjoint_lmn2lm(flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, parameters); + // s2let_synthesis_lmn2lm(flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, parameters); + + free(wav_lm); + free(scal_l); + free(f_scal_lm); + free(f_wav_lmn); } /*! @@ -441,80 +403,74 @@ void s2let_analysis_adjoint_wav2lm_real( complex double *flm, const double *f_wav, const double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - ssht_dl_method_t dl_method = parameters->dl_method; - - s2let_parameters_t real_parameters = *parameters; - real_parameters.reality = 1; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, &real_parameters); - - int j, offset, offset_lmn; - int J = s2let_j_max(&real_parameters); - - complex double *wav_lm; - double *scal_l; - s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters); - s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters); - - complex double *f_wav_lmn, *f_scal_lm; - s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters); - - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, &real_parameters), L); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_inverse_sov_sym_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_inverse_sov_sym_ss_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + ssht_dl_method_t dl_method = parameters->dl_method; + + s2let_parameters_t real_parameters = *parameters; + real_parameters.reality = 1; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, &real_parameters); + + int j, offset, offset_lmn; + int J = s2let_j_max(&real_parameters); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters); + s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters); + + complex double *f_wav_lmn, *f_scal_lm; + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters); + + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, &real_parameters), L); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_inverse_sov_sym_real( + f_scal_lm, f_scal, bandlimit, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_inverse_sov_sym_ss_real( + f_scal_lm, f_scal, bandlimit, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + offset = 0; + offset_lmn = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; } + so3_parameters.L0 = s2let_L0(j, parameters); - offset = 0; - offset_lmn = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } - - so3_parameters.L0 = s2let_L0(j, parameters); - - so3_adjoint_inverse_direct_real( - f_wav_lmn + offset_lmn, - f_wav + offset, - &so3_parameters - ); + so3_adjoint_inverse_direct_real( + f_wav_lmn + offset_lmn, f_wav + offset, &so3_parameters); - offset_lmn += so3_sampling_flmn_size(&so3_parameters); - offset += so3_sampling_f_size(&so3_parameters); - } + offset_lmn += so3_sampling_flmn_size(&so3_parameters); + offset += so3_sampling_f_size(&so3_parameters); + } - s2let_analysis_adjoint_lmn2lm_real( - flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, &real_parameters); + s2let_analysis_adjoint_lmn2lm_real( + flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, &real_parameters); - free(wav_lm); - free(scal_l); - free(f_scal_lm); - free(f_wav_lmn); + free(wav_lm); + free(scal_l); + free(f_scal_lm); + free(f_wav_lmn); } /*! @@ -533,32 +489,30 @@ void s2let_analysis_adjoint_wav2px( complex double *f, const complex double *f_wav, const complex double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int spin = parameters->spin; - ssht_dl_method_t dl_method = parameters->dl_method; - int verbosity = 0; - - complex double *flm; - s2let_allocate_lm(&flm, L); - -// s2let_synthesis_wav2lm(flm, f_wav, f_scal, parameters); - s2let_analysis_adjoint_wav2lm(flm, f_wav, f_scal, parameters); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_forward_sov_sym(f, flm, L, spin, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_forward_sov_sym_ss(f, flm, L, spin, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - free(flm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int spin = parameters->spin; + ssht_dl_method_t dl_method = parameters->dl_method; + int verbosity = 0; + + complex double *flm; + s2let_allocate_lm(&flm, L); + + // s2let_synthesis_wav2lm(flm, f_wav, f_scal, parameters); + s2let_analysis_adjoint_wav2lm(flm, f_wav, f_scal, parameters); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_forward_sov_sym(f, flm, L, spin, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_forward_sov_sym_ss(f, flm, L, spin, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + free(flm); } /*! @@ -577,28 +531,26 @@ void s2let_analysis_adjoint_wav2px_real( double *f, const double *f_wav, const double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - ssht_dl_method_t dl_method = parameters->dl_method; - int verbosity = 0; - - complex double *flm; - s2let_allocate_lm(&flm, L); - - s2let_analysis_adjoint_wav2lm_real(flm, f_wav, f_scal, parameters); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_forward_sov_sym_real(f, flm, L, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_forward_sov_sym_ss_real(f, flm, L, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - free(flm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + ssht_dl_method_t dl_method = parameters->dl_method; + int verbosity = 0; + + complex double *flm; + s2let_allocate_lm(&flm, L); + + s2let_analysis_adjoint_wav2lm_real(flm, f_wav, f_scal, parameters); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_forward_sov_sym_real(f, flm, L, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_forward_sov_sym_ss_real(f, flm, L, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + free(flm); } diff --git a/src/main/c/s2let_axisym_denoising_demo.c b/src/main/c/s2let_axisym_denoising_demo.c index d61026c5..1c6ed8c9 100644 --- a/src/main/c/s2let_axisym_denoising_demo.c +++ b/src/main/c/s2let_axisym_denoising_demo.c @@ -2,26 +2,29 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include -#include #include +#include +#include #include #include #include -#include #include -void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise) { +#include "s2let.h" + +void s2let_lm_random_flm_real_sigma( + complex double *flm, int L, int seed, double sigmanoise) { int el, m, msign, i, i_op; - for (el=0; el SNR before denoising = %f\n", SNR_actual); printf(" -> SNR after denoising = %f\n", SNR_denoised); // Finally write the denoised signal printf(" Write output files\n"); - sprintf(outfile, "%s%s%s", "data/earth_tomo_mw_128", "_noisy" , ".fits"); - printf(" Outfile = %s\n",outfile); - remove(outfile); // In case the file exists + sprintf(outfile, "%s%s%s", "data/earth_tomo_mw_128", "_noisy", ".fits"); + printf(" Outfile = %s\n", outfile); + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, g, L); // Now write the map to fits file char params[100]; sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min); sprintf(outfile, "%s%s%s", "data/earth_tomo_mw_128", "_denoised", ".fits"); - printf(" Outfile = %s\n",outfile); - remove(outfile); // In case the file exists + printf(" Outfile = %s\n", outfile); + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, f_denois, L); // Now write the map to fits file free(f); diff --git a/src/main/c/s2let_denoising_demo.c b/src/main/c/s2let_denoising_demo.c index cad5e5fe..e152e13a 100644 --- a/src/main/c/s2let_denoising_demo.c +++ b/src/main/c/s2let_denoising_demo.c @@ -2,26 +2,29 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" -#include #include #include +#include +#include #include #include #include -#include #include -void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise) { +#include "s2let.h" + +void s2let_lm_random_flm_real_sigma( + complex double *flm, int L, int seed, double sigmanoise) { int el, m, msign, i, i_op; - for (el=0; elL; - int J_min = parameters->J_min; - int N = parameters->N; - - int J = s2let_j_max(parameters); - int i, j, offset = 0; - for(j = J_min; j <= J; j++){ - int bl = parameters->upsample ? L : MIN(s2let_bandlimit(j, parameters), L); - for(i = 0; i < N*bl*(2*bl-1); i++){ - if( cabs(g_wav[offset + i]) < threshold[j-J_min] ) - g_wav[offset + i] = 0; - } - offset += N*bl*(2*bl-1); + double *g_wav, const double *threshold, const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + + int J = s2let_j_max(parameters); + int i, j, offset = 0; + for (j = J_min; j <= J; j++) { + int bl = parameters->upsample ? L : MIN(s2let_bandlimit(j, parameters), L); + for (i = 0; i < N * bl * (2 * bl - 1); i++) { + if (cabs(g_wav[offset + i]) < threshold[j - J_min]) + g_wav[offset + i] = 0; } + offset += N * bl * (2 * bl - 1); + } } /*! @@ -63,18 +63,17 @@ void hard_threshold_real( * COMMAND : bin/s2let_denoising_demo * ARGUMENTS : none */ -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { s2let_parameters_t parameters = {}; - const int seed = (int)(10000.0*(double)clock()/(double)CLOCKS_PER_SEC); + const int seed = (int)(10000.0 * (double)clock() / (double)CLOCKS_PER_SEC); // PARAMETERS - const double SNR_in = 10.0; // Input SNR - const int nsigma = 3; // Number of sigmas for hard thresholding - const int upsample = 0; // Multiresolution flag - const double B = 2; // Wavelet parameters - const int N = 4; // Azimuthal band-limit - const int J_min = 0; // First wavelet scale to use + const double SNR_in = 10.0; // Input SNR + const int nsigma = 3; // Number of sigmas for hard thresholding + const int upsample = 0; // Multiresolution flag + const double B = 2; // Wavelet parameters + const int N = 4; // Azimuthal band-limit + const int J_min = 0; // First wavelet scale to use char outfile[100]; int i, j; @@ -93,14 +92,14 @@ int main(int argc, char *argv[]) printf("--------------------------------------------------\n"); char file[100] = "data/earth_tomo_mw_128.fits"; - printf(" Reading file %s\n",file); + printf(" Reading file %s\n", file); const int L = s2let_fits_mw_read_bandlimit(file); parameters.L = L; - printf(" - Detected bandlimit L = %i\n",L); + printf(" - Detected bandlimit L = %i\n", L); int J = s2let_j_max(¶meters); printf(" Parameters for wavelet denoising :\n"); s2let_switch_wavtype(1); - printf(" - Input SNR : %f\n",SNR_in); + printf(" - Input SNR : %f\n", SNR_in); printf(" - Sigma threshold : %i\n", nsigma); printf(" - upsample flag : %i\n", upsample); printf(" - Wavelet parameter : %i\n", B); @@ -109,28 +108,31 @@ int main(int argc, char *argv[]) s2let_allocate_mw_real(&f, L); s2let_fits_mw_read_map(f, file, L); // Read MW map from file - for(i = 0; i < L*(2*L-1); i++) + for (i = 0; i < L * (2 * L - 1); i++) f[i] = f[i] * 1000; printf(" File successfully read from file\n"); // Compute noise standard deviation and generate noise - double sigmanoise = sqrt(pow(10.0, -SNR_in/10.0) * s2let_mw_power_real(f, L)); + double sigmanoise = sqrt(pow(10.0, -SNR_in / 10.0) * s2let_mw_power_real(f, L)); printf(" - Std dev of the noise (to match SNR) = %f\n", sigmanoise); s2let_allocate_lm(&noise_lm, L); s2let_lm_random_flm_real_sigma(noise_lm, L, seed, sigmanoise); - double SNR_actual = 10.0 * log10( s2let_mw_power_real(f, L) / s2let_lm_power(noise_lm, L)); + double SNR_actual = + 10.0 * log10(s2let_mw_power_real(f, L) / s2let_lm_power(noise_lm, L)); printf(" - Actual (realised) SNR = %f\n", SNR_actual); // Add noise to the signal in real space - printf(" Contaminating the signal with this noise...");fflush(NULL); + printf(" Contaminating the signal with this noise..."); + fflush(NULL); s2let_allocate_mw_real(&noise, L); s2let_mw_alm2map_real(noise, noise_lm, L); s2let_allocate_mw_real(&g, L); - for(i = 0; i < L*(2*L-1); i++) + for (i = 0; i < L * (2 * L - 1); i++) g[i] = f[i] + noise[i]; printf(" done\n"); - printf(" Performing wavelet decomposition...");fflush(NULL); + printf(" Performing wavelet decomposition..."); + fflush(NULL); // Perform wavelet analysis from scratch with all signals given as MW maps s2let_allocate_f_wav_real(&g_wav, &g_scal, ¶meters); s2let_analysis_px2wav_real(g_wav, g_scal, g, ¶meters); @@ -140,11 +142,13 @@ int main(int argc, char *argv[]) printf(" Construct the threshold rule for the Gaussian noise\n"); s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, ¶meters); s2let_tiling_wavelet(wav_lm, scal_l, ¶meters); - double *threshold = (double*)calloc((J-J_min+1), sizeof(double)); - for(j = J_min; j <= J; j++) - threshold[j-J_min] = sigmanoise * nsigma * sqrt(waveletpower(wav_lm + j * L*L, L)); + double *threshold = (double *)calloc((J - J_min + 1), sizeof(double)); + for (j = J_min; j <= J; j++) + threshold[j - J_min] = + sigmanoise * nsigma * sqrt(waveletpower(wav_lm + j * L * L, L)); - printf(" Hard thresholding the wavelets...");fflush(NULL); + printf(" Hard thresholding the wavelets..."); + fflush(NULL); s2let_allocate_mw_real(&f_denoised, L); hard_threshold_real(g_wav, threshold, ¶meters); s2let_synthesis_wav2px_real(f_denoised, g_wav, g_scal, ¶meters); @@ -152,31 +156,32 @@ int main(int argc, char *argv[]) // Remaining noise s2let_allocate_mw_real(&remaining_noise, L); - for(i = 0; i < L*(2*L-1); i++) + for (i = 0; i < L * (2 * L - 1); i++) remaining_noise[i] = f_denoised[i] - f[i]; // SNR after denoising - double SNR_denoised = 10.0 * log10( s2let_mw_power_real(f, L) / s2let_mw_power_real(remaining_noise, L)); + double SNR_denoised = + 10.0 * log10(s2let_mw_power_real(f, L) / s2let_mw_power_real(remaining_noise, L)); printf(" -> SNR before denoising = %f\n", SNR_actual); printf(" -> SNR after denoising = %f\n", SNR_denoised); // Finally write the denoised signal printf(" Write output files\n"); - sprintf(outfile, "%s%s%s", "data/real_signal", "_U_input" , ".fits"); - printf(" Outfile = %s\n",outfile); - remove(outfile); // In case the file exists + sprintf(outfile, "%s%s%s", "data/real_signal", "_U_input", ".fits"); + printf(" Outfile = %s\n", outfile); + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, f, L); // Now write the map to fits file - sprintf(outfile, "%s%s%s", "data/real_signal", "_U_noise" , ".fits"); - printf(" Outfile = %s\n",outfile); - remove(outfile); // In case the file exists + sprintf(outfile, "%s%s%s", "data/real_signal", "_U_noise", ".fits"); + printf(" Outfile = %s\n", outfile); + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, noise, L); // Now write the map to fits file - sprintf(outfile, "%s%s%s", "data/real_signal", "_U_input_noise" , ".fits"); - printf(" Outfile = %s\n",outfile); - remove(outfile); // In case the file exists + sprintf(outfile, "%s%s%s", "data/real_signal", "_U_input_noise", ".fits"); + printf(" Outfile = %s\n", outfile); + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, g, L); // Now write the map to fits file sprintf(outfile, "%s%s%s", "data/real_signal", "_U_denoised", ".fits"); - printf(" Outfile = %s\n",outfile); - remove(outfile); // In case the file exists + printf(" Outfile = %s\n", outfile); + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, f_denoised, L); // Now write the map to fits file free(f); diff --git a/src/main/c/s2let_fits.c b/src/main/c/s2let_fits.c index 81982bbb..cc66ede1 100644 --- a/src/main/c/s2let_fits.c +++ b/src/main/c/s2let_fits.c @@ -3,362 +3,336 @@ // Boris Leistedt & Jason McEwen #include -#include "s2let.h" +#include "s2let.h" -void printerror(int status) -{ - if (status){ +void printerror(int status) { + if (status) { fits_report_error(stderr, status); /* print error report */ - exit( status ); /* terminate the program, returning error status */ + exit(status); /* terminate the program, returning error status */ } return; } -int s2let_fits_mw_read_bandlimit(char* filename) -{ - long naxes, *naxis, Lread; - int status, hdutype, nfound; - char comment[FLEN_COMMENT]; +int s2let_fits_mw_read_bandlimit(char *filename) { + long naxes, *naxis, Lread; + int status, hdutype, nfound; + char comment[FLEN_COMMENT]; fitsfile *fptr; status = 0; + if (fits_open_file(&fptr, filename, READONLY, &status)) + printerror(status); - if ( fits_open_file(&fptr, filename, READONLY, &status) ) - printerror( status ); - - if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) ) - printerror( status ); + if (fits_movabs_hdu(fptr, 2, &hdutype, &status)) + printerror(status); if (hdutype != BINARY_TBL) fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__); - if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) ) - printerror( status ); + if (fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status)) + printerror(status); - naxis = (long *)malloc(((size_t)naxes)*sizeof(long)); - if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) - || nfound != naxes ) - printerror( status ); + naxis = (long *)malloc(((size_t)naxes) * sizeof(long)); + if (fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) || + nfound != naxes) + printerror(status); - if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) ) - { + if (fits_read_key_lng(fptr, "L", &Lread, comment, &status)) { Lread = -1; status = 0; } - - if ( fits_close_file(fptr, &status) ) - printerror( status ); + if (fits_close_file(fptr, &status)) + printerror(status); return Lread; - } - -int s2let_fits_hpx_read_nside(char* filename) -{ - long naxes, *naxis, nsideread; - int status, hdutype, nfound; - char comment[FLEN_COMMENT]; +int s2let_fits_hpx_read_nside(char *filename) { + long naxes, *naxis, nsideread; + int status, hdutype, nfound; + char comment[FLEN_COMMENT]; fitsfile *fptr; status = 0; + if (fits_open_file(&fptr, filename, READONLY, &status)) + printerror(status); - if ( fits_open_file(&fptr, filename, READONLY, &status) ) - printerror( status ); - - if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) ) - printerror( status ); + if (fits_movabs_hdu(fptr, 2, &hdutype, &status)) + printerror(status); if (hdutype != BINARY_TBL) fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__); - if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) ) - printerror( status ); + if (fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status)) + printerror(status); - naxis = (long *)malloc(((size_t)naxes)*sizeof(long)); - if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) - || nfound != naxes ) - printerror( status ); + naxis = (long *)malloc(((size_t)naxes) * sizeof(long)); + if (fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) || + nfound != naxes) + printerror(status); - if ( fits_read_key_lng(fptr, "NSIDE", &nsideread, comment, &status) ) - { + if (fits_read_key_lng(fptr, "NSIDE", &nsideread, comment, &status)) { nsideread = -1; status = 0; } - if ( fits_close_file(fptr, &status) ) - printerror( status ); + if (fits_close_file(fptr, &status)) + printerror(status); return nsideread; - } -void s2let_fits_mw_write_map(char* filename, double* f, int L) -{ +void s2let_fits_mw_write_map(char *filename, double *f, int L) { fitsfile *fptr; int status, hdutype; long firstrow, firstelem; - int bitpix = SHORT_IMG; - long naxis = 0; - long naxes[] = {0,0}; - int tfields = 1; + int bitpix = SHORT_IMG; + long naxis = 0; + long naxes[] = {0, 0}; + int tfields = 1; char extname[] = "BINTABLE"; - char *ttype[] = { "SIGNAL" }; - char *tform[] = { "1D" }; - char *tunit[] = { " " }; + char *ttype[] = {"SIGNAL"}; + char *tform[] = {"1D"}; + char *tunit[] = {" "}; - long npix = L * (2*L-1); + long npix = L * (2 * L - 1); status = 0; if (fits_create_file(&fptr, filename, &status)) - fprintf(stderr, "%s (%d): Could not create new fits file.\n", - __FILE__, __LINE__); + fprintf(stderr, "%s (%d): Could not create new fits file.\n", __FILE__, __LINE__); - if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) ) - fprintf(stderr, "%s (%d): Could not create new image file.\n", - __FILE__, __LINE__); + if (fits_create_img(fptr, bitpix, naxis, naxes, &status)) + fprintf(stderr, "%s (%d): Could not create new image file.\n", __FILE__, __LINE__); - if ( fits_movabs_hdu(fptr, 1, &hdutype, &status) ) - fprintf(stderr, "%s (%d): Could not move to first HDU.\n", - __FILE__, __LINE__); + if (fits_movabs_hdu(fptr, 1, &hdutype, &status)) + fprintf(stderr, "%s (%d): Could not move to first HDU.\n", __FILE__, __LINE__); - if ( fits_create_tbl( fptr, BINARY_TBL, npix, tfields, ttype, tform, - tunit, extname, &status) ) - fprintf(stderr, "%s (%d): Could not create new binary table.\n", - __FILE__, __LINE__); + if (fits_create_tbl( + fptr, BINARY_TBL, npix, tfields, ttype, tform, tunit, extname, &status)) + fprintf( + stderr, "%s (%d): Could not create new binary table.\n", __FILE__, __LINE__); - if (fits_write_key(fptr, TINT, "L", &L, - "Resolution parameter", &status)) - fprintf(stderr, "%s (%d): Could not write L keyword.\n", - __FILE__, __LINE__); + if (fits_write_key(fptr, TINT, "L", &L, "Resolution parameter", &status)) + fprintf(stderr, "%s (%d): Could not write L keyword.\n", __FILE__, __LINE__); - firstrow = 1; + firstrow = 1; firstelem = 1; if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, npix, f, &status)) fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__); - if ( fits_close_file(fptr, &status) ) /* close the FITS file */ - fprintf(stderr, "%s (%d): Could not close file.\n", - __FILE__, __LINE__); - + if (fits_close_file(fptr, &status)) /* close the FITS file */ + fprintf(stderr, "%s (%d): Could not close file.\n", __FILE__, __LINE__); } -void s2let_fits_mwss_write_map(char* filename, double* f, int L) -{ +void s2let_fits_mwss_write_map(char *filename, double *f, int L) { fitsfile *fptr; int status, hdutype; long firstrow, firstelem; - int bitpix = SHORT_IMG; - long naxis = 0; - long naxes[] = {0,0}; - int tfields = 1; + int bitpix = SHORT_IMG; + long naxis = 0; + long naxes[] = {0, 0}; + int tfields = 1; char extname[] = "BINTABLE"; - char *ttype[] = { "SIGNAL" }; - char *tform[] = { "1D" }; - char *tunit[] = { " " }; + char *ttype[] = {"SIGNAL"}; + char *tform[] = {"1D"}; + char *tunit[] = {" "}; - long npix = (L+1) * 2*L; + long npix = (L + 1) * 2 * L; status = 0; if (fits_create_file(&fptr, filename, &status)) - fprintf(stderr, "%s (%d): Could not create new fits file.\n", - __FILE__, __LINE__); + fprintf(stderr, "%s (%d): Could not create new fits file.\n", __FILE__, __LINE__); - if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) ) - fprintf(stderr, "%s (%d): Could not create new image file.\n", - __FILE__, __LINE__); + if (fits_create_img(fptr, bitpix, naxis, naxes, &status)) + fprintf(stderr, "%s (%d): Could not create new image file.\n", __FILE__, __LINE__); - if ( fits_movabs_hdu(fptr, 1, &hdutype, &status) ) - fprintf(stderr, "%s (%d): Could not move to first HDU.\n", - __FILE__, __LINE__); + if (fits_movabs_hdu(fptr, 1, &hdutype, &status)) + fprintf(stderr, "%s (%d): Could not move to first HDU.\n", __FILE__, __LINE__); - if ( fits_create_tbl( fptr, BINARY_TBL, npix, tfields, ttype, tform, - tunit, extname, &status) ) - fprintf(stderr, "%s (%d): Could not create new binary table.\n", - __FILE__, __LINE__); + if (fits_create_tbl( + fptr, BINARY_TBL, npix, tfields, ttype, tform, tunit, extname, &status)) + fprintf( + stderr, "%s (%d): Could not create new binary table.\n", __FILE__, __LINE__); - if (fits_write_key(fptr, TINT, "L", &L, - "Resolution parameter", &status)) - fprintf(stderr, "%s (%d): Could not write L keyword.\n", - __FILE__, __LINE__); + if (fits_write_key(fptr, TINT, "L", &L, "Resolution parameter", &status)) + fprintf(stderr, "%s (%d): Could not write L keyword.\n", __FILE__, __LINE__); int mwss = 1; - if (fits_write_key(fptr, TINT, "MWSS", &mwss, - "Sampling scheme parameter", &status)) - fprintf(stderr, "%s (%d): Could not write MWSS keyword.\n", - __FILE__, __LINE__); + if (fits_write_key(fptr, TINT, "MWSS", &mwss, "Sampling scheme parameter", &status)) + fprintf(stderr, "%s (%d): Could not write MWSS keyword.\n", __FILE__, __LINE__); - firstrow = 1; + firstrow = 1; firstelem = 1; if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, npix, f, &status)) fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__); - if ( fits_close_file(fptr, &status) ) /* close the FITS file */ - fprintf(stderr, "%s (%d): Could not close file.\n", - __FILE__, __LINE__); - + if (fits_close_file(fptr, &status)) /* close the FITS file */ + fprintf(stderr, "%s (%d): Could not close file.\n", __FILE__, __LINE__); } - -void s2let_fits_mw_read_map(double* f, char* filename, int L) -{ - long naxes, *naxis, npix, npercol, irow, Lread; - int status, hdutype, nfound, anynul; - float nulval; - char comment[FLEN_COMMENT]; +void s2let_fits_mw_read_map(double *f, char *filename, int L) { + long naxes, *naxis, npix, npercol, irow, Lread; + int status, hdutype, nfound, anynul; + float nulval; + char comment[FLEN_COMMENT]; fitsfile *fptr; status = 0; - if ( fits_open_file(&fptr, filename, READONLY, &status) ) - printerror( status ); - - if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) ) - printerror( status ); + if (fits_open_file(&fptr, filename, READONLY, &status)) + printerror(status); + if (fits_movabs_hdu(fptr, 2, &hdutype, &status)) + printerror(status); if (hdutype != BINARY_TBL) fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__); - if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) ) - printerror( status ); + if (fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status)) + printerror(status); - naxis = (long *)malloc(((size_t)naxes)*sizeof(long)); - if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) - || nfound != naxes ) - printerror( status ); + naxis = (long *)malloc(((size_t)naxes) * sizeof(long)); + if (fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) || + nfound != naxes) + printerror(status); - if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) ) + if (fits_read_key_lng(fptr, "L", &Lread, comment, &status)) printerror(status); - if( Lread != L ) - printf("Attention : read L = %li but you specified L = %i\n",Lread,L); + if (Lread != L) + printf("Attention : read L = %li but you specified L = %i\n", Lread, L); - npix = L * (2*L-1); + npix = L * (2 * L - 1); - if ( (npix%naxis[1]) != 0 ) + if ((npix % naxis[1]) != 0) fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__); - npercol = npix/naxis[1]; + npercol = npix / naxis[1]; nulval = -1.6375e30; for (irow = 0; irow < naxis[1]; irow++) { - if ( fits_read_col(fptr, TDOUBLE, 1, irow+1, 1, npercol, &nulval, - &(f[irow*npercol]), &anynul, &status) ) { + if (fits_read_col( + fptr, + TDOUBLE, + 1, + irow + 1, + 1, + npercol, + &nulval, + &(f[irow * npercol]), + &anynul, + &status)) { printerror(status); } } - if ( fits_close_file(fptr, &status) ) - printerror( status ); - + if (fits_close_file(fptr, &status)) + printerror(status); } -void s2let_fits_mwss_read_map(double* f, char* filename, int L) -{ - long naxes, *naxis, npix, npercol, irow, Lread; - int status, hdutype, nfound, anynul; - float nulval; - char comment[FLEN_COMMENT]; +void s2let_fits_mwss_read_map(double *f, char *filename, int L) { + long naxes, *naxis, npix, npercol, irow, Lread; + int status, hdutype, nfound, anynul; + float nulval; + char comment[FLEN_COMMENT]; fitsfile *fptr; status = 0; - if ( fits_open_file(&fptr, filename, READONLY, &status) ) - printerror( status ); - - if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) ) - printerror( status ); + if (fits_open_file(&fptr, filename, READONLY, &status)) + printerror(status); + if (fits_movabs_hdu(fptr, 2, &hdutype, &status)) + printerror(status); if (hdutype != BINARY_TBL) fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__); - if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) ) - printerror( status ); - - naxis = (long *)malloc(((size_t)naxes)*sizeof(long)); - if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) - || nfound != naxes ) - printerror( status ); + if (fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status)) + printerror(status); - if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) ) + naxis = (long *)malloc(((size_t)naxes) * sizeof(long)); + if (fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) || + nfound != naxes) printerror(status); - if( Lread != L ) - printf("Attention : read L = %li but you specified L = %i\n",Lread,L); + if (fits_read_key_lng(fptr, "L", &Lread, comment, &status)) + printerror(status); + if (Lread != L) + printf("Attention : read L = %li but you specified L = %i\n", Lread, L); long mwss_read; - if ( fits_read_key_lng(fptr, "MWSS", &mwss_read, comment, &status) ) + if (fits_read_key_lng(fptr, "MWSS", &mwss_read, comment, &status)) printerror(status); - if( mwss_read != 1 ) + if (mwss_read != 1) printf("Attention : the file is not stored with MWSS sampling.\n"); - npix = (L+1) * 2*L; + npix = (L + 1) * 2 * L; - if ( (npix%naxis[1]) != 0 ) + if ((npix % naxis[1]) != 0) fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__); - npercol = npix/naxis[1]; + npercol = npix / naxis[1]; nulval = -1.6375e30; for (irow = 0; irow < naxis[1]; irow++) { - if ( fits_read_col(fptr, TDOUBLE, 1, irow+1, 1, npercol, &nulval, - &(f[irow*npercol]), &anynul, &status) ) { + if (fits_read_col( + fptr, + TDOUBLE, + 1, + irow + 1, + 1, + npercol, + &nulval, + &(f[irow * npercol]), + &anynul, + &status)) { printerror(status); } } - if ( fits_close_file(fptr, &status) ) - printerror( status ); - + if (fits_close_file(fptr, &status)) + printerror(status); } - -void s2let_fits_mw_write_spin_maps(char* filename, double* fQ, double*fU, int L) -{ +void s2let_fits_mw_write_spin_maps(char *filename, double *fQ, double *fU, int L) { fitsfile *fptr; int status, hdutype; long firstrow, firstelem; - int bitpix = SHORT_IMG; - long naxis = 0; - long naxes[] = {0,0}; - int tfields = 2; + int bitpix = SHORT_IMG; + long naxis = 0; + long naxes[] = {0, 0}; + int tfields = 2; char extname[] = "BINTABLE"; - char *ttype[] = { "Q_POLARISATION", "U_POLARISATION" }; - char *tform[] = { "1D", "1D" }; - char *tunit[] = { " ", " " }; + char *ttype[] = {"Q_POLARISATION", "U_POLARISATION"}; + char *tform[] = {"1D", "1D"}; + char *tunit[] = {" ", " "}; - long npix = L * (2*L-1); + long npix = L * (2 * L - 1); status = 0; if (fits_create_file(&fptr, filename, &status)) - fprintf(stderr, "%s (%d): Could not create new fits file.\n", - __FILE__, __LINE__); + fprintf(stderr, "%s (%d): Could not create new fits file.\n", __FILE__, __LINE__); - if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) ) - fprintf(stderr, "%s (%d): Could not create new image file.\n", - __FILE__, __LINE__); + if (fits_create_img(fptr, bitpix, naxis, naxes, &status)) + fprintf(stderr, "%s (%d): Could not create new image file.\n", __FILE__, __LINE__); - if ( fits_movabs_hdu(fptr, 1, &hdutype, &status) ) - fprintf(stderr, "%s (%d): Could not move to first HDU.\n", - __FILE__, __LINE__); + if (fits_movabs_hdu(fptr, 1, &hdutype, &status)) + fprintf(stderr, "%s (%d): Could not move to first HDU.\n", __FILE__, __LINE__); - if ( fits_create_tbl( fptr, BINARY_TBL, npix, tfields, ttype, tform, - tunit, extname, &status) ) - fprintf(stderr, "%s (%d): Could not create new binary table.\n", - __FILE__, __LINE__); + if (fits_create_tbl( + fptr, BINARY_TBL, npix, tfields, ttype, tform, tunit, extname, &status)) + fprintf( + stderr, "%s (%d): Could not create new binary table.\n", __FILE__, __LINE__); - if (fits_write_key(fptr, TINT, "L", &L, - "Resolution parameter", &status)) - fprintf(stderr, "%s (%d): Could not write L keyword.\n", - __FILE__, __LINE__); + if (fits_write_key(fptr, TINT, "L", &L, "Resolution parameter", &status)) + fprintf(stderr, "%s (%d): Could not write L keyword.\n", __FILE__, __LINE__); - firstrow = 1; + firstrow = 1; firstelem = 1; if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, npix, fQ, &status)) @@ -367,58 +341,48 @@ void s2let_fits_mw_write_spin_maps(char* filename, double* fQ, double*fU, int L) if (fits_write_col(fptr, TDOUBLE, 2, firstrow, firstelem, npix, fU, &status)) fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__); - if ( fits_close_file(fptr, &status) ) /* close the FITS file */ - fprintf(stderr, "%s (%d): Could not close file.\n", - __FILE__, __LINE__); - + if (fits_close_file(fptr, &status)) /* close the FITS file */ + fprintf(stderr, "%s (%d): Could not close file.\n", __FILE__, __LINE__); } -void s2let_fits_mwss_write_spin_maps(char* filename, double* fQ, double*fU, int L) -{ +void s2let_fits_mwss_write_spin_maps(char *filename, double *fQ, double *fU, int L) { fitsfile *fptr; int status, hdutype; long firstrow, firstelem; - int bitpix = SHORT_IMG; - long naxis = 0; - long naxes[] = {0,0}; - int tfields = 2; + int bitpix = SHORT_IMG; + long naxis = 0; + long naxes[] = {0, 0}; + int tfields = 2; char extname[] = "BINTABLE"; - char *ttype[] = { "Q_POLARISATION", "U_POLARISATION" }; - char *tform[] = { "1D", "1D" }; - char *tunit[] = { " ", " " }; + char *ttype[] = {"Q_POLARISATION", "U_POLARISATION"}; + char *tform[] = {"1D", "1D"}; + char *tunit[] = {" ", " "}; - long npix = (L+1) * 2*L; + long npix = (L + 1) * 2 * L; status = 0; if (fits_create_file(&fptr, filename, &status)) - fprintf(stderr, "%s (%d): Could not create new fits file.\n", - __FILE__, __LINE__); + fprintf(stderr, "%s (%d): Could not create new fits file.\n", __FILE__, __LINE__); - if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) ) - fprintf(stderr, "%s (%d): Could not create new image file.\n", - __FILE__, __LINE__); + if (fits_create_img(fptr, bitpix, naxis, naxes, &status)) + fprintf(stderr, "%s (%d): Could not create new image file.\n", __FILE__, __LINE__); - if ( fits_movabs_hdu(fptr, 1, &hdutype, &status) ) - fprintf(stderr, "%s (%d): Could not move to first HDU.\n", - __FILE__, __LINE__); + if (fits_movabs_hdu(fptr, 1, &hdutype, &status)) + fprintf(stderr, "%s (%d): Could not move to first HDU.\n", __FILE__, __LINE__); - if ( fits_create_tbl( fptr, BINARY_TBL, npix, tfields, ttype, tform, - tunit, extname, &status) ) - fprintf(stderr, "%s (%d): Could not create new binary table.\n", - __FILE__, __LINE__); + if (fits_create_tbl( + fptr, BINARY_TBL, npix, tfields, ttype, tform, tunit, extname, &status)) + fprintf( + stderr, "%s (%d): Could not create new binary table.\n", __FILE__, __LINE__); - if (fits_write_key(fptr, TINT, "L", &L, - "Resolution parameter", &status)) - fprintf(stderr, "%s (%d): Could not write L keyword.\n", - __FILE__, __LINE__); + if (fits_write_key(fptr, TINT, "L", &L, "Resolution parameter", &status)) + fprintf(stderr, "%s (%d): Could not write L keyword.\n", __FILE__, __LINE__); int mwss = 1; - if (fits_write_key(fptr, TINT, "MWSS", &mwss, - "Sampling scheme parameter", &status)) - fprintf(stderr, "%s (%d): Could not write MWSS keyword.\n", - __FILE__, __LINE__); + if (fits_write_key(fptr, TINT, "MWSS", &mwss, "Sampling scheme parameter", &status)) + fprintf(stderr, "%s (%d): Could not write MWSS keyword.\n", __FILE__, __LINE__); - firstrow = 1; + firstrow = 1; firstelem = 1; if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, npix, fQ, &status)) @@ -427,133 +391,162 @@ void s2let_fits_mwss_write_spin_maps(char* filename, double* fQ, double*fU, int if (fits_write_col(fptr, TDOUBLE, 2, firstrow, firstelem, npix, fU, &status)) fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__); - if ( fits_close_file(fptr, &status) ) /* close the FITS file */ - fprintf(stderr, "%s (%d): Could not close file.\n", - __FILE__, __LINE__); - + if (fits_close_file(fptr, &status)) /* close the FITS file */ + fprintf(stderr, "%s (%d): Could not close file.\n", __FILE__, __LINE__); } - -void s2let_fits_mw_read_spin_maps(double* fQ, double* fU, char* filename, int L) -{ - long naxes, *naxis, npix, npercol, irow, Lread; - int status, hdutype, nfound, anynul; - float nulval; - char comment[FLEN_COMMENT]; +void s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *filename, int L) { + long naxes, *naxis, npix, npercol, irow, Lread; + int status, hdutype, nfound, anynul; + float nulval; + char comment[FLEN_COMMENT]; fitsfile *fptr; status = 0; - if ( fits_open_file(&fptr, filename, READONLY, &status) ) - printerror( status ); + if (fits_open_file(&fptr, filename, READONLY, &status)) + printerror(status); - if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) ) - printerror( status ); + if (fits_movabs_hdu(fptr, 2, &hdutype, &status)) + printerror(status); if (hdutype != BINARY_TBL) fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__); - if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) ) - printerror( status ); + if (fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status)) + printerror(status); - naxis = (long *)malloc(((size_t)naxes)*sizeof(long)); - if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) - || nfound != naxes ) - printerror( status ); + naxis = (long *)malloc(((size_t)naxes) * sizeof(long)); + if (fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) || + nfound != naxes) + printerror(status); - if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) ) + if (fits_read_key_lng(fptr, "L", &Lread, comment, &status)) printerror(status); - if( Lread != L ) - printf("Attention : read L = %li but you specified L = %i\n",Lread,L); + if (Lread != L) + printf("Attention : read L = %li but you specified L = %i\n", Lread, L); - npix = L * (2*L-1); - printf("naxis[0] = %li\n",naxis[0]); - printf("naxis[1] = %li\n",naxis[1]); + npix = L * (2 * L - 1); + printf("naxis[0] = %li\n", naxis[0]); + printf("naxis[1] = %li\n", naxis[1]); - if ( (npix%naxis[1]) != 0 ) + if ((npix % naxis[1]) != 0) fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__); - npercol = npix/naxis[1]; + npercol = npix / naxis[1]; nulval = -1.6375e30; for (irow = 0; irow < naxis[1]; irow++) { - if ( fits_read_col(fptr, TDOUBLE, 1, irow+1, 1, npercol, &nulval, - &(fQ[irow*npercol]), &anynul, &status) ) { + if (fits_read_col( + fptr, + TDOUBLE, + 1, + irow + 1, + 1, + npercol, + &nulval, + &(fQ[irow * npercol]), + &anynul, + &status)) { printerror(status); } } for (irow = 0; irow < naxis[1]; irow++) { - if ( fits_read_col(fptr, TDOUBLE, 2, irow+1, 1, npercol, &nulval, - &(fU[irow*npercol]), &anynul, &status) ) { + if (fits_read_col( + fptr, + TDOUBLE, + 2, + irow + 1, + 1, + npercol, + &nulval, + &(fU[irow * npercol]), + &anynul, + &status)) { printerror(status); } } - if ( fits_close_file(fptr, &status) ) - printerror( status ); - + if (fits_close_file(fptr, &status)) + printerror(status); } -void s2let_fits_mwss_read_spin_maps(double* fQ, double* fU, char* filename, int L) -{ - long naxes, *naxis, npix, npercol, irow, Lread; - int status, hdutype, nfound, anynul; - float nulval; - char comment[FLEN_COMMENT]; +void s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *filename, int L) { + long naxes, *naxis, npix, npercol, irow, Lread; + int status, hdutype, nfound, anynul; + float nulval; + char comment[FLEN_COMMENT]; fitsfile *fptr; status = 0; - if ( fits_open_file(&fptr, filename, READONLY, &status) ) - printerror( status ); + if (fits_open_file(&fptr, filename, READONLY, &status)) + printerror(status); - if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) ) - printerror( status ); + if (fits_movabs_hdu(fptr, 2, &hdutype, &status)) + printerror(status); if (hdutype != BINARY_TBL) fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__); - if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) ) - printerror( status ); + if (fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status)) + printerror(status); - naxis = (long *)malloc(((size_t)naxes)*sizeof(long)); - if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) - || nfound != naxes ) - printerror( status ); + naxis = (long *)malloc(((size_t)naxes) * sizeof(long)); + if (fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status) || + nfound != naxes) + printerror(status); - if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) ) + if (fits_read_key_lng(fptr, "L", &Lread, comment, &status)) printerror(status); - if( Lread != L ) - printf("Attention : read L = %li but you specified L = %i\n",Lread,L); + if (Lread != L) + printf("Attention : read L = %li but you specified L = %i\n", Lread, L); long mwss_read; - if ( fits_read_key_lng(fptr, "MWSS", &mwss_read, comment, &status) ) + if (fits_read_key_lng(fptr, "MWSS", &mwss_read, comment, &status)) printerror(status); - if( mwss_read != 1 ) + if (mwss_read != 1) printf("Attention : the file is not stored with MWSS sampling.\n"); - npix = (L+1) * 2*L; - printf("naxis[0] = %li\n",naxis[0]); - printf("naxis[1] = %li\n",naxis[1]); + npix = (L + 1) * 2 * L; + printf("naxis[0] = %li\n", naxis[0]); + printf("naxis[1] = %li\n", naxis[1]); - if ( (npix%naxis[1]) != 0 ) + if ((npix % naxis[1]) != 0) fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__); - npercol = npix/naxis[1]; + npercol = npix / naxis[1]; nulval = -1.6375e30; for (irow = 0; irow < naxis[1]; irow++) { - if ( fits_read_col(fptr, TDOUBLE, 1, irow+1, 1, npercol, &nulval, - &(fQ[irow*npercol]), &anynul, &status) ) { + if (fits_read_col( + fptr, + TDOUBLE, + 1, + irow + 1, + 1, + npercol, + &nulval, + &(fQ[irow * npercol]), + &anynul, + &status)) { printerror(status); } } for (irow = 0; irow < naxis[1]; irow++) { - if ( fits_read_col(fptr, TDOUBLE, 2, irow+1, 1, npercol, &nulval, - &(fU[irow*npercol]), &anynul, &status) ) { + if (fits_read_col( + fptr, + TDOUBLE, + 2, + irow + 1, + 1, + npercol, + &nulval, + &(fU[irow * npercol]), + &anynul, + &status)) { printerror(status); } } - if ( fits_close_file(fptr, &status) ) - printerror( status ); - + if (fits_close_file(fptr, &status)) + printerror(status); } /* diff --git a/src/main/c/s2let_helper.c b/src/main/c/s2let_helper.c index 9b188075..2bb7dcca 100644 --- a/src/main/c/s2let_helper.c +++ b/src/main/c/s2let_helper.c @@ -1,122 +1,107 @@ -#include "s2let.h" #include -int s2let_n_phi(const s2let_parameters_t *parameters) -{ - if (parameters->sampling_scheme == S2LET_SAMPLING_MW_SS) - return ssht_sampling_mw_ss_nphi(parameters->L); - else - return ssht_sampling_mw_nphi(parameters->L); +#include "s2let.h" + +int s2let_n_phi(const s2let_parameters_t *parameters) { + if (parameters->sampling_scheme == S2LET_SAMPLING_MW_SS) + return ssht_sampling_mw_ss_nphi(parameters->L); + else + return ssht_sampling_mw_nphi(parameters->L); } -int s2let_n_theta(const s2let_parameters_t *parameters) -{ - if (parameters->sampling_scheme == S2LET_SAMPLING_MW_SS) - return ssht_sampling_mw_ss_ntheta(parameters->L); - else - return ssht_sampling_mw_ntheta(parameters->L); +int s2let_n_theta(const s2let_parameters_t *parameters) { + if (parameters->sampling_scheme == S2LET_SAMPLING_MW_SS) + return ssht_sampling_mw_ss_ntheta(parameters->L); + else + return ssht_sampling_mw_ntheta(parameters->L); } -int s2let_n_px(const s2let_parameters_t *parameters) -{ - return s2let_n_phi(parameters) * s2let_n_theta(parameters); +int s2let_n_px(const s2let_parameters_t *parameters) { + return s2let_n_phi(parameters) * s2let_n_theta(parameters); } -int s2let_n_lm(const s2let_parameters_t *parameters) -{ - int L = parameters->L; - return L*L; +int s2let_n_lm(const s2let_parameters_t *parameters) { + int L = parameters->L; + return L * L; } -int s2let_n_lm_scal(const s2let_parameters_t *parameters) -{ - int L = parameters->L; - int J_min = parameters->J_min; - int bandlimit = (parameters->upsample) - ? L - : MIN(s2let_bandlimit(J_min-1, parameters), L); +int s2let_n_lm_scal(const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int bandlimit = + (parameters->upsample) ? L : MIN(s2let_bandlimit(J_min - 1, parameters), L); - return bandlimit * bandlimit; + return bandlimit * bandlimit; } -int s2let_n_lmn_wav(const s2let_parameters_t *parameters) -{ - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - int L = parameters->L; - int N = parameters->N; - int J_min = parameters->J_min; - int J = s2let_j_max(parameters); - int bandlimit = L; - int j, total = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - so3_parameters.N = MIN(N, bandlimit); - } - total += so3_sampling_flmn_size(&so3_parameters); +int s2let_n_lmn_wav(const s2let_parameters_t *parameters) { + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + int L = parameters->L; + int N = parameters->N; + int J_min = parameters->J_min; + int J = s2let_j_max(parameters); + int bandlimit = L; + int j, total = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + so3_parameters.N = MIN(N, bandlimit); } - return total; + total += so3_sampling_flmn_size(&so3_parameters); + } + return total; } -int s2let_n_gamma(const s2let_parameters_t *parameters) -{ - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); +int s2let_n_gamma(const s2let_parameters_t *parameters) { + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); - return so3_sampling_ngamma(&so3_parameters); + return so3_sampling_ngamma(&so3_parameters); } -int s2let_n_scal(const s2let_parameters_t *parameters) -{ - int J_min = parameters->J_min; - int L = parameters->L; - int bandlimit = (parameters->upsample) - ? parameters->L - : MIN(s2let_bandlimit(J_min-1, parameters), L); +int s2let_n_scal(const s2let_parameters_t *parameters) { + int J_min = parameters->J_min; + int L = parameters->L; + int bandlimit = (parameters->upsample) + ? parameters->L + : MIN(s2let_bandlimit(J_min - 1, parameters), L); - s2let_parameters_t bl_parameters = *parameters; - bl_parameters.L = bandlimit; + s2let_parameters_t bl_parameters = *parameters; + bl_parameters.L = bandlimit; - return s2let_n_phi(&bl_parameters) * s2let_n_theta(&bl_parameters); + return s2let_n_phi(&bl_parameters) * s2let_n_theta(&bl_parameters); } -int s2let_n_wav(const s2let_parameters_t *parameters) -{ - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - int L = parameters->L; - int J_min = parameters->J_min; - int J = s2let_j_max(parameters); - int bandlimit = L; - int j, total = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - } - total += so3_sampling_f_size(&so3_parameters); +int s2let_n_wav(const s2let_parameters_t *parameters) { + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + int L = parameters->L; + int J_min = parameters->J_min; + int J = s2let_j_max(parameters); + int bandlimit = L; + int j, total = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; } - return total; + total += so3_sampling_f_size(&so3_parameters); + } + return total; } -int s2let_n_wav_j(int j, const s2let_parameters_t *parameters) -{ - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); +int s2let_n_wav_j(int j, const s2let_parameters_t *parameters) { + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); - if (!parameters->upsample) - { - int L = parameters->L; - so3_parameters.L = MIN(s2let_bandlimit(j, parameters), L); - } + if (!parameters->upsample) { + int L = parameters->L; + so3_parameters.L = MIN(s2let_bandlimit(j, parameters), L); + } - return so3_sampling_f_size(&so3_parameters); + return so3_sampling_f_size(&so3_parameters); } diff --git a/src/main/c/s2let_hpx.c b/src/main/c/s2let_hpx.c index 681201b2..57ab98b9 100644 --- a/src/main/c/s2let_hpx.c +++ b/src/main/c/s2let_hpx.c @@ -2,10 +2,11 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" +#include #include #include -#include + +#include "s2let.h" // Fortran interfaces to Healpix F90 library ; see s2let_hpx.f90 extern void healpix_inverse_real_(); @@ -17,42 +18,48 @@ extern void read_healpix_map_(); extern void read_healpix_maps_(); extern void healpix_forward_real_(); -void s2let_hpx_alm2map_real(double* f, const complex double* flm, int nside, int L) -{ +void s2let_hpx_alm2map_real(double *f, const complex double *flm, int nside, int L) { healpix_inverse_real_(f, flm, &nside, &L); } -void s2let_hpx_map2alm_real(complex double* flm, const double* f, int nside, int L) -{ +void s2let_hpx_map2alm_real(complex double *flm, const double *f, int nside, int L) { healpix_forward_real_(flm, f, &nside, &L); } -void s2let_hpx_alm2map_spin_real(double* fQ, double* fU, const complex double* flmE, const complex double* flmB, int nside, int L, int spin) -{ +void s2let_hpx_alm2map_spin_real( + double *fQ, + double *fU, + const complex double *flmE, + const complex double *flmB, + int nside, + int L, + int spin) { healpix_inverse_spin_real_(fQ, fU, flmE, flmB, &nside, &L, &spin); } -void s2let_hpx_map2alm_spin_real(complex double* flmE, complex double* flmB, const double* fQ, const double* fU, int nside, int L, int spin) -{ +void s2let_hpx_map2alm_spin_real( + complex double *flmE, + complex double *flmB, + const double *fQ, + const double *fU, + int nside, + int L, + int spin) { healpix_forward_spin_real_(flmE, flmB, fQ, fU, &nside, &L, &spin); } -void s2let_hpx_read_maps(double* f, char* file, int nside, int nmaps) -{ +void s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps) { read_healpix_maps_(f, file, &nside, &nmaps); } -void s2let_hpx_read_map(double* f, char* file, int nside) -{ +void s2let_hpx_read_map(double *f, char *file, int nside) { read_healpix_map_(f, file, &nside); } -void s2let_hpx_write_map(char* file, const double* f, int nside) -{ +void s2let_hpx_write_map(char *file, const double *f, int nside) { write_healpix_map_(file, f, &nside); } -void s2let_hpx_allocate_real(double **f, int nside) -{ - *f = calloc(12*nside*nside, sizeof **f); +void s2let_hpx_allocate_real(double **f, int nside) { + *f = calloc(12 * nside * nside, sizeof **f); } diff --git a/src/main/c/s2let_hpx_demo.c b/src/main/c/s2let_hpx_demo.c index 91ec3112..80ff1a16 100644 --- a/src/main/c/s2let_hpx_demo.c +++ b/src/main/c/s2let_hpx_demo.c @@ -2,30 +2,30 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" -#include #include #include +#include +#include #include #include #include -#include #include +#include "s2let.h" + /*! * PROGRAM : s2let_hpx_demo * COMMAND : bin/s2let_hpx_demo * ARGUMENTS : none */ -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { printf("--------------------------------------------------\n"); printf(" S2LET : Healpix wavelet transform \n"); printf("--------------------------------------------------\n"); - const int L = 256; // Harmonic band-limit - const double B = 4; // Wavelet parameters - const int J_min = 2; // First wavelet scale to use + const int L = 256; // Harmonic band-limit + const double B = 4; // Wavelet parameters + const int J_min = 2; // First wavelet scale to use s2let_parameters_t parameters = {}; parameters.B = B; parameters.L = L; @@ -36,7 +36,7 @@ int main(int argc, char *argv[]) const int nside = s2let_fits_hpx_read_nside(file); // Read Healpix map from file - double *f = (double*)calloc(12*nside*nside, sizeof(double)); + double *f = (double *)calloc(12 * nside * nside, sizeof(double)); s2let_hpx_read_map(f, file, nside); // Allocate space for wavelet maps (corresponding to the triplet B/L/J_min) @@ -47,26 +47,36 @@ int main(int argc, char *argv[]) clock_t time_start = clock(); s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, nside, ¶meters); clock_t time_end = clock(); - printf(" - Wavelet analysis : %4.4f seconds\n", - (time_end - time_start) / (double)CLOCKS_PER_SEC); + printf( + " - Wavelet analysis : %4.4f seconds\n", + (time_end - time_start) / (double)CLOCKS_PER_SEC); // Output the wavelets to FITS files char outfile[100]; char params[100]; sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min); int j, J = s2let_j_max(¶meters); // Explicitly compute the maximum wavelet scale - int offset = 0; // Start with the first wavelet - for(j = J_min; j <= J; j++){ - sprintf(outfile, "%s%s%s%s%d%s", "data/somecmbsimu_hpx_128", "_wav_", params, "_", j, ".fits"); - printf(" Outfile_wav[j=%i] = %s\n",j,outfile); + int offset = 0; // Start with the first wavelet + for (j = J_min; j <= J; j++) { + sprintf( + outfile, + "%s%s%s%s%d%s", + "data/somecmbsimu_hpx_128", + "_wav_", + params, + "_", + j, + ".fits"); + printf(" Outfile_wav[j=%i] = %s\n", j, outfile); remove(outfile); // In case the file exists - s2let_hpx_write_map(outfile, f_wav + offset, nside); // Now write the map to fits file - offset += 12 * nside * nside; // Go to the next wavelet + s2let_hpx_write_map( + outfile, f_wav + offset, nside); // Now write the map to fits file + offset += 12 * nside * nside; // Go to the next wavelet } // Finally write the scaling function sprintf(outfile, "%s%s%s%s", "data/somecmbsimu_hpx_128", "_scal_", params, ".fits"); - printf(" Outfile_scal = %s\n",outfile); - remove(outfile); // In case the file exists + printf(" Outfile_scal = %s\n", outfile); + remove(outfile); // In case the file exists s2let_hpx_write_map(outfile, f_scal, nside); // Now write the map to fits file free(f_wav); @@ -77,5 +87,3 @@ int main(int argc, char *argv[]) return 0; } - - diff --git a/src/main/c/s2let_idl_hpx.c b/src/main/c/s2let_idl_hpx.c index 9e6fc6b0..df4e8db4 100644 --- a/src/main/c/s2let_idl_hpx.c +++ b/src/main/c/s2let_idl_hpx.c @@ -1,5 +1,5 @@ // S2LET package -// Copyright (C) 2012 +// Copyright (C) 2012 // Boris Leistedt & Jason McEwen #include "s2let.h" @@ -8,15 +8,16 @@ * IDL integer types. For historical reasons, we use UCHAR for TYP_BYTE * instead of defining an IDL_BYTE type. */ -#if defined(ALPHA_OSF) || defined(SUN_64) || defined(LINUX_X86_64) || defined(HPUX_64) || defined(IRIX_64) || defined(AIX_64) +#if defined(ALPHA_OSF) || defined(SUN_64) || defined(LINUX_X86_64) || \ + defined(HPUX_64) || defined(IRIX_64) || defined(AIX_64) #define IDL_SIZEOF_C_LONG 8 #else #define IDL_SIZEOF_C_LONG 4 #endif #if (IDL_SIZEOF_C_LONG == 8) || defined(MSWIN_64) -#define IDL_SIZEOF_C_PTR 8 +#define IDL_SIZEOF_C_PTR 8 #else -#define IDL_SIZEOF_C_PTR 4 +#define IDL_SIZEOF_C_PTR 4 #endif typedef short IDL_INT; typedef unsigned short IDL_UINT; @@ -30,19 +31,18 @@ typedef unsigned long IDL_ULONG; #error "IDL_LONG not defined --- unexpected value of IDL_SIZEOF_C_LONG" #endif -int s2let_idl_axisym_hpx_wav_analysis_real(int argc, void* argv[]) -{ - if(argc != 8) return 0; - double *f_wav = (double *) argv[0]; - double *f_scal = (double *) argv[1]; - double *f = (double *) argv[2]; - IDL_INT *nside = (IDL_INT *) argv[3]; - IDL_INT *B = (IDL_INT *) argv[4]; - IDL_INT *L = (IDL_INT *) argv[5]; - IDL_INT *J_min = (IDL_INT *) argv[6]; - - - IDL_INT *wavtype = (IDL_INT *) argv[7]; +int s2let_idl_axisym_hpx_wav_analysis_real(int argc, void *argv[]) { + if (argc != 8) + return 0; + double *f_wav = (double *)argv[0]; + double *f_scal = (double *)argv[1]; + double *f = (double *)argv[2]; + IDL_INT *nside = (IDL_INT *)argv[3]; + IDL_INT *B = (IDL_INT *)argv[4]; + IDL_INT *L = (IDL_INT *)argv[5]; + IDL_INT *J_min = (IDL_INT *)argv[6]; + + IDL_INT *wavtype = (IDL_INT *)argv[7]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -50,23 +50,24 @@ int s2let_idl_axisym_hpx_wav_analysis_real(int argc, void* argv[]) parameters.L = *L; parameters.J_min = *J_min; s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, *nside, ¶meters); - //s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, *nside, *B, *L, *J_min); - - return 1; -} - -int s2let_idl_axisym_hpx_wav_synthesis_real(int argc, void* argv[]) -{ - if(argc != 8) return 0; - double *f = (double *) argv[0]; - double *f_wav = (double *) argv[1]; - double *f_scal = (double *) argv[2]; - IDL_INT *nside = (IDL_INT *) argv[3]; - IDL_INT *B = (IDL_INT *) argv[4]; - IDL_INT *L = (IDL_INT *) argv[5]; - IDL_INT *J_min = (IDL_INT *) argv[6]; - - IDL_INT *wavtype = (IDL_INT *) argv[7]; + // s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, *nside, *B, *L, + // *J_min); + + return 1; +} + +int s2let_idl_axisym_hpx_wav_synthesis_real(int argc, void *argv[]) { + if (argc != 8) + return 0; + double *f = (double *)argv[0]; + double *f_wav = (double *)argv[1]; + double *f_scal = (double *)argv[2]; + IDL_INT *nside = (IDL_INT *)argv[3]; + IDL_INT *B = (IDL_INT *)argv[4]; + IDL_INT *L = (IDL_INT *)argv[5]; + IDL_INT *J_min = (IDL_INT *)argv[6]; + + IDL_INT *wavtype = (IDL_INT *)argv[7]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -74,34 +75,34 @@ int s2let_idl_axisym_hpx_wav_synthesis_real(int argc, void* argv[]) parameters.L = *L; parameters.J_min = *J_min; s2let_transform_axisym_wav_synthesis_hpx_real(f, f_wav, f_scal, *nside, ¶meters); - //s2let_transform_axisym_wav_synthesis_hpx_real(f, f_wav, f_scal, *nside, *B, *L, *J_min); - - return 1; -} + // s2let_transform_axisym_wav_synthesis_hpx_real(f, f_wav, f_scal, *nside, *B, *L, + // *J_min); + return 1; +} -int s2let_idl_hpx_map2alm_real(int argc, void* argv[]) -{ - if(argc != 4) return 0; - complex double *flm = (complex double *) argv[0]; - double *f = (double *) argv[1]; - IDL_INT *nside = (IDL_INT *) argv[2]; - IDL_INT *L = (IDL_INT *) argv[3]; +int s2let_idl_hpx_map2alm_real(int argc, void *argv[]) { + if (argc != 4) + return 0; + complex double *flm = (complex double *)argv[0]; + double *f = (double *)argv[1]; + IDL_INT *nside = (IDL_INT *)argv[2]; + IDL_INT *L = (IDL_INT *)argv[3]; s2let_hpx_map2alm_real(flm, f, *nside, *L); - return 1; -} + return 1; +} -int s2let_idl_hpx_alm2map_real(int argc, void* argv[]) -{ - if(argc != 4) return 0; - double *f = (double *) argv[0]; - complex double *flm = (complex double *) argv[1]; - IDL_INT *nside = (IDL_INT *) argv[2]; - IDL_INT *L = (IDL_INT *) argv[3]; +int s2let_idl_hpx_alm2map_real(int argc, void *argv[]) { + if (argc != 4) + return 0; + double *f = (double *)argv[0]; + complex double *flm = (complex double *)argv[1]; + IDL_INT *nside = (IDL_INT *)argv[2]; + IDL_INT *L = (IDL_INT *)argv[3]; s2let_hpx_alm2map_real(f, flm, *nside, *L); - return 1; -} + return 1; +} diff --git a/src/main/c/s2let_idl_mw.c b/src/main/c/s2let_idl_mw.c index 8c3c7c6f..55f25b1b 100644 --- a/src/main/c/s2let_idl_mw.c +++ b/src/main/c/s2let_idl_mw.c @@ -8,15 +8,16 @@ * IDL integer types. For historical reasons, we use UCHAR for TYP_BYTE * instead of defining an IDL_BYTE type. */ -#if defined(ALPHA_OSF) || defined(SUN_64) || defined(LINUX_X86_64) || defined(HPUX_64) || defined(IRIX_64) || defined(AIX_64) +#if defined(ALPHA_OSF) || defined(SUN_64) || defined(LINUX_X86_64) || \ + defined(HPUX_64) || defined(IRIX_64) || defined(AIX_64) #define IDL_SIZEOF_C_LONG 8 #else #define IDL_SIZEOF_C_LONG 4 #endif #if (IDL_SIZEOF_C_LONG == 8) || defined(MSWIN_64) -#define IDL_SIZEOF_C_PTR 8 +#define IDL_SIZEOF_C_PTR 8 #else -#define IDL_SIZEOF_C_PTR 4 +#define IDL_SIZEOF_C_PTR 4 #endif typedef short IDL_INT; typedef unsigned short IDL_UINT; @@ -30,18 +31,17 @@ typedef unsigned long IDL_ULONG; #error "IDL_LONG not defined --- unexpected value of IDL_SIZEOF_C_LONG" #endif - -int s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void* argv[]) -{ - if(argc != 7) return 0; - double *f_wav = (double *) argv[0]; - double *f_scal = (double *) argv[1]; - double *f = (double *) argv[2]; - IDL_INT *B = (IDL_INT *) argv[3]; - IDL_INT *L = (IDL_INT *) argv[4]; - IDL_INT *J_min = (IDL_INT *) argv[5]; - - IDL_INT *wavtype = (IDL_INT *) argv[6]; +int s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[]) { + if (argc != 7) + return 0; + double *f_wav = (double *)argv[0]; + double *f_scal = (double *)argv[1]; + double *f = (double *)argv[2]; + IDL_INT *B = (IDL_INT *)argv[3]; + IDL_INT *L = (IDL_INT *)argv[4]; + IDL_INT *J_min = (IDL_INT *)argv[5]; + + IDL_INT *wavtype = (IDL_INT *)argv[6]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -54,17 +54,17 @@ int s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void* argv[]) return 1; } -int s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void* argv[]) -{ - if(argc != 7) return 0; - double *f = (double *) argv[0]; - double *f_wav = (double *) argv[1]; - double *f_scal = (double *) argv[2]; - IDL_INT *B = (IDL_INT *) argv[3]; - IDL_INT *L = (IDL_INT *) argv[4]; - IDL_INT *J_min = (IDL_INT *) argv[5]; - - IDL_INT *wavtype = (IDL_INT *) argv[6]; +int s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[]) { + if (argc != 7) + return 0; + double *f = (double *)argv[0]; + double *f_wav = (double *)argv[1]; + double *f_scal = (double *)argv[2]; + IDL_INT *B = (IDL_INT *)argv[3]; + IDL_INT *L = (IDL_INT *)argv[4]; + IDL_INT *J_min = (IDL_INT *)argv[5]; + + IDL_INT *wavtype = (IDL_INT *)argv[6]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -77,18 +77,17 @@ int s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void* argv[]) return 1; } - -int s2let_idl_transform_axisym_wav_analysis_mw(int argc, void* argv[]) -{ - if(argc != 7) return 0; - complex double *f_wav = (complex double *) argv[0]; - complex double *f_scal = (complex double *) argv[1]; - complex double *f = (complex double *) argv[2]; - IDL_INT *B = (IDL_INT *) argv[3]; - IDL_INT *L = (IDL_INT *) argv[4]; - IDL_INT *J_min = (IDL_INT *) argv[5]; - - IDL_INT *wavtype = (IDL_INT *) argv[6]; +int s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[]) { + if (argc != 7) + return 0; + complex double *f_wav = (complex double *)argv[0]; + complex double *f_scal = (complex double *)argv[1]; + complex double *f = (complex double *)argv[2]; + IDL_INT *B = (IDL_INT *)argv[3]; + IDL_INT *L = (IDL_INT *)argv[4]; + IDL_INT *J_min = (IDL_INT *)argv[5]; + + IDL_INT *wavtype = (IDL_INT *)argv[6]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -101,17 +100,17 @@ int s2let_idl_transform_axisym_wav_analysis_mw(int argc, void* argv[]) return 1; } -int s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void* argv[]) -{ - if(argc != 7) return 0; - complex double *f = (complex double *) argv[0]; - complex double *f_wav = (complex double *) argv[1]; - complex double *f_scal = (complex double *) argv[2]; - IDL_INT *B = (IDL_INT *) argv[3]; - IDL_INT *L = (IDL_INT *) argv[4]; - IDL_INT *J_min = (IDL_INT *) argv[5]; - - IDL_INT *wavtype = (IDL_INT *) argv[6]; +int s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[]) { + if (argc != 7) + return 0; + complex double *f = (complex double *)argv[0]; + complex double *f_wav = (complex double *)argv[1]; + complex double *f_scal = (complex double *)argv[2]; + IDL_INT *B = (IDL_INT *)argv[3]; + IDL_INT *L = (IDL_INT *)argv[4]; + IDL_INT *J_min = (IDL_INT *)argv[5]; + + IDL_INT *wavtype = (IDL_INT *)argv[6]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -124,18 +123,17 @@ int s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void* argv[]) return 1; } - -int s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void* argv[]) -{ - if(argc != 7) return 0; - complex double *f_wav = (complex double *) argv[0]; - complex double *f_scal = (complex double *) argv[1]; - complex double *f = (complex double *) argv[2]; - IDL_INT *B = (IDL_INT *) argv[3]; - IDL_INT *L = (IDL_INT *) argv[4]; - IDL_INT *J_min = (IDL_INT *) argv[5]; - - IDL_INT *wavtype = (IDL_INT *) argv[6]; +int s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[]) { + if (argc != 7) + return 0; + complex double *f_wav = (complex double *)argv[0]; + complex double *f_scal = (complex double *)argv[1]; + complex double *f = (complex double *)argv[2]; + IDL_INT *B = (IDL_INT *)argv[3]; + IDL_INT *L = (IDL_INT *)argv[4]; + IDL_INT *J_min = (IDL_INT *)argv[5]; + + IDL_INT *wavtype = (IDL_INT *)argv[6]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -148,17 +146,17 @@ int s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void* argv[]) return 1; } -int s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void* argv[]) -{ - if(argc != 7) return 0; - complex double *f = (complex double *) argv[0]; - complex double *f_wav = (complex double *) argv[1]; - complex double *f_scal = (complex double *) argv[2]; - IDL_INT *B = (IDL_INT *) argv[3]; - IDL_INT *L = (IDL_INT *) argv[4]; - IDL_INT *J_min = (IDL_INT *) argv[5]; - - IDL_INT *wavtype = (IDL_INT *) argv[6]; +int s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[]) { + if (argc != 7) + return 0; + complex double *f = (complex double *)argv[0]; + complex double *f_wav = (complex double *)argv[1]; + complex double *f_scal = (complex double *)argv[2]; + IDL_INT *B = (IDL_INT *)argv[3]; + IDL_INT *L = (IDL_INT *)argv[4]; + IDL_INT *J_min = (IDL_INT *)argv[5]; + + IDL_INT *wavtype = (IDL_INT *)argv[6]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -171,17 +169,17 @@ int s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void* argv[]) return 1; } -int s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void* argv[]) -{ - if(argc != 7) return 0; - double *f_wav = (double *) argv[0]; - double *f_scal = (double *) argv[1]; - double *f = (double *) argv[2]; - IDL_INT *B = (IDL_INT *) argv[3]; - IDL_INT *L = (IDL_INT *) argv[4]; - IDL_INT *J_min = (IDL_INT *) argv[5]; - - IDL_INT *wavtype = (IDL_INT *) argv[6]; +int s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[]) { + if (argc != 7) + return 0; + double *f_wav = (double *)argv[0]; + double *f_scal = (double *)argv[1]; + double *f = (double *)argv[2]; + IDL_INT *B = (IDL_INT *)argv[3]; + IDL_INT *L = (IDL_INT *)argv[4]; + IDL_INT *J_min = (IDL_INT *)argv[5]; + + IDL_INT *wavtype = (IDL_INT *)argv[6]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -194,17 +192,17 @@ int s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void* arg return 1; } -int s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void* argv[]) -{ - if(argc != 7) return 0; - double *f = (double *) argv[0]; - double *f_wav = (double *) argv[1]; - double *f_scal = (double *) argv[2]; - IDL_INT *B = (IDL_INT *) argv[3]; - IDL_INT *L = (IDL_INT *) argv[4]; - IDL_INT *J_min = (IDL_INT *) argv[5]; - - IDL_INT *wavtype = (IDL_INT *) argv[6]; +int s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[]) { + if (argc != 7) + return 0; + double *f = (double *)argv[0]; + double *f_wav = (double *)argv[1]; + double *f_scal = (double *)argv[2]; + IDL_INT *B = (IDL_INT *)argv[3]; + IDL_INT *L = (IDL_INT *)argv[4]; + IDL_INT *J_min = (IDL_INT *)argv[5]; + + IDL_INT *wavtype = (IDL_INT *)argv[6]; s2let_switch_wavtype(*wavtype); s2let_parameters_t parameters = {}; @@ -217,50 +215,48 @@ int s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void* ar return 1; } - -int s2let_idl_mw_map2alm(int argc, void* argv[]) -{ - if(argc != 3) return 0; - complex double *flm = (complex double *) argv[0]; - complex double *f = (complex double *) argv[1]; - IDL_INT *L = (IDL_INT *) argv[2]; +int s2let_idl_mw_map2alm(int argc, void *argv[]) { + if (argc != 3) + return 0; + complex double *flm = (complex double *)argv[0]; + complex double *f = (complex double *)argv[1]; + IDL_INT *L = (IDL_INT *)argv[2]; s2let_mw_map2alm(flm, f, *L, 0); return 1; } -int s2let_idl_mw_alm2map(int argc, void* argv[]) -{ - if(argc != 3) return 0; - complex double *f = (complex double *) argv[0]; - complex double *flm = (complex double *) argv[1]; - IDL_INT *L = (IDL_INT *) argv[2]; +int s2let_idl_mw_alm2map(int argc, void *argv[]) { + if (argc != 3) + return 0; + complex double *f = (complex double *)argv[0]; + complex double *flm = (complex double *)argv[1]; + IDL_INT *L = (IDL_INT *)argv[2]; s2let_mw_alm2map(f, flm, *L, 0); return 1; } - -int s2let_idl_mw_map2alm_real(int argc, void* argv[]) -{ - if(argc != 3) return 0; - complex double *flm = (complex double *) argv[0]; - double *f = (double *) argv[1]; - IDL_INT *L = (IDL_INT *) argv[2]; +int s2let_idl_mw_map2alm_real(int argc, void *argv[]) { + if (argc != 3) + return 0; + complex double *flm = (complex double *)argv[0]; + double *f = (double *)argv[1]; + IDL_INT *L = (IDL_INT *)argv[2]; s2let_mw_map2alm_real(flm, f, *L); return 1; } -int s2let_idl_mw_alm2map_real(int argc, void* argv[]) -{ - if(argc != 3) return 0; - double *f = (double *) argv[0]; - complex double *flm = (complex double *) argv[1]; - IDL_INT *L = (IDL_INT *) argv[2]; +int s2let_idl_mw_alm2map_real(int argc, void *argv[]) { + if (argc != 3) + return 0; + double *f = (double *)argv[0]; + complex double *flm = (complex double *)argv[1]; + IDL_INT *L = (IDL_INT *)argv[2]; s2let_mw_alm2map_real(f, flm, *L); diff --git a/src/main/c/s2let_lm.c b/src/main/c/s2let_lm.c index 0261a68c..b89bb5fb 100644 --- a/src/main/c/s2let_lm.c +++ b/src/main/c/s2let_lm.c @@ -2,24 +2,25 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include -#include +#include #include +#include #include -#include #include +#include "s2let.h" + /*! * Compute power for a signal in harmonic space. */ -double s2let_lm_power(complex double *flm, int L){ - int i; - double totalpower = 0.0; - for(i = 0; i < L*L; ++i) - totalpower += pow(cabs(flm[i]), 2.0); - totalpower = totalpower / (L * L); - return totalpower; +double s2let_lm_power(complex double *flm, int L) { + int i; + double totalpower = 0.0; + for (i = 0; i < L * L; ++i) + totalpower += pow(cabs(flm[i]), 2.0); + totalpower = totalpower / (L * L); + return totalpower; } /*! @@ -31,14 +32,13 @@ double s2let_lm_power(complex double *flm, int L){ * \param[in] seed Random seed. * \retval none */ -void s2let_lm_random_flm(complex double *flm, int L, int spin, int seed) -{ - int i, i_min; - srand( time(NULL) ); - // el < |s| are zero, so start with el = |s|, m = -el. - i_min = spin*spin; - for (i=i_min; i -#include #include +#include +#include #include +#include "s2let.h" + /*! * Tiling function for S2DW wavelets */ -double f_s2dw(double k, double B) -{ - double t = (k - (1 / B)) * (2.0 * B / (B-1)) - 1; +double f_s2dw(double k, double B) { + double t = (k - (1 / B)) * (2.0 * B / (B - 1)) - 1; return exp(-2.0 / (1.0 - pow(t, 2.0))) / k; } /*! * Tiling function for needlets */ -double f_needlet(double t) -{ - return exp(-1.0 / (1.0 - pow(t, 2.0))) ; -} - +double f_needlet(double t) { return exp(-1.0 / (1.0 - pow(t, 2.0))); } /*! * Computes cubis B-spline function */ -double b3_spline (double x) -{ - if ( ABS(x) < 1e-16 ) return 0; - double A1,A2,A3,A4,A5,Val; - A1 = ABS ((x - 2) * (x - 2) * (x - 2)); - A2 = ABS ((x - 1) * (x - 1) * (x - 1)); - A3 = ABS (x * x * x); - A4 = ABS ((x + 1) * (x + 1) * (x + 1)); - A5 = ABS ((x + 2) * (x + 2) * (x + 2)); - Val = 1./12. * (A1 - 4. * A2 + 6. * A3 - 4. * A4 + A5); - fflush(NULL); - return Val; +double b3_spline(double x) { + if (ABS(x) < 1e-16) + return 0; + double A1, A2, A3, A4, A5, Val; + A1 = ABS((x - 2) * (x - 2) * (x - 2)); + A2 = ABS((x - 1) * (x - 1) * (x - 1)); + A3 = ABS(x * x * x); + A4 = ABS((x + 1) * (x + 1) * (x + 1)); + A5 = ABS((x + 2) * (x + 2) * (x + 2)); + Val = 1. / 12. * (A1 - 4. * A2 + 6. * A3 - 4. * A4 + A5); + fflush(NULL); + return Val; } /*! * Computes spline scaling function */ -double s2let_math_spline_scalingfct(double x, double y){ +double s2let_math_spline_scalingfct(double x, double y) { double res = 1.5 * b3_spline(2.0 * x / y); return res; } @@ -54,21 +50,20 @@ double s2let_math_spline_scalingfct(double x, double y){ /*! * Computes smooth "Schwartz" functions for scale-discretised wavelets */ -double s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B) -{ +double s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B) { double sum = 0; double f1, f2; int i; double h = (b - a) / n; - if( a == b ){ + if (a == b) { return 0; - }else{ - for (i = 0; i < n; i++){ + } else { + for (i = 0; i < n; i++) { f1 = f_s2dw(a + i * h, B); f2 = f_s2dw(a + (i + 1) * h, B); - if(!isnan(f1) && !isinf(f1) && !isnan(f2) && !isinf(f2)) - sum += ((f1 + f2) * h) / 2; + if (!isnan(f1) && !isinf(f1) && !isnan(f2) && !isinf(f2)) + sum += ((f1 + f2) * h) / 2; } } return sum; @@ -77,75 +72,78 @@ double s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B) /*! * Computes smooth "Schwartz" functions for needlets */ -double s2let_math_kappa0_quadtrap_needlet(double a, double b, int n) -{ +double s2let_math_kappa0_quadtrap_needlet(double a, double b, int n) { double sum = 0; double f1, f2; int i; double h = (b - a) / n; - if( a == b ){ + if (a == b) { return 0; - }else{ - for (i = 0; i < n; i++){ + } else { + for (i = 0; i < n; i++) { f1 = f_needlet(a + i * h); f2 = f_needlet(a + (i + 1) * h); - if(!isnan(f1) && !isinf(f1) && !isnan(f2) && !isinf(f2)) - sum += ((f1 + f2) * h) / 2; + if (!isnan(f1) && !isinf(f1) && !isnan(f2) && !isinf(f2)) + sum += ((f1 + f2) * h) / 2; } } return sum; } - /*! * Random number from seed (Numerical Recipes). */ double ran2_dp(int idum) { - int IM1=2147483563,IM2=2147483399,IMM1=IM1-1, - IA1=40014,IA2=40692,IQ1=53668,IQ2=52774,IR1=12211,IR2=3791, - NTAB=32,NDIV=1+IMM1/NTAB; + int IM1 = 2147483563, IM2 = 2147483399, IMM1 = IM1 - 1, IA1 = 40014, IA2 = 40692, + IQ1 = 53668, IQ2 = 52774, IR1 = 12211, IR2 = 3791, NTAB = 32, + NDIV = 1 + IMM1 / NTAB; - double AM=1./IM1,EPS=1.2e-7,RNMX=1.-EPS; - int j,k; - static int iv[32],iy,idum2 = 123456789; + double AM = 1. / IM1, EPS = 1.2e-7, RNMX = 1. - EPS; + int j, k; + static int iv[32], iy, idum2 = 123456789; // N.B. in C static variables are initialised to 0 by default. if (idum <= 0) { - idum= (-idum>1 ? -idum : 1); // max(-idum,1); - idum2=idum; - for(j=NTAB+8;j>=1;j--) { - k=idum/IQ1; - idum=IA1*(idum-k*IQ1)-k*IR1; - if (idum < 0) idum=idum+IM1; - if (j < NTAB) iv[j-1]=idum; + idum = (-idum > 1 ? -idum : 1); // max(-idum,1); + idum2 = idum; + for (j = NTAB + 8; j >= 1; j--) { + k = idum / IQ1; + idum = IA1 * (idum - k * IQ1) - k * IR1; + if (idum < 0) + idum = idum + IM1; + if (j < NTAB) + iv[j - 1] = idum; } - iy=iv[0]; + iy = iv[0]; } - k=idum/IQ1; - idum=IA1*(idum-k*IQ1)-k*IR1; - if (idum < 0) idum=idum+IM1; - k=idum2/IQ2; - idum2=IA2*(idum2-k*IQ2)-k*IR2; - if (idum2 < 0) idum2=idum2+IM2; - j=1+iy/NDIV; - iy=iv[j-1]-idum2; - iv[j-1]=idum; - if(iy < 1)iy=iy+IMM1; - return (AM*iy < RNMX ? AM*iy : RNMX); // min(AM*iy,RNMX); + k = idum / IQ1; + idum = IA1 * (idum - k * IQ1) - k * IR1; + if (idum < 0) + idum = idum + IM1; + k = idum2 / IQ2; + idum2 = IA2 * (idum2 - k * IQ2) - k * IR2; + if (idum2 < 0) + idum2 = idum2 + IM2; + j = 1 + iy / NDIV; + iy = iv[j - 1] - idum2; + iv[j - 1] = idum; + if (iy < 1) + iy = iy + IMM1; + return (AM * iy < RNMX ? AM * iy : RNMX); // min(AM*iy,RNMX); } /*! * Max absolute error between two complex arrays */ -double maxerr_cplx(complex double *a, complex double *b, int size) -{ +double maxerr_cplx(complex double *a, complex double *b, int size) { double value = 0; int i; - for(i = 0; i 0.001 ) - // printf("%f+i%f %f+i%f %f\n",creal(a[i]), cimag(a[i]), creal(b[i]), cimag(b[i]), cabs( a[i]-b[i] )); - value = MAX( cabs( a[i]-b[i] ), value ); + for (i = 0; i < size; i++) { + // if( cabs( a[i]-b[i] ) > 0.001 ) + // printf("%f+i%f %f+i%f %f\n",creal(a[i]), cimag(a[i]), creal(b[i]), cimag(b[i]), + // cabs( a[i]-b[i] )); + value = MAX(cabs(a[i] - b[i]), value); } return value; } @@ -153,88 +151,83 @@ double maxerr_cplx(complex double *a, complex double *b, int size) /*! * Max absolute error between two real arrays */ -double maxerr(double *a, double *b, int size) -{ +double maxerr(double *a, double *b, int size) { double value = 0; int i; - for(i = 0; i n/2) - k = n - k; - - for (i = 1; i <= k; ++i) - { - // By interleaving the division and multiplication, we - // avoid intermediate results getting bigger than necessary. - - // We can do this without risking problems due to integer - // division: before dividing by i we will have multiplied - // by i consecutive integers, one of which has to be - // divisible by i. - result *= n - i + 1UL; - result /= i; - } +unsigned long binomial_coefficient(int n, int k, int exact) { + if (!exact) + return floor(0.5 + exp(logfact(n) - logfact(k) - logfact(n - k))); + + /** exact implementation **/ + + unsigned long result = 1; + unsigned long i; + + // Avoid lengthy loops for large k, using the + // fact that (n,k) == (n,n-k). + if (k > n / 2) + k = n - k; + + for (i = 1; i <= k; ++i) { + // By interleaving the division and multiplication, we + // avoid intermediate results getting bigger than necessary. + + // We can do this without risking problems due to integer + // division: before dividing by i we will have multiplied + // by i consecutive integers, one of which has to be + // divisible by i. + result *= n - i + 1UL; + result /= i; + } - return result; + return result; } diff --git a/src/main/c/s2let_mw.c b/src/main/c/s2let_mw.c index 0c344791..12968c4d 100644 --- a/src/main/c/s2let_mw.c +++ b/src/main/c/s2let_mw.c @@ -2,11 +2,12 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include +#include #include #include -#include + +#include "s2let.h" /*! * Interface to SSHT (required by the Java interface to S2LET) @@ -17,7 +18,7 @@ * \param[in] L Angular harmonic band-limit. * \retval none */ -void s2let_mw_alm2map(complex double* f, const complex double* flm, int L, int spin) { +void s2let_mw_alm2map(complex double *f, const complex double *flm, int L, int spin) { int verbosity = 0; ssht_dl_method_t dl_method = SSHT_DL_RISBO; ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity); @@ -32,7 +33,7 @@ void s2let_mw_alm2map(complex double* f, const complex double* flm, int L, int s * \param[in] L Angular harmonic band-limit. * \retval none */ -void s2let_mw_map2alm(complex double* flm, const complex double* f, int L, int spin) { +void s2let_mw_map2alm(complex double *flm, const complex double *f, int L, int spin) { int verbosity = 0; ssht_dl_method_t dl_method = SSHT_DL_RISBO; ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity); @@ -47,7 +48,7 @@ void s2let_mw_map2alm(complex double* flm, const complex double* f, int L, int s * \param[in] L Angular harmonic band-limit. * \retval none */ -void s2let_mw_alm2map_real(double* f, const complex double* flm, int L) { +void s2let_mw_alm2map_real(double *f, const complex double *flm, int L) { int verbosity = 0; ssht_dl_method_t dl_method = SSHT_DL_RISBO; ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity); @@ -62,7 +63,7 @@ void s2let_mw_alm2map_real(double* f, const complex double* flm, int L) { * \param[in] L Angular harmonic band-limit. * \retval none */ -void s2let_mw_map2alm_real(complex double* flm, const double* f, int L) { +void s2let_mw_map2alm_real(complex double *flm, const double *f, int L) { int verbosity = 0; ssht_dl_method_t dl_method = SSHT_DL_RISBO; ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity); @@ -71,7 +72,7 @@ void s2let_mw_map2alm_real(complex double* flm, const double* f, int L) { /*! * Computes power of a complex MW signal */ -double s2let_mw_power(complex double *f, int L){ +double s2let_mw_power(complex double *f, int L) { complex double *flm; s2let_allocate_lm(&flm, L); s2let_mw_map2alm(flm, f, L, 0); @@ -83,7 +84,7 @@ double s2let_mw_power(complex double *f, int L){ /*! * Computes power of a real MW signal */ -double s2let_mw_power_real(double *f, int L){ +double s2let_mw_power_real(double *f, int L) { complex double *flm; s2let_allocate_lm(&flm, L); s2let_mw_map2alm_real(flm, f, L); diff --git a/src/main/c/s2let_spin_denoising_demo.c b/src/main/c/s2let_spin_denoising_demo.c index f9148859..293c5359 100644 --- a/src/main/c/s2let_spin_denoising_demo.c +++ b/src/main/c/s2let_spin_denoising_demo.c @@ -2,26 +2,29 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include #include +#include #include #include #include -#include #include -void s2let_lm_random_flm_sigma(complex double *flm, int L, int spin, int seed, double sigmanoise) { +#include "s2let.h" + +void s2let_lm_random_flm_sigma( + complex double *flm, int L, int spin, int seed, double sigmanoise) { int i; - int i_min = spin*spin; - for (i=i_min; iL; - int J_min = parameters->J_min; - int N = parameters->N; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; - int J = s2let_j_max(parameters); - int i, j, offset = 0; - for(j = J_min; j <= J; j++){ - int bl = parameters->upsample ? L : MIN(s2let_bandlimit(j, parameters), L); - for(i = 0; i < N*bl*(2*bl-1); i++){ - if( cabs(g_wav[offset + i]) < threshold[j-J_min] ) - g_wav[offset + i] = 0; - } - offset += N*bl*(2*bl-1); + int J = s2let_j_max(parameters); + int i, j, offset = 0; + for (j = J_min; j <= J; j++) { + int bl = parameters->upsample ? L : MIN(s2let_bandlimit(j, parameters), L); + for (i = 0; i < N * bl * (2 * bl - 1); i++) { + if (cabs(g_wav[offset + i]) < threshold[j - J_min]) + g_wav[offset + i] = 0; } + offset += N * bl * (2 * bl - 1); + } } /*! @@ -52,29 +54,24 @@ void hard_threshold( * COMMAND : bin/s2let_spin_denoising_demo * ARGUMENTS : none */ -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { int i, j; s2let_parameters_t parameters = {}; - const int seed = (int)(10000.0*(double)clock()/(double)CLOCKS_PER_SEC); + const int seed = (int)(10000.0 * (double)clock() / (double)CLOCKS_PER_SEC); // PARAMETERS - const double SNR_in = 10.0; // Input SNR - const int nsigma = 3; // Number of sigmas for hard thresholding - const int upsample = 0; // Multiresolution flag - const double B = 2; // Wavelet parameters - const int N = 4; // Azimuthal band-limit - const int J_min = 0; // First wavelet scale to use - const int spin = 2; // Spin number + const double SNR_in = 10.0; // Input SNR + const int nsigma = 3; // Number of sigmas for hard thresholding + const int upsample = 0; // Multiresolution flag + const double B = 2; // Wavelet parameters + const int N = 4; // Azimuthal band-limit + const int J_min = 0; // First wavelet scale to use + const int spin = 2; // Spin number char outfile[100]; complex double *flm, *f, *noise, *g, *g_wav, *g_scal, *f_denoised, *remaining_noise; - double *f_hpx_r, *f_hpx_i, - *f_r, *f_i, - *noise_r, *noise_i, - *f_denoised_r, *f_denoised_i, - *g_r, *g_i, - *scal_l; + double *f_hpx_r, *f_hpx_i, *f_r, *f_i, *noise_r, *noise_i, *f_denoised_r, + *f_denoised_i, *g_r, *g_i, *scal_l; complex double *noise_lm, *wav_lm; parameters.B = B; @@ -91,34 +88,34 @@ int main(int argc, char *argv[]) // Commented out code uses a real map and converts it to // a spin map - //char file[100] = "data/earth_tomo_mw_128_rot.fits"; + // char file[100] = "data/earth_tomo_mw_128_rot.fits"; char fileQ[100] = "data/wmap_mcmc_fs_k_synch_stk_q_9yr_v5_rot_mw.fits"; char fileU[100] = "data/wmap_mcmc_fs_k_synch_stk_u_9yr_v5_rot_mw.fits"; - //printf(" Reading file %s\n", file); + // printf(" Reading file %s\n", file); printf(" Reading file %s\n", fileQ); printf(" Reading file %s\n", fileU); const int L = s2let_fits_mw_read_bandlimit(fileQ); - //const int nside = s2let_fits_hpx_read_nside(fileQ); - //int L = MIN(192,3*nside); + // const int nside = s2let_fits_hpx_read_nside(fileQ); + // int L = MIN(192,3*nside); parameters.L = L; - printf(" - Detected bandlimit L = %i\n",L); + printf(" - Detected bandlimit L = %i\n", L); int J = s2let_j_max(¶meters); printf(" Parameters for wavelet denoising :\n"); s2let_switch_wavtype(1); - printf(" - Input SNR : %f\n",SNR_in); + printf(" - Input SNR : %f\n", SNR_in); printf(" - Sigma threshold : %i\n", nsigma); printf(" - upsample flag : %i\n", upsample); printf(" - Wavelet parameter : %i\n", B); printf(" - Total number of wavelets : %i\n", J); printf(" - First wavelet scale to be used : %i\n", J_min); - //s2let_allocate_mw_real(&f_r, L); - //s2let_fits_mw_read_map(f_r, file, L); // Read MW map from file - //s2let_hpx_allocate_real(&f_hpx_r, nside); - //s2let_hpx_allocate_real(&f_hpx_i, nside); - //s2let_hpx_read_map(f_hpx_r, fileQ, nside); - //s2let_hpx_read_map(f_hpx_i, fileU, nside); - //printf(" Map successfully read from file\n"); + // s2let_allocate_mw_real(&f_r, L); + // s2let_fits_mw_read_map(f_r, file, L); // Read MW map from file + // s2let_hpx_allocate_real(&f_hpx_r, nside); + // s2let_hpx_allocate_real(&f_hpx_i, nside); + // s2let_hpx_read_map(f_hpx_r, fileQ, nside); + // s2let_hpx_read_map(f_hpx_i, fileU, nside); + // printf(" Map successfully read from file\n"); // Force into spin signal // s2let_allocate_lm(&flm, L); @@ -135,37 +132,39 @@ int main(int argc, char *argv[]) s2let_allocate_mw_real(&f_i, L); s2let_fits_mw_read_map(f_r, fileQ, L); s2let_fits_mw_read_map(f_i, fileU, L); - //s2let_allocate_lm(&flm, L); - //s2let_hpx_map2alm_real(flm, f_hpx_r, nside, L); - //s2let_mw_alm2map_real(f_r, flm, L); - //s2let_hpx_map2alm_real(flm, f_hpx_i, nside, L); - //s2let_mw_alm2map_real(f_i, flm, L); + // s2let_allocate_lm(&flm, L); + // s2let_hpx_map2alm_real(flm, f_hpx_r, nside, L); + // s2let_mw_alm2map_real(f_r, flm, L); + // s2let_hpx_map2alm_real(flm, f_hpx_i, nside, L); + // s2let_mw_alm2map_real(f_i, flm, L); s2let_allocate_mw(&f, L); - for (i = 0; i < L*(2*L-1); ++i) - f[i] = f_r[i] + I*f_i[i]; - //free(flm); - //free(f_hpx_r); - //free(f_hpx_i); + for (i = 0; i < L * (2 * L - 1); ++i) + f[i] = f_r[i] + I * f_i[i]; + // free(flm); + // free(f_hpx_r); + // free(f_hpx_i); // Compute noise standard deviation and generate noise - double sigmanoise = sqrt(pow(10.0, -SNR_in/10.0) * s2let_mw_power(f, L)); + double sigmanoise = sqrt(pow(10.0, -SNR_in / 10.0) * s2let_mw_power(f, L)); printf(" - Std dev of the noise (to match SNR) = %f\n", sigmanoise); s2let_allocate_lm(&noise_lm, L); s2let_lm_random_flm_sigma(noise_lm, L, spin, seed, sigmanoise); - double SNR_actual = 10.0 * log10( s2let_mw_power(f, L) / s2let_lm_power(noise_lm, L)); + double SNR_actual = 10.0 * log10(s2let_mw_power(f, L) / s2let_lm_power(noise_lm, L)); printf(" - Actual (realised) SNR = %f\n", SNR_actual); // Add noise to the signal in real space - printf(" Contaminating the signal with this noise...");fflush(NULL); + printf(" Contaminating the signal with this noise..."); + fflush(NULL); s2let_allocate_mw(&noise, L); s2let_mw_alm2map(noise, noise_lm, L, 0); s2let_allocate_mw(&g, L); - for (i = 0; i < L*(2*L-1); i++) + for (i = 0; i < L * (2 * L - 1); i++) g[i] = f[i] + noise[i]; printf(" done\n"); - printf(" Performing wavelet decomposition...");fflush(NULL); + printf(" Performing wavelet decomposition..."); + fflush(NULL); // Perform wavelet analysis from scratch with all signals given as MW maps s2let_allocate_f_wav(&g_wav, &g_scal, ¶meters); s2let_analysis_px2wav(g_wav, g_scal, g, ¶meters); @@ -175,11 +174,13 @@ int main(int argc, char *argv[]) printf(" Construct the threshold rule for the Gaussian noise\n"); s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, ¶meters); s2let_tiling_wavelet(wav_lm, scal_l, ¶meters); - double *threshold = (double*)calloc((J-J_min+1), sizeof(double)); - for(j = J_min; j <= J; j++) - threshold[j-J_min] = sigmanoise * nsigma * sqrt(waveletpower(wav_lm + j * L*L, L)); + double *threshold = (double *)calloc((J - J_min + 1), sizeof(double)); + for (j = J_min; j <= J; j++) + threshold[j - J_min] = + sigmanoise * nsigma * sqrt(waveletpower(wav_lm + j * L * L, L)); - printf(" Hard thresholding the wavelets...");fflush(NULL); + printf(" Hard thresholding the wavelets..."); + fflush(NULL); s2let_allocate_mw(&f_denoised, L); hard_threshold(g_wav, threshold, ¶meters); s2let_synthesis_wav2px(f_denoised, g_wav, g_scal, ¶meters); @@ -187,11 +188,12 @@ int main(int argc, char *argv[]) // Remaining noise s2let_allocate_mw(&remaining_noise, L); - for(i = 0; i < L*(2*L-1); i++) + for (i = 0; i < L * (2 * L - 1); i++) remaining_noise[i] = f_denoised[i] - f[i]; // SNR after denoising - double SNR_denoised = 10.0 * log10( s2let_mw_power(f, L) / s2let_mw_power(remaining_noise, L)); + double SNR_denoised = + 10.0 * log10(s2let_mw_power(f, L) / s2let_mw_power(remaining_noise, L)); printf(" -> SNR before denoising = %f\n", SNR_actual); printf(" -> SNR after denoising = %f\n", SNR_denoised); @@ -202,8 +204,7 @@ int main(int argc, char *argv[]) s2let_allocate_mw_real(&g_i, L); s2let_allocate_mw_real(&f_denoised_r, L); s2let_allocate_mw_real(&f_denoised_i, L); - for (i = 0; i < L*(2*L-1); ++i) - { + for (i = 0; i < L * (2 * L - 1); ++i) { noise_r[i] = creal(noise[i]); noise_i[i] = cimag(noise[i]); g_r[i] = creal(g[i]); @@ -212,40 +213,40 @@ int main(int argc, char *argv[]) f_denoised_i[i] = cimag(f_denoised[i]); } printf(" Write output files\n"); - sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_input" , ".fits"); + sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_input", ".fits"); printf(" Outfile = %s\n", outfile); - remove(outfile); // In case the file exists + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, f_r, L); // Now write the map to fits file - sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_input" , ".fits"); + sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_input", ".fits"); printf(" Outfile = %s\n", outfile); - remove(outfile); // In case the file exists + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, f_i, L); // Now write the map to fits file - sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_noise" , ".fits"); + sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_noise", ".fits"); printf(" Outfile = %s\n", outfile); - remove(outfile); // In case the file exists + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, noise_r, L); // Now write the map to fits file - sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_noise" , ".fits"); + sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_noise", ".fits"); printf(" Outfile = %s\n", outfile); - remove(outfile); // In case the file exists + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, noise_i, L); // Now write the map to fits file - sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_input_noise" , ".fits"); + sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_input_noise", ".fits"); printf(" Outfile = %s\n", outfile); - remove(outfile); // In case the file exists + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, g_r, L); // Now write the map to fits file - sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_input_noise" , ".fits"); + sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_input_noise", ".fits"); printf(" Outfile = %s\n", outfile); - remove(outfile); // In case the file exists + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, g_i, L); // Now write the map to fits file sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_denoised", ".fits"); printf(" Outfile = %s\n", outfile); - remove(outfile); // In case the file exists + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, f_denoised_r, L); // Now write the map to fits file sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_denoised", ".fits"); printf(" Outfile = %s\n", outfile); - remove(outfile); // In case the file exists + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, f_denoised_i, L); // Now write the map to fits file free(f); diff --git a/src/main/c/s2let_synthesis.c b/src/main/c/s2let_synthesis.c index 3ca34224..9ba8dcaa 100644 --- a/src/main/c/s2let_synthesis.c +++ b/src/main/c/s2let_synthesis.c @@ -2,27 +2,25 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" -#include -#include #include #include -#include +#include +#include #include +#include + +#include "s2let.h" /*! * Wavelet synthesis from Wigner space to harmonic space for complex signals. * * \param[out] flm Spherical harmonic coefficients of input function. - * \param[in] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet contribution). - * \param[in] f_scal_lm Wavelet transform (spherical harmonic coefficients of scaling contribution). - * \param[in] wav_lm Wavelet kernels. - * \param[in] scal_l Scaling function kernels. - * \param[in] parameters A fully populated parameters object. The \link - * s2let_parameters_t::reality reality\endlink flag - * is ignored. Use \link s2let_synthesis_lmn2lm_real - * \endlink instead for real signals. - * \retval none + * \param[in] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet + * contribution). \param[in] f_scal_lm Wavelet transform (spherical harmonic + * coefficients of scaling contribution). \param[in] wav_lm Wavelet kernels. \param[in] + * scal_l Scaling function kernels. \param[in] parameters A fully populated parameters + * object. The \link s2let_parameters_t::reality reality\endlink flag is ignored. Use + * \link s2let_synthesis_lmn2lm_real \endlink instead for real signals. \retval none */ void s2let_synthesis_lmn2lm( complex double *flm, @@ -30,86 +28,75 @@ void s2let_synthesis_lmn2lm( const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - int spin = parameters->spin; - - int j, el, m ,n; - int J = s2let_j_max(parameters); - int bandlimit = L; - int Nj = N; - - int lm_ind, lmn_ind; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - complex double psi; - double phi; - - int offset = 0; - - // Clear output - for (el = 0; el < L*L; ++el) - flm[el] = 0; - - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + int spin = parameters->spin; + + int j, el, m, n; + int J = s2let_j_max(parameters); + int bandlimit = L; + int Nj = N; + + int lm_ind, lmn_ind; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + complex double psi; + double phi; + + int offset = 0; + + // Clear output + for (el = 0; el < L * L; ++el) + flm[el] = 0; + + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; + } - for (n = -Nj+1; n < Nj; n+=2) - { - for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = wav_lm[j*L*L + lm_ind]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); - flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi; - } - } + for (n = -Nj + 1; n < Nj; n += 2) { + for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = wav_lm[j * L * L + lm_ind]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); + flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi; } - offset += so3_sampling_flmn_size(&so3_parameters); + } } + offset += so3_sampling_flmn_size(&so3_parameters); + } - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); - for (el = ABS(spin); el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - flm[lm_ind] += f_scal_lm[lm_ind] * phi; - } + for (el = ABS(spin); el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + flm[lm_ind] += f_scal_lm[lm_ind] * phi; } + } } /*! * Wavelet synthesis from Wigner space to harmonic space for real signals. * * \param[out] flm Spherical harmonic coefficients of input function. - * \param[in] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet contribution). - * \param[in] f_scal_lm Wavelet transform (spherical harmonic coefficients of scaling contribution). - * \param[in] wav_lm Wavelet kernels. - * \param[in] scal_l Scaling function kernels. - * \param[in] parameters A fully populated parameters object. The \link - * s2let_parameters_t::reality reality\endlink flag - * is ignored. Use \link s2let_synthesis_lmn2lm - * \endlink instead for complex signals. - * \retval none + * \param[in] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet + * contribution). \param[in] f_scal_lm Wavelet transform (spherical harmonic + * coefficients of scaling contribution). \param[in] wav_lm Wavelet kernels. \param[in] + * scal_l Scaling function kernels. \param[in] parameters A fully populated parameters + * object. The \link s2let_parameters_t::reality reality\endlink flag is ignored. Use + * \link s2let_synthesis_lmn2lm \endlink instead for complex signals. \retval none */ void s2let_synthesis_lmn2lm_real( complex double *flm, @@ -117,108 +104,98 @@ void s2let_synthesis_lmn2lm_real( const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - - int j, el, m ,n; - int J = s2let_j_max(parameters); - int bandlimit = L; - int Nj = N; - - int lm_ind, lmn_ind; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - complex double psi, npsi; - double phi; - - int offset = 0; - - // Clear output - for (el = 0; el < L*L; ++el) - flm[el] = 0; - - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + + int j, el, m, n; + int J = s2let_j_max(parameters); + int bandlimit = L; + int Nj = N; + + int lm_ind, lmn_ind; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + complex double psi, npsi; + double phi; + + int offset = 0; + + // Clear output + for (el = 0; el < L * L; ++el) + flm[el] = 0; + + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; + } + + for (n = 1 - Nj % 2; n < Nj; n += 2) { + for (el = n; el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = wav_lm[j * L * L + lm_ind]; + + if (n) { + ssht_sampling_elm2ind(&lm_ind, el, -n); + npsi = wav_lm[j * L * L + lm_ind]; } - for (n = 1-Nj%2; n < Nj; n+=2) - { - for (el = n; el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = wav_lm[j*L*L + lm_ind]; - - if (n) - { - ssht_sampling_elm2ind(&lm_ind, el, -n); - npsi = wav_lm[j*L*L + lm_ind]; - } - - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters); - flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi; - - if (n) - { - so3_sampling_elmn2ind_real(&lmn_ind, el, -m, n, &so3_parameters); - int sign = (m+n)%2 ? -1 : 1; - flm[lm_ind] += sign * conj(f_wav_lmn[offset + lmn_ind]) * npsi; - } - } - } + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters); + flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi; + + if (n) { + so3_sampling_elmn2ind_real(&lmn_ind, el, -m, n, &so3_parameters); + int sign = (m + n) % 2 ? -1 : 1; + flm[lm_ind] += sign * conj(f_wav_lmn[offset + lmn_ind]) * npsi; + } } - offset += so3_sampling_flmn_size(&so3_parameters); + } } + offset += so3_sampling_flmn_size(&so3_parameters); + } - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); - for (el = 0; el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - flm[lm_ind] += f_scal_lm[lm_ind] * phi; - } + for (el = 0; el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + flm[lm_ind] += f_scal_lm[lm_ind] * phi; } + } } /*! * Wavelet analysis from wavelet space to harmonic space for complex signals. - * with fully manual wavelet tiling, using multiresolution as default with + * with fully manual wavelet tiling, using multiresolution as default with * the band-limits provided in input. * * \param[out] flm Spherical harmonic coefficients of the signal * \param[in] f_wav Array of wavelets maps * \param[in] f_scal Scaling function map - * \param[in] scal_l Array of size L containing the \ell space tiling for the scaling fct. - It is only \ell because it is assumed to be axisymmetric. - * \param[in] wav_lm Array of size (J+1)*L*L containing the (\ell, space) harmonic coefs - of the wavelets. They can be directional. These must make sense and - define a valid invertible transform as no extra checks are performed. + * \param[in] scal_l Array of size L containing the \ell space tiling for the scaling + fct. It is only \ell because it is assumed to be axisymmetric. + * \param[in] wav_lm Array of size (J+1)*L*L containing the (\ell, space) harmonic + coefs of the wavelets. They can be directional. These must make sense and define a + valid invertible transform as no extra checks are performed. * \param[in] scal_bandlimit Same as wav_bandlimits but only one integer: the band-limit of the scaling function. - * \param[in] wav_bandlimits Array of integers of size J+1 containing the band-limits + * \param[in] wav_bandlimits Array of integers of size J+1 containing the band-limits of the wavelets. Will be used to do the multiresolution. These must make sense and define a valid invertible transform as no extra checks are performed. - * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. + * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. * \param[in] L Band-limit for the transform: defines the size of all awways. - * \param[in] spin Spin (integer) to perform the transform + * \param[in] spin Spin (integer) to perform the transform * \param[in] N Azimuthal band-limit for the directional transform * \retval none */ @@ -233,96 +210,84 @@ void s2let_synthesis_wav2lm_manual( int J, int L, int spin, - int N -) { - s2let_parameters_t parameters = {}; - parameters.L = L; - parameters.J_min = 0; - parameters.B = pow(L, 1.0/(float)J); - parameters.N = N; - parameters.dl_method = SSHT_DL_RISBO; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, ¶meters); - - int j, offset; - complex double *f_wav_lmn, *f_scal_lm; - complex double psi; - double phi; - int el, m, n, lm_ind, lmn_ind; - - bandlimit = MIN(scal_bandlimit, L); - - f_scal_lm = (complex double*)calloc(bandlimit*bandlimit, sizeof(complex double)); - - // Note, this is a spin-0 transform! - switch (parameters.sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_forward_sov_conv_sym_ss(f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - for (el = ABS(spin); el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - flm[lm_ind] += f_scal_lm[lm_ind] * phi; - } + int N) { + s2let_parameters_t parameters = {}; + parameters.L = L; + parameters.J_min = 0; + parameters.B = pow(L, 1.0 / (float)J); + parameters.N = N; + parameters.dl_method = SSHT_DL_RISBO; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, ¶meters); + + int j, offset; + complex double *f_wav_lmn, *f_scal_lm; + complex double psi; + double phi; + int el, m, n, lm_ind, lmn_ind; + + bandlimit = MIN(scal_bandlimit, L); + + f_scal_lm = (complex double *)calloc(bandlimit * bandlimit, sizeof(complex double)); + + // Note, this is a spin-0 transform! + switch (parameters.sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_forward_sov_conv_sym( + f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_forward_sov_conv_sym_ss( + f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + for (el = ABS(spin); el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + flm[lm_ind] += f_scal_lm[lm_ind] * phi; } - - free(f_scal_lm); - - offset = 0; - for (j = 0; j <= J; ++j) - { - bandlimit = MIN(wav_bandlimits[j], L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - so3_parameters.L0 = 0; - - f_wav_lmn = (complex double*)calloc(so3_sampling_flmn_size(&so3_parameters), sizeof(complex double)); - - so3_core_forward_direct( - f_wav_lmn, - f_wav + offset, - &so3_parameters - ); - - for (n = -Nj+1; n < Nj; n+=2) - { - for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = wav_lm[j*L*L + lm_ind]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); - flm[lm_ind] += f_wav_lmn[lmn_ind] * psi; - } - } + } + + free(f_scal_lm); + + offset = 0; + for (j = 0; j <= J; ++j) { + bandlimit = MIN(wav_bandlimits[j], L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; + so3_parameters.L0 = 0; + + f_wav_lmn = (complex double *)calloc( + so3_sampling_flmn_size(&so3_parameters), sizeof(complex double)); + + so3_core_forward_direct(f_wav_lmn, f_wav + offset, &so3_parameters); + + for (n = -Nj + 1; n < Nj; n += 2) { + for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = wav_lm[j * L * L + lm_ind]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); + flm[lm_ind] += f_wav_lmn[lmn_ind] * psi; } - - free(f_wav_lmn); - offset += so3_sampling_f_size(&so3_parameters); - + } } + free(f_wav_lmn); + offset += so3_sampling_f_size(&so3_parameters); + } } - /*! * Wavelet synthesis from wavelet space to harmonic space for complex signals. * @@ -339,78 +304,71 @@ void s2let_synthesis_wav2lm( complex double *flm, const complex double *f_wav, const complex double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - ssht_dl_method_t dl_method = parameters->dl_method; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - int j, offset, offset_lmn; - int J = s2let_j_max(parameters); - - complex double *wav_lm; - double *scal_l; - s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); - s2let_tiling_wavelet(wav_lm, scal_l, parameters); - - complex double *f_wav_lmn, *f_scal_lm; - s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); - - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - - // Note, this is a spin-0 transform! - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_forward_sov_conv_sym_ss(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + ssht_dl_method_t dl_method = parameters->dl_method; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + int j, offset, offset_lmn; + int J = s2let_j_max(parameters); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); + s2let_tiling_wavelet(wav_lm, scal_l, parameters); + + complex double *f_wav_lmn, *f_scal_lm; + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); + + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + + // Note, this is a spin-0 transform! + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_forward_sov_conv_sym( + f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_forward_sov_conv_sym_ss( + f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + offset = 0; + offset_lmn = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; } - offset = 0; - offset_lmn = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } - - so3_parameters.L0 = s2let_L0(j, parameters); + so3_parameters.L0 = s2let_L0(j, parameters); + // so3_adjoint_inverse_direct( + // so3_core_forward_direct( + so3_core_forward_via_ssht(f_wav_lmn + offset_lmn, f_wav + offset, &so3_parameters); + offset_lmn += so3_sampling_flmn_size(&so3_parameters); + offset += so3_sampling_f_size(&so3_parameters); + } -// so3_adjoint_inverse_direct( -// so3_core_forward_direct( - so3_core_forward_via_ssht( - f_wav_lmn + offset_lmn, - f_wav + offset, - &so3_parameters - ); - offset_lmn += so3_sampling_flmn_size(&so3_parameters); - offset += so3_sampling_f_size(&so3_parameters); - } + s2let_synthesis_lmn2lm(flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, parameters); - s2let_synthesis_lmn2lm(flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, parameters); - - free(wav_lm); - free(scal_l); - free(f_scal_lm); - free(f_wav_lmn); + free(wav_lm); + free(scal_l); + free(f_scal_lm); + free(f_wav_lmn); } /*! @@ -429,80 +387,74 @@ void s2let_synthesis_wav2lm_real( complex double *flm, const double *f_wav, const double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - ssht_dl_method_t dl_method = parameters->dl_method; - - s2let_parameters_t real_parameters = *parameters; - real_parameters.reality = 1; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, &real_parameters); - - int j, offset, offset_lmn; - int J = s2let_j_max(&real_parameters); - - complex double *wav_lm; - double *scal_l; - s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters); - s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters); - - complex double *f_wav_lmn, *f_scal_lm; - s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters); - - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, &real_parameters), L); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_forward_sov_conv_sym_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_forward_sov_conv_sym_ss_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + ssht_dl_method_t dl_method = parameters->dl_method; + + s2let_parameters_t real_parameters = *parameters; + real_parameters.reality = 1; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, &real_parameters); + + int j, offset, offset_lmn; + int J = s2let_j_max(&real_parameters); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters); + s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters); + + complex double *f_wav_lmn, *f_scal_lm; + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters); + + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, &real_parameters), L); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_forward_sov_conv_sym_real( + f_scal_lm, f_scal, bandlimit, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_forward_sov_conv_sym_ss_real( + f_scal_lm, f_scal, bandlimit, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + offset = 0; + offset_lmn = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; } + so3_parameters.L0 = s2let_L0(j, parameters); - offset = 0; - offset_lmn = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } - - so3_parameters.L0 = s2let_L0(j, parameters); - - so3_core_forward_via_ssht_real( - f_wav_lmn + offset_lmn, - f_wav + offset, - &so3_parameters - ); + so3_core_forward_via_ssht_real( + f_wav_lmn + offset_lmn, f_wav + offset, &so3_parameters); - offset_lmn += so3_sampling_flmn_size(&so3_parameters); - offset += so3_sampling_f_size(&so3_parameters); - } + offset_lmn += so3_sampling_flmn_size(&so3_parameters); + offset += so3_sampling_f_size(&so3_parameters); + } - s2let_synthesis_lmn2lm_real( - flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, &real_parameters); + s2let_synthesis_lmn2lm_real( + flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, &real_parameters); - free(wav_lm); - free(scal_l); - free(f_scal_lm); - free(f_wav_lmn); + free(wav_lm); + free(scal_l); + free(f_scal_lm); + free(f_wav_lmn); } /*! @@ -521,31 +473,29 @@ void s2let_synthesis_wav2px( complex double *f, const complex double *f_wav, const complex double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int spin = parameters->spin; - ssht_dl_method_t dl_method = parameters->dl_method; - int verbosity = 0; - - complex double *flm; - s2let_allocate_lm(&flm, L); - - s2let_synthesis_wav2lm(flm, f_wav, f_scal, parameters); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_inverse_sov_sym_ss(f, flm, L, spin, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - free(flm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int spin = parameters->spin; + ssht_dl_method_t dl_method = parameters->dl_method; + int verbosity = 0; + + complex double *flm; + s2let_allocate_lm(&flm, L); + + s2let_synthesis_wav2lm(flm, f_wav, f_scal, parameters); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_inverse_sov_sym_ss(f, flm, L, spin, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + free(flm); } /*! @@ -564,28 +514,26 @@ void s2let_synthesis_wav2px_real( double *f, const double *f_wav, const double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - ssht_dl_method_t dl_method = parameters->dl_method; - int verbosity = 0; - - complex double *flm; - s2let_allocate_lm(&flm, L); - - s2let_synthesis_wav2lm_real(flm, f_wav, f_scal, parameters); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_core_mw_inverse_sov_sym_ss_real(f, flm, L, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - free(flm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + ssht_dl_method_t dl_method = parameters->dl_method; + int verbosity = 0; + + complex double *flm; + s2let_allocate_lm(&flm, L); + + s2let_synthesis_wav2lm_real(flm, f_wav, f_scal, parameters); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_core_mw_inverse_sov_sym_ss_real(f, flm, L, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + free(flm); } diff --git a/src/main/c/s2let_synthesis_adjoint.c b/src/main/c/s2let_synthesis_adjoint.c index 6981260e..2b727c85 100644 --- a/src/main/c/s2let_synthesis_adjoint.c +++ b/src/main/c/s2let_synthesis_adjoint.c @@ -2,21 +2,22 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" -#include -#include #include #include -#include +#include +#include #include +#include + +#include "s2let.h" /*! * Wavelet synthesis adjoint from harmonic space to Wigner space for complex signals. * - * \param[out] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet contribution). - * \param[out] f_scal_lm Wavelet transform (Spherical harmonic coefficients of scaling contribution). - * \param[in] flm Spherical harmonic coefficients of input function. - * \param[in] wav_lm Wavelet kernels in harmonic space. + * \param[out] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet + * contribution). \param[out] f_scal_lm Wavelet transform (Spherical harmonic + * coefficients of scaling contribution). \param[in] flm Spherical harmonic + * coefficients of input function. \param[in] wav_lm Wavelet kernels in harmonic space. * \param[in] scal_l Scaling function kernels in harmonic space. * \param[in] parameters A fully populated parameters object. The \link * s2let_parameters_t::reality reality\endlink flag @@ -30,85 +31,74 @@ void s2let_synthesis_adjoint_lm2lmn( const complex double *flm, const complex double *wav_lm, const double *scal_l, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - int spin = parameters->spin; - - int j, el, m ,n; - int J = s2let_j_max(parameters); - int bandlimit = L; - int Nj = N; - - int lm_ind, lmn_ind; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - complex double psi; - double phi; - - int offset = 0; - - for (j = J_min; j <= J; ++j) - { - - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - Nj = MIN(N,bandlimit); - // ensure N and Nj are both even or both odd - Nj += (Nj+N)%2; - so3_parameters.N = Nj; - } + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + int spin = parameters->spin; + + int j, el, m, n; + int J = s2let_j_max(parameters); + int bandlimit = L; + int Nj = N; + + int lm_ind, lmn_ind; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + complex double psi; + double phi; + + int offset = 0; + + for (j = J_min; j <= J; ++j) { + + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + Nj = MIN(N, bandlimit); + // ensure N and Nj are both even or both odd + Nj += (Nj + N) % 2; + so3_parameters.N = Nj; + } + + for (n = -Nj + 1; n < Nj; n += 2) { + for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = conj(wav_lm[j * L * L + lm_ind]); - for (n = -Nj+1; n < Nj; n+=2) - { - for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = conj(wav_lm[j*L*L + lm_ind]); - - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); - f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi; - } - } + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); + f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi; } - offset += so3_sampling_flmn_size(&so3_parameters); + } } + offset += so3_sampling_flmn_size(&so3_parameters); + } - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); - for (el = ABS(spin); el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - f_scal_lm[lm_ind] = flm[lm_ind] * phi; - } + for (el = ABS(spin); el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + f_scal_lm[lm_ind] = flm[lm_ind] * phi; } + } } /*! * Wavelet synthesis adjoint from harmonic space to Wigner space for real signals. * - * \param[out] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet contribution). - * \param[out] f_scal_lm Wavelet transform (spherical harmonic coefficients of scaling contribution). - * \param[in] flm Spherical harmonic coefficients of input function. - * \param[in] wav_lm Wavelet kernels. - * \param[in] scal_l Scaling function kernels. - * \param[in] parameters A fully populated parameters object. The \link - * s2let_parameters_t::reality reality\endlink flag - * is ignored. Use \link s2let_analysis_lm2lmn - * \endlink instead for complex signals. - * \retval none + * \param[out] f_wav_lmn Wavelet transform (Wigner coefficients of wavelet + * contribution). \param[out] f_scal_lm Wavelet transform (spherical harmonic + * coefficients of scaling contribution). \param[in] flm Spherical harmonic + * coefficients of input function. \param[in] wav_lm Wavelet kernels. \param[in] scal_l + * Scaling function kernels. \param[in] parameters A fully populated parameters object. + * The \link s2let_parameters_t::reality reality\endlink flag is ignored. Use \link + * s2let_analysis_lm2lmn \endlink instead for complex signals. \retval none */ void s2let_synthesis_adjoint_lm2lmn_real( complex double *f_wav_lmn, @@ -116,92 +106,83 @@ void s2let_synthesis_adjoint_lm2lmn_real( const complex double *flm, const complex double *wav_lm, const double *scal_l, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - - int j, el, m ,n; - int J = s2let_j_max(parameters); - int bandlimit = L; - int Nj = N; - - int lm_ind, lmn_ind; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - complex double psi; - double phi; - - int offset = 0; - - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - // ensure N and Nj are both even or both odd - Nj += (Nj+N)%2; - so3_parameters.N = Nj; - } + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + + int j, el, m, n; + int J = s2let_j_max(parameters); + int bandlimit = L; + int Nj = N; + + int lm_ind, lmn_ind; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + complex double psi; + double phi; + + int offset = 0; + + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + // ensure N and Nj are both even or both odd + Nj += (Nj + N) % 2; + so3_parameters.N = Nj; + } - for (n = 1-Nj%2; n < Nj; n+=2) - { - for (el = n; el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = conj(wav_lm[j*L*L + lm_ind]); - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters); - f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi; - } - } + for (n = 1 - Nj % 2; n < Nj; n += 2) { + for (el = n; el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = conj(wav_lm[j * L * L + lm_ind]); + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters); + f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi; } - offset += so3_sampling_flmn_size(&so3_parameters); + } } + offset += so3_sampling_flmn_size(&so3_parameters); + } - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); - for (el = 0; el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - f_scal_lm[lm_ind] = flm[lm_ind] * phi; - } + for (el = 0; el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + f_scal_lm[lm_ind] = flm[lm_ind] * phi; } + } } - /*! * Wavelet synthesis adjoint from harmonic space to wavelet space for complex signals. - * with fully manual wavelet tiling, using multiresolution as default with + * with fully manual wavelet tiling, using multiresolution as default with * the band-limits provided in input. * * \param[out] f_wav Array of wavelet maps * \param[out] f_scal Scaling function map * \param[in] flm Spherical harmonic coefficients of the signal - * \param[in] scal_l Array of size L containing the \ell space tiling for the scaling fct. - It is only \ell because it is assumed to be axisymmetric. - * \param[in] wav_lm Array of size (J+1)*L*L containing the (\ell, space) harmonic coefs - of the wavelets. They can be directional. These must make sense and - define a valid invertible transform as no extra checks are performed. + * \param[in] scal_l Array of size L containing the \ell space tiling for the scaling + fct. It is only \ell because it is assumed to be axisymmetric. + * \param[in] wav_lm Array of size (J+1)*L*L containing the (\ell, space) harmonic + coefs of the wavelets. They can be directional. These must make sense and define a + valid invertible transform as no extra checks are performed. * \param[in] scal_bandlimit Same as wav_bandlimits but only one integer: the band-limit of the scaling function. - * \param[in] wav_bandlimits Array of integers of size J+1 containing the band-limits + * \param[in] wav_bandlimits Array of integers of size J+1 containing the band-limits of the wavelets. Will be used to do the multiresolution. These must make sense and define a valid invertible transform as no extra checks are performed. - * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. + * \param[in] J Number of scales in total (in wav_bandlimits) is J+1. * \param[in] L Band-limit for the transform: defines the size of all awways. - * \param[in] spin Spin (integer) to perform the transform + * \param[in] spin Spin (integer) to perform the transform * \param[in] N Azimuthal band-limit for the directional transform * \retval none */ @@ -216,99 +197,87 @@ void s2let_synthesis_adjoint_lm2wav_manual( int J, int L, int spin, - int N -) { - s2let_parameters_t parameters = {}; - parameters.L = L; - parameters.J_min = 0; - parameters.B = pow(L, 1.0/(float)(J+2)); - parameters.N = N; - parameters.dl_method = SSHT_DL_RISBO; - printf("J = %i\n", J); - printf("B = %g\n", parameters.B); - printf("N = %i\n", parameters.N); - printf("L = %i\n", parameters.L); - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, ¶meters); - - int j, offset, offset_lmn; - complex double *f_wav_lmn, *f_scal_lm; - complex double psi, npsi; - double phi; - int el, m, n, lm_ind, lmn_ind; - - int Nj = N; - - bandlimit = MIN(scal_bandlimit, L); - f_scal_lm = (complex double*)calloc(bandlimit*bandlimit, sizeof(complex double)); - - for (el = ABS(spin); el < bandlimit; ++el) - { - phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - f_scal_lm[lm_ind] = flm[lm_ind] * phi; - } - } - - switch (parameters.sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_forward_sov_sym(f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_forward_sov_sym_ss(f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); + int N) { + s2let_parameters_t parameters = {}; + parameters.L = L; + parameters.J_min = 0; + parameters.B = pow(L, 1.0 / (float)(J + 2)); + parameters.N = N; + parameters.dl_method = SSHT_DL_RISBO; + printf("J = %i\n", J); + printf("B = %g\n", parameters.B); + printf("N = %i\n", parameters.N); + printf("L = %i\n", parameters.L); + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, ¶meters); + + int j, offset, offset_lmn; + complex double *f_wav_lmn, *f_scal_lm; + complex double psi, npsi; + double phi; + int el, m, n, lm_ind, lmn_ind; + + int Nj = N; + + bandlimit = MIN(scal_bandlimit, L); + f_scal_lm = (complex double *)calloc(bandlimit * bandlimit, sizeof(complex double)); + + for (el = ABS(spin); el < bandlimit; ++el) { + phi = sqrt(4.0 * PI / (2 * el + 1)) * scal_l[el]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + f_scal_lm[lm_ind] = flm[lm_ind] * phi; } - - free(f_scal_lm); - - offset = 0; - for (j = 0; j <= J; ++j) - { - bandlimit = MIN(wav_bandlimits[j], L); - so3_parameters.L = bandlimit; - int Nj = MIN(N, bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - so3_parameters.L0 = 0; - - f_wav_lmn = (complex double*)calloc(so3_sampling_flmn_size(&so3_parameters), sizeof(complex double)); - - for (n = -Nj+1; n < Nj; n+=2) - { - for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) - { - ssht_sampling_elm2ind(&lm_ind, el, n); - psi = wav_lm[j*L*L + lm_ind]; - for (m = -el; m <= el; ++m) - { - ssht_sampling_elm2ind(&lm_ind, el, m); - so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); - f_wav_lmn[lmn_ind] = flm[lm_ind] * psi; - } - } + } + + switch (parameters.sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_forward_sov_sym( + f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_forward_sov_sym_ss( + f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + free(f_scal_lm); + + offset = 0; + for (j = 0; j <= J; ++j) { + bandlimit = MIN(wav_bandlimits[j], L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; + so3_parameters.L0 = 0; + + f_wav_lmn = (complex double *)calloc( + so3_sampling_flmn_size(&so3_parameters), sizeof(complex double)); + + for (n = -Nj + 1; n < Nj; n += 2) { + for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el) { + ssht_sampling_elm2ind(&lm_ind, el, n); + psi = wav_lm[j * L * L + lm_ind]; + for (m = -el; m <= el; ++m) { + ssht_sampling_elm2ind(&lm_ind, el, m); + so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters); + f_wav_lmn[lmn_ind] = flm[lm_ind] * psi; } - - so3_adjoint_forward_direct( - f_wav + offset, - f_wav_lmn, - &so3_parameters - ); - - free(f_wav_lmn); - offset += so3_sampling_f_size(&so3_parameters); - + } } -} + so3_adjoint_forward_direct(f_wav + offset, f_wav_lmn, &so3_parameters); + free(f_wav_lmn); + offset += so3_sampling_f_size(&so3_parameters); + } +} /*! * Wavelet synthesis_adjoint from harmonic space to wavelet space for complex signals. @@ -326,78 +295,74 @@ void s2let_synthesis_adjoint_lm2wav( complex double *f_wav, complex double *f_scal, const complex double *flm, - const s2let_parameters_t *parameters -) { - int L = parameters->L, i; - int J_min = parameters->J_min; - int N = parameters->N; - ssht_dl_method_t dl_method = parameters->dl_method; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, parameters); - - int j, offset, offset_lmn; - int J = s2let_j_max(parameters); - - complex double *wav_lm; - double *scal_l; - s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); - s2let_tiling_wavelet(wav_lm, scal_l, parameters); - - complex double *f_wav_lmn, *f_scal_lm; - - s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); - s2let_synthesis_adjoint_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, parameters); - - - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - - // Note, this is a spin-0 transform! - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_forward_sov_sym(f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_forward_sov_sym_ss(f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - offset = 0; - offset_lmn = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } - - so3_parameters.L0 = s2let_L0(j, parameters); - - so3_adjoint_forward_direct( -// so3_core_inverse_direct( -// so3_core_inverse_direct( - f_wav + offset, - f_wav_lmn + offset_lmn, - &so3_parameters - ); - offset_lmn += so3_sampling_flmn_size(&so3_parameters); - offset += so3_sampling_f_size(&so3_parameters); + const s2let_parameters_t *parameters) { + int L = parameters->L, i; + int J_min = parameters->J_min; + int N = parameters->N; + ssht_dl_method_t dl_method = parameters->dl_method; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, parameters); + + int j, offset, offset_lmn; + int J = s2let_j_max(parameters); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters); + s2let_tiling_wavelet(wav_lm, scal_l, parameters); + + complex double *f_wav_lmn, *f_scal_lm; + + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters); + s2let_synthesis_adjoint_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, parameters); + + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + + // Note, this is a spin-0 transform! + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_forward_sov_sym( + f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_forward_sov_sym_ss( + f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + offset = 0; + offset_lmn = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; } - free(wav_lm); - free(scal_l); - free(f_scal_lm); - free(f_wav_lmn); + so3_parameters.L0 = s2let_L0(j, parameters); + + so3_adjoint_forward_direct( + // so3_core_inverse_direct( + // so3_core_inverse_direct( + f_wav + offset, + f_wav_lmn + offset_lmn, + &so3_parameters); + offset_lmn += so3_sampling_flmn_size(&so3_parameters); + offset += so3_sampling_f_size(&so3_parameters); + } + + free(wav_lm); + free(scal_l); + free(f_scal_lm); + free(f_wav_lmn); } /*! @@ -416,77 +381,73 @@ void s2let_synthesis_adjoint_lm2wav_real( double *f_wav, double *f_scal, const complex double *flm, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - int N = parameters->N; - ssht_dl_method_t dl_method = parameters->dl_method; - - s2let_parameters_t real_parameters = *parameters; - real_parameters.reality = 1; - - int bandlimit = L; - int verbosity = 0; - so3_parameters_t so3_parameters = {}; - fill_so3_parameters(&so3_parameters, &real_parameters); - - int j, offset, offset_lmn; - int J = s2let_j_max(&real_parameters); - - complex double *wav_lm; - double *scal_l; - s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters); - s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters); - - complex double *f_wav_lmn, *f_scal_lm; - - s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters); - s2let_synthesis_adjoint_lm2lmn_real(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, &real_parameters); - - if (!parameters->upsample) - bandlimit = MIN(s2let_bandlimit(J_min-1, &real_parameters), L); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_forward_sov_sym_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_forward_sov_sym_ss_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int N = parameters->N; + ssht_dl_method_t dl_method = parameters->dl_method; + + s2let_parameters_t real_parameters = *parameters; + real_parameters.reality = 1; + + int bandlimit = L; + int verbosity = 0; + so3_parameters_t so3_parameters = {}; + fill_so3_parameters(&so3_parameters, &real_parameters); + + int j, offset, offset_lmn; + int J = s2let_j_max(&real_parameters); + + complex double *wav_lm; + double *scal_l; + s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters); + s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters); + + complex double *f_wav_lmn, *f_scal_lm; + + s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters); + s2let_synthesis_adjoint_lm2lmn_real( + f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, &real_parameters); + + if (!parameters->upsample) + bandlimit = MIN(s2let_bandlimit(J_min - 1, &real_parameters), L); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_forward_sov_sym_real( + f_scal, f_scal_lm, bandlimit, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_forward_sov_sym_ss_real( + f_scal, f_scal_lm, bandlimit, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + offset = 0; + offset_lmn = 0; + for (j = J_min; j <= J; ++j) { + if (!parameters->upsample) { + bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L); + so3_parameters.L = bandlimit; + int Nj = MIN(N, bandlimit); + Nj += (Nj + N) % 2; // ensure N and Nj are both even or both odd + so3_parameters.N = Nj; } - offset = 0; - offset_lmn = 0; - for (j = J_min; j <= J; ++j) - { - if (!parameters->upsample) - { - bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L); - so3_parameters.L = bandlimit; - int Nj = MIN(N,bandlimit); - Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd - so3_parameters.N = Nj; - } - - so3_parameters.L0 = s2let_L0(j, parameters); + so3_parameters.L0 = s2let_L0(j, parameters); - so3_adjoint_forward_direct_real( - f_wav + offset, - f_wav_lmn + offset_lmn, - &so3_parameters - ); - offset_lmn += so3_sampling_flmn_size(&so3_parameters); - offset += so3_sampling_f_size(&so3_parameters); - } + so3_adjoint_forward_direct_real( + f_wav + offset, f_wav_lmn + offset_lmn, &so3_parameters); + offset_lmn += so3_sampling_flmn_size(&so3_parameters); + offset += so3_sampling_f_size(&so3_parameters); + } - free(wav_lm); - free(scal_l); - free(f_scal_lm); - free(f_wav_lmn); + free(wav_lm); + free(scal_l); + free(f_scal_lm); + free(f_wav_lmn); } /*! @@ -505,31 +466,29 @@ void s2let_synthesis_adjoint_px2wav( complex double *f_wav, complex double *f_scal, const complex double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L, i; - int spin = parameters->spin; - ssht_dl_method_t dl_method = parameters->dl_method; - int verbosity = parameters->verbosity; - - complex double *flm; - s2let_allocate_lm(&flm, L); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_inverse_sov_sym(flm, f, L, spin, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_inverse_sov_sym_ss(flm, f, L, spin, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - s2let_synthesis_adjoint_lm2wav(f_wav, f_scal, flm, parameters); - - free(flm); + const s2let_parameters_t *parameters) { + int L = parameters->L, i; + int spin = parameters->spin; + ssht_dl_method_t dl_method = parameters->dl_method; + int verbosity = parameters->verbosity; + + complex double *flm; + s2let_allocate_lm(&flm, L); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_inverse_sov_sym(flm, f, L, spin, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_inverse_sov_sym_ss(flm, f, L, spin, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + s2let_synthesis_adjoint_lm2wav(f_wav, f_scal, flm, parameters); + + free(flm); } /*! @@ -548,28 +507,26 @@ void s2let_synthesis_adjoint_px2wav_real( double *f_wav, double *f_scal, const double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - ssht_dl_method_t dl_method = parameters->dl_method; - int verbosity = 0; - - complex double *flm; - s2let_allocate_lm(&flm, L); - - switch (parameters->sampling_scheme) - { - case S2LET_SAMPLING_MW: - ssht_adjoint_mw_inverse_sov_sym_real(flm, f, L, dl_method, verbosity); - break; - case S2LET_SAMPLING_MW_SS: - ssht_adjoint_mw_inverse_sov_sym_ss_real(flm, f, L, dl_method, verbosity); - break; - default: - S2LET_ERROR_GENERIC("Sampling scheme not supported."); - } - - s2let_synthesis_adjoint_lm2wav_real(f_wav, f_scal, flm, parameters); - - free(flm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + ssht_dl_method_t dl_method = parameters->dl_method; + int verbosity = 0; + + complex double *flm; + s2let_allocate_lm(&flm, L); + + switch (parameters->sampling_scheme) { + case S2LET_SAMPLING_MW: + ssht_adjoint_mw_inverse_sov_sym_real(flm, f, L, dl_method, verbosity); + break; + case S2LET_SAMPLING_MW_SS: + ssht_adjoint_mw_inverse_sov_sym_ss_real(flm, f, L, dl_method, verbosity); + break; + default: + S2LET_ERROR_GENERIC("Sampling scheme not supported."); + } + + s2let_synthesis_adjoint_lm2wav_real(f_wav, f_scal, flm, parameters); + + free(flm); } diff --git a/src/main/c/s2let_tiling.c b/src/main/c/s2let_tiling.c index 322f0257..31b589e4 100644 --- a/src/main/c/s2let_tiling.c +++ b/src/main/c/s2let_tiling.c @@ -2,14 +2,15 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include -#include #include +#include + +#include "s2let.h" // // -typedef enum { S2DW, NEEDLET, SPLINE } s2let_kernel_type ; +typedef enum { S2DW, NEEDLET, SPLINE } s2let_kernel_type; s2let_kernel_type s2let_kernel = S2DW; // // @@ -17,25 +18,24 @@ s2let_kernel_type s2let_kernel = S2DW; /*! * Switch to different wavelet type. * - * \param[in] typenum Integer: 1 for scale-discretised, 2 for needlets and 3 for spline wavelets. - * \retval none + * \param[in] typenum Integer: 1 for scale-discretised, 2 for needlets and 3 for spline + * wavelets. \retval none */ -void s2let_switch_wavtype(int typenum) -{ - //printf("Input wavelet type : %i\n",typenum); - if (typenum == 1){ - //printf("Kernel switch 1: using scale-discretised wavelets.\n"); - s2let_kernel = S2DW; - } else if (typenum == 2){ - //printf("Kernel switch 2: using needlets.\n"); - s2let_kernel = NEEDLET; - } else if (typenum == 3){ - //printf("Kernel switch 3: using cubic splines wavelets.\n"); - s2let_kernel = SPLINE; - } else { - printf("Kernel number should be 1, 2 or 3. Default is 1.\n"); - s2let_kernel = S2DW; - } +void s2let_switch_wavtype(int typenum) { + // printf("Input wavelet type : %i\n",typenum); + if (typenum == 1) { + // printf("Kernel switch 1: using scale-discretised wavelets.\n"); + s2let_kernel = S2DW; + } else if (typenum == 2) { + // printf("Kernel switch 2: using needlets.\n"); + s2let_kernel = NEEDLET; + } else if (typenum == 3) { + // printf("Kernel switch 3: using cubic splines wavelets.\n"); + s2let_kernel = SPLINE; + } else { + printf("Kernel number should be 1, 2 or 3. Default is 1.\n"); + s2let_kernel = S2DW; + } } /*! @@ -48,27 +48,26 @@ void s2let_switch_wavtype(int typenum) * \link s2let_parameters_t::J_min J_min\endlink * \retval band-limit */ -int s2let_bandlimit(int j, const s2let_parameters_t *parameters) -{ - double B = parameters->B; - int L = parameters->L; - // int J_min = parameters->J_min; - - int Jmax; - switch (s2let_kernel) - { - case S2DW: - case NEEDLET: - return ceil(pow(B, j+1)); - case SPLINE: - Jmax = s2let_j_max(parameters); - if (j == Jmax) return L; - //if (j < J_min) return ceil(L / (double) pow(B, Jmax-J_min-1)); - return ceil(L / pow(B, Jmax-j-2)); - default: - // This should never happen - return -1; - } +int s2let_bandlimit(int j, const s2let_parameters_t *parameters) { + double B = parameters->B; + int L = parameters->L; + // int J_min = parameters->J_min; + + int Jmax; + switch (s2let_kernel) { + case S2DW: + case NEEDLET: + return ceil(pow(B, j + 1)); + case SPLINE: + Jmax = s2let_j_max(parameters); + if (j == Jmax) + return L; + // if (j < J_min) return ceil(L / (double) pow(B, Jmax-J_min-1)); + return ceil(L / pow(B, Jmax - j - 2)); + default: + // This should never happen + return -1; + } } /*! @@ -80,21 +79,19 @@ int s2let_bandlimit(int j, const s2let_parameters_t *parameters) * \link s2let_parameters_t::B B\endlink * \retval el_min */ -int s2let_L0(int j, const s2let_parameters_t *parameters) -{ - double B = parameters->B; - - switch (s2let_kernel) - { - case S2DW: - case NEEDLET: - return ceil(pow(B, j-1)); - case SPLINE: - return 0; - default: - // This should never happen - return -1; - } +int s2let_L0(int j, const s2let_parameters_t *parameters) { + double B = parameters->B; + + switch (s2let_kernel) { + case S2DW: + case NEEDLET: + return ceil(pow(B, j - 1)); + case SPLINE: + return 0; + default: + // This should never happen + return -1; + } } /*! @@ -105,8 +102,7 @@ int s2let_L0(int j, const s2let_parameters_t *parameters) * \link s2let_parameters_t::L L\endlink * \retval j_max */ -int s2let_j_max(const s2let_parameters_t *parameters) -{ +int s2let_j_max(const s2let_parameters_t *parameters) { double B = parameters->B; int L = parameters->L; @@ -123,84 +119,83 @@ int s2let_j_max(const s2let_parameters_t *parameters) * \link s2let_parameters_t::L L\endlink * \retval none */ -void s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters) -{ - int L = parameters->L; +void s2let_tiling_axisym_allocate( + double **kappa, double **kappa0, const s2let_parameters_t *parameters) { + int L = parameters->L; - int J = s2let_j_max(parameters); - *kappa = calloc((J+1) * L, sizeof **kappa); - *kappa0 = calloc(L, sizeof **kappa0); + int J = s2let_j_max(parameters); + *kappa = calloc((J + 1) * L, sizeof **kappa); + *kappa0 = calloc(L, sizeof **kappa0); } -void s2let_tiling_phi2_s2dw(double *phi2, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - double B = parameters->B; - - int j, l; - int J = s2let_j_max(parameters); - int n = 300; - - double kappanorm = s2let_math_kappa0_quadtrap_s2dw(1.0 / B, 1.0, n, B); - for (j = 0; j <= J+1; j++){ - for (l = 0; l < L; l++){ - if (l < pow(B,j-1)) { - phi2[l+j*L] = 1; - } else if (l > pow(B,j)) { - phi2[l+j*L] = 0; - } else { - phi2[l+j*L] = s2let_math_kappa0_quadtrap_s2dw((double)l / pow(B, j), 1.0, n, B) / kappanorm; - } - } +void s2let_tiling_phi2_s2dw(double *phi2, const s2let_parameters_t *parameters) { + int L = parameters->L; + double B = parameters->B; + + int j, l; + int J = s2let_j_max(parameters); + int n = 300; + + double kappanorm = s2let_math_kappa0_quadtrap_s2dw(1.0 / B, 1.0, n, B); + for (j = 0; j <= J + 1; j++) { + for (l = 0; l < L; l++) { + if (l < pow(B, j - 1)) { + phi2[l + j * L] = 1; + } else if (l > pow(B, j)) { + phi2[l + j * L] = 0; + } else { + phi2[l + j * L] = + s2let_math_kappa0_quadtrap_s2dw((double)l / pow(B, j), 1.0, n, B) / + kappanorm; + } } + } } -void s2let_tiling_phi2_needlet(double *phi2, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - double B = parameters->B; - - int j, l; - int J = s2let_j_max(parameters); - int n = 300; - double u; - - double kappanorm = s2let_math_kappa0_quadtrap_needlet(-1.0, 1.0, n); - for (j = 0; j <= J+1; j++){ - for (l = 0; l < L; l++){ - if (l < pow(B,j-1)) { - phi2[l+j*L] = 1; - } else if (l > pow(B,j)) { - phi2[l+j*L] = 0; - } else { - u = 1.0 - 2.0 * B / (B - 1.0) * ( l * pow(B, -j) - 1.0 / B ); - phi2[l+j*L] = s2let_math_kappa0_quadtrap_needlet(-1.0, u, n) / kappanorm; - } - } +void s2let_tiling_phi2_needlet(double *phi2, const s2let_parameters_t *parameters) { + int L = parameters->L; + double B = parameters->B; + + int j, l; + int J = s2let_j_max(parameters); + int n = 300; + double u; + + double kappanorm = s2let_math_kappa0_quadtrap_needlet(-1.0, 1.0, n); + for (j = 0; j <= J + 1; j++) { + for (l = 0; l < L; l++) { + if (l < pow(B, j - 1)) { + phi2[l + j * L] = 1; + } else if (l > pow(B, j)) { + phi2[l + j * L] = 0; + } else { + u = 1.0 - 2.0 * B / (B - 1.0) * (l * pow(B, -j) - 1.0 / B); + phi2[l + j * L] = s2let_math_kappa0_quadtrap_needlet(-1.0, u, n) / kappanorm; + } } + } } -void s2let_tiling_phi2_spline(double *phi2, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - double B = parameters->B; +void s2let_tiling_phi2_spline(double *phi2, const s2let_parameters_t *parameters) { + int L = parameters->L; + double B = parameters->B; - int j = 0, l; - int J = s2let_j_max(parameters); - phi2[(J+1-j)*L] = 1.0; - for (l = 1; l < L; l++){ - phi2[l+(J+1-j)*L] = 1.0; - } - for (j = 1; j <= J+1; j++){ - double bl = (double) L / (double) pow(B, j-2); - phi2[(J+1-j)*L] = 1.0; - for (l = 1; l < L; l++){ - if (l > bl) - phi2[l+(J+1-j)*L] = 0.0; - else - phi2[l+(J+1-j)*L] = s2let_math_spline_scalingfct((double) l, bl); - } + int j = 0, l; + int J = s2let_j_max(parameters); + phi2[(J + 1 - j) * L] = 1.0; + for (l = 1; l < L; l++) { + phi2[l + (J + 1 - j) * L] = 1.0; + } + for (j = 1; j <= J + 1; j++) { + double bl = (double)L / (double)pow(B, j - 2); + phi2[(J + 1 - j) * L] = 1.0; + for (l = 1; l < L; l++) { + if (l > bl) + phi2[l + (J + 1 - j) * L] = 0.0; + else + phi2[l + (J + 1 - j) * L] = s2let_math_spline_scalingfct((double)l, bl); } + } } /*! @@ -214,41 +209,41 @@ void s2let_tiling_phi2_spline(double *phi2, const s2let_parameters_t *parameters * \link s2let_parameters_t::J_min J_min\endlink * \retval none */ -void s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - int J_min = parameters->J_min; +void s2let_tiling_axisym( + double *kappa, double *kappa0, const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int j, l; - int J = s2let_j_max(parameters); + int j, l; + int J = s2let_j_max(parameters); - double previoustemp = 0.0, temp; - double *phi2 = (double*)calloc((J+2) * L, sizeof(double)); + double previoustemp = 0.0, temp; + double *phi2 = (double *)calloc((J + 2) * L, sizeof(double)); - if(s2let_kernel == SPLINE) - s2let_tiling_phi2_spline(phi2, parameters); // SPLINE tiling - if(s2let_kernel == S2DW) - s2let_tiling_phi2_s2dw(phi2, parameters); // S2DW tiling - if(s2let_kernel == NEEDLET) - s2let_tiling_phi2_needlet(phi2, parameters); // Needlet tiling + if (s2let_kernel == SPLINE) + s2let_tiling_phi2_spline(phi2, parameters); // SPLINE tiling + if (s2let_kernel == S2DW) + s2let_tiling_phi2_s2dw(phi2, parameters); // S2DW tiling + if (s2let_kernel == NEEDLET) + s2let_tiling_phi2_needlet(phi2, parameters); // Needlet tiling - for (l = 0; l < L; l++) - kappa0[l] = sqrt(phi2[l+J_min*L]); - - for (j = J_min; j <= J; j++){ - for (l = 0; l < L; l++){ - temp = sqrt(phi2[l+(j+1)*L] - phi2[l+j*L]); - if( isnan(temp) || isinf(temp) ) - kappa[l+j*L] = previoustemp; - else - kappa[l+j*L] = temp; - previoustemp = temp; - } - for (l = 0; l < L; l++) - if( !isfinite(kappa[l+j*L]) ) - kappa[l+j*L] = kappa[l+j*L-1]; + for (l = 0; l < L; l++) + kappa0[l] = sqrt(phi2[l + J_min * L]); + + for (j = J_min; j <= J; j++) { + for (l = 0; l < L; l++) { + temp = sqrt(phi2[l + (j + 1) * L] - phi2[l + j * L]); + if (isnan(temp) || isinf(temp)) + kappa[l + j * L] = previoustemp; + else + kappa[l + j * L] = temp; + previoustemp = temp; } - free(phi2); + for (l = 0; l < L; l++) + if (!isfinite(kappa[l + j * L])) + kappa[l + j * L] = kappa[l + j * L - 1]; + } + free(phi2); } /*! @@ -262,11 +257,11 @@ void s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t * \link s2let_parameters_t::N N\endlink * \retval none */ -void s2let_tiling_direction_allocate(complex double **s_elm, const s2let_parameters_t *parameters) -{ +void s2let_tiling_direction_allocate( + complex double **s_elm, const s2let_parameters_t *parameters) { int L = parameters->L; // TODO: This could be reduced by not storing s_elm with |m| >= N - *s_elm = calloc(L*L, sizeof **s_elm); + *s_elm = calloc(L * L, sizeof **s_elm); } /*! @@ -283,44 +278,44 @@ void s2let_tiling_direction_allocate(complex double **s_elm, const s2let_paramet * \link s2let_parameters_t::spin spin\endlink * */ -void s2let_tiling_direction(complex double *s_elm, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - int N = parameters->N; +void s2let_tiling_direction( + complex double *s_elm, const s2let_parameters_t *parameters) { + int L = parameters->L; + int N = parameters->N; + + // TODO: Add spin parameter to avoid computation of el < |s| + complex double nu; + int el, m, ind; - // TODO: Add spin parameter to avoid computation of el < |s| - complex double nu; - int el, m, ind; + if (N % 2) + nu = 1; + else + nu = I; - if (N % 2) - nu = 1; + // Skip the s_00 component, as it is zero. + ind = 1; + + for (el = 1; el < L; ++el) { + int gamma; + // This if else replaces the -1^(N+l) + if ((N + el) % 2) + gamma = MIN(N - 1, el); else - nu = I; - - // Skip the s_00 component, as it is zero. - ind = 1; - - for (el = 1; el < L; ++el) - { - int gamma; - // This if else replaces the -1^(N+l) - if ((N+el) % 2) - gamma = MIN(N-1, el); - else - gamma = MIN(N-1, el-1); - - for (m = -el; m <= el; ++m) - { - // This if/else takes care of the azimuthal - // band-limit and replaces the beta factor. - if (ABS(m) < N && (N+m) % 2) - s_elm[ind] = nu*sqrt(binomial_coefficient(gamma, (gamma - m)/2UL, 1)/pow(2, gamma)); - else - s_elm[ind] = 0.0; - - ++ind; - } + gamma = MIN(N - 1, el - 1); + + for (m = -el; m <= el; ++m) { + // This if/else takes care of the azimuthal + // band-limit and replaces the beta factor. + if (ABS(m) < N && (N + m) % 2) + s_elm[ind] = + nu * + sqrt(binomial_coefficient(gamma, (gamma - m) / 2UL, 1) / pow(2, gamma)); + else + s_elm[ind] = 0.0; + + ++ind; } + } } /*! @@ -336,14 +331,14 @@ void s2let_tiling_direction(complex double *s_elm, const s2let_parameters_t *par * \link s2let_parameters_t::N N\endlink * \retval none */ -void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - - // TODO: This could be reduced by not storing psi_j_elm with |m| >= N - int J = s2let_j_max(parameters); - *psi = calloc((J+1) * L*L, sizeof **psi); - *phi = calloc(L, sizeof **phi); +void s2let_tiling_wavelet_allocate( + complex double **psi, double **phi, const s2let_parameters_t *parameters) { + int L = parameters->L; + + // TODO: This could be reduced by not storing psi_j_elm with |m| >= N + int J = s2let_j_max(parameters); + *psi = calloc((J + 1) * L * L, sizeof **psi); + *phi = calloc(L, sizeof **phi); } /*! @@ -353,20 +348,18 @@ void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2l * \param[in] el Harmonic index el. * \param[in] spin Spin number the wavelet was lowered from. */ -static double s2let_spin_normalization(int el, int spin) -{ - double factor = 1; - int s; - - for (s = -ABS(spin)+1; s <= ABS(spin); ++s) - { - factor *= el+s; - } - - if (spin > 0) - return sqrt(factor); - else - return sqrt(1.0/factor); +static double s2let_spin_normalization(int el, int spin) { + double factor = 1; + int s; + + for (s = -ABS(spin) + 1; s <= ABS(spin); ++s) { + factor *= el + s; + } + + if (spin > 0) + return sqrt(factor); + else + return sqrt(1.0 / factor); } /*! @@ -385,55 +378,54 @@ static double s2let_spin_normalization(int el, int spin) * \link s2let_parameters_t::original_spin original_spin\endlink * */ -void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters) { - int L = parameters->L; - int J_min = parameters->J_min; - int spin = parameters->spin; - int original_spin = parameters->original_spin; - - // TODO: Add spin parameter to avoid computation of el < |s| - // TODO: Correctly compute spin scaling functions - double *kappa; - double *kappa0; - complex double *s_elm; - int j, el, m, el_min; - int J = s2let_j_max(parameters); - - // TODO: Allocate kappa0 directly inside phi. For this, we should probably - // separate the allocation functions to do only one allocation per - // function. - s2let_tiling_axisym_allocate(&kappa, &kappa0, parameters); - s2let_tiling_axisym(kappa, kappa0, parameters); - s2let_tiling_direction_allocate(&s_elm, parameters); - s2let_tiling_direction(s_elm, parameters); - - el_min = MAX(ABS(spin), ABS(original_spin)); - - for (el = el_min; el < L; ++el) - { - phi[el] = sqrt((2*el+1)/(4.0*PI)) * kappa0[el]; +void s2let_tiling_wavelet( + complex double *psi, double *phi, const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + int spin = parameters->spin; + int original_spin = parameters->original_spin; + + // TODO: Add spin parameter to avoid computation of el < |s| + // TODO: Correctly compute spin scaling functions + double *kappa; + double *kappa0; + complex double *s_elm; + int j, el, m, el_min; + int J = s2let_j_max(parameters); + + // TODO: Allocate kappa0 directly inside phi. For this, we should probably + // separate the allocation functions to do only one allocation per + // function. + s2let_tiling_axisym_allocate(&kappa, &kappa0, parameters); + s2let_tiling_axisym(kappa, kappa0, parameters); + s2let_tiling_direction_allocate(&s_elm, parameters); + s2let_tiling_direction(s_elm, parameters); + + el_min = MAX(ABS(spin), ABS(original_spin)); + + for (el = el_min; el < L; ++el) { + phi[el] = sqrt((2 * el + 1) / (4.0 * PI)) * kappa0[el]; + if (original_spin != 0) + phi[el] *= s2let_spin_normalization(el, original_spin) * pow(-1, original_spin); + } + + for (j = J_min; j <= J; ++j) { + int ind = el_min * el_min; + for (el = el_min; el < L; ++el) { + for (m = -el; m <= el; ++m) { + psi[j * L * L + ind] = + sqrt((2 * el + 1) / (8.0 * PI * PI)) * kappa[j * L + el] * s_elm[ind]; if (original_spin != 0) - phi[el] *= s2let_spin_normalization(el, original_spin) * pow(-1, original_spin); + psi[j * L * L + ind] *= + s2let_spin_normalization(el, original_spin) * pow(-1, original_spin); + ++ind; + } } + } - for (j = J_min; j <= J; ++j) - { - int ind = el_min*el_min; - for (el = el_min; el < L; ++el) - { - for (m = -el; m <= el; ++m) - { - psi[j*L*L + ind] = sqrt((2*el+1)/(8.0*PI*PI)) * kappa[j*L + el] * s_elm[ind]; - if (original_spin != 0) - psi[j*L*L + ind] *= s2let_spin_normalization(el, original_spin) * pow(-1, original_spin); - ++ind; - } - } - } - - free(kappa); - free(kappa0); - free(s_elm); + free(kappa); + free(kappa0); + free(s_elm); } /*! @@ -449,31 +441,31 @@ void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_paramete * * \retval Achieved accuracy (should be lower than e-14). */ -double s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - - int l, j; - int J = s2let_j_max(parameters); - //int l_min = s2let_el_min(B, J_min); - double error = 0; +double s2let_tiling_axisym_check_identity( + double *kappa, double *kappa0, const s2let_parameters_t *parameters) { + int L = parameters->L; - double *ident; - ident = calloc(L, sizeof *ident); + int l, j; + int J = s2let_j_max(parameters); + // int l_min = s2let_el_min(B, J_min); + double error = 0; - for (l = 0; l < L; l++) - ident[l] = pow(kappa0[l], 2.0); + double *ident; + ident = calloc(L, sizeof *ident); - for (l = 0; l < L; l++) { - for (j = 0; j <= J; j++) { - ident[l] += pow(kappa[l+j*L], 2.0); - } + for (l = 0; l < L; l++) + ident[l] = pow(kappa0[l], 2.0); - error = MAX(error, fabs(ident[l] - 1.0)); + for (l = 0; l < L; l++) { + for (j = 0; j <= J; j++) { + ident[l] += pow(kappa[l + j * L], 2.0); } - free(ident); - return error; + error = MAX(error, fabs(ident[l] - 1.0)); + } + + free(ident); + return error; } /*! @@ -487,29 +479,27 @@ double s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s * \link s2let_parameters_t::N N\endlink * \retval Achieved accuracy (should be lower than e-14). */ -double s2let_tiling_direction_check_identity(complex double *s_elm, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - - int el, m, ind; - double error = 0.0; // maximum error for all el - - // Skip the s_00 component, as it is zero. - ind = 1; - - for (el = 1; el < L; ++el) - { - double sum = 0.0; // sum for each el - for (m = -el; m <= el; ++m) - { - sum += s_elm[ind] * conj(s_elm[ind]); - ++ind; - } - - error = MAX(error, fabs(sum - 1.0)); +double s2let_tiling_direction_check_identity( + complex double *s_elm, const s2let_parameters_t *parameters) { + int L = parameters->L; + + int el, m, ind; + double error = 0.0; // maximum error for all el + + // Skip the s_00 component, as it is zero. + ind = 1; + + for (el = 1; el < L; ++el) { + double sum = 0.0; // sum for each el + for (m = -el; m <= el; ++m) { + sum += s_elm[ind] * conj(s_elm[ind]); + ++ind; } - return error; + error = MAX(error, fabs(sum - 1.0)); + } + + return error; } /*! @@ -526,41 +516,36 @@ double s2let_tiling_direction_check_identity(complex double *s_elm, const s2let_ * \link s2let_parameters_t::spin spin\endlink * \retval Achieved accuracy (should be lower than e-14). */ -double s2let_tiling_wavelet_check_identity(complex double *psi, double *phi, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - int spin = parameters->spin; - - int j, el, m, ind; - int J = s2let_j_max(parameters); - double error = 0.0; // maximum error for all el - - double *ident; - ident = calloc(L, sizeof *ident); - - for (el = ABS(spin); el < L; ++el) - { - ident[el] += 4.0*PI/(2*el+1) * phi[el] * phi[el]; - } - - for (j = 0; j <= J; ++j) - { - ind = spin*spin; - for (el = ABS(spin); el < L; ++el) - { - for (m = -el; m <= el; ++m) - { - ident[el] += 8.0*PI*PI/(2*el+1) * - psi[j*L*L + ind] * conj(psi[j*L*L + ind]); - ++ind; - } - } +double s2let_tiling_wavelet_check_identity( + complex double *psi, double *phi, const s2let_parameters_t *parameters) { + int L = parameters->L; + int spin = parameters->spin; + + int j, el, m, ind; + int J = s2let_j_max(parameters); + double error = 0.0; // maximum error for all el + + double *ident; + ident = calloc(L, sizeof *ident); + + for (el = ABS(spin); el < L; ++el) { + ident[el] += 4.0 * PI / (2 * el + 1) * phi[el] * phi[el]; + } + + for (j = 0; j <= J; ++j) { + ind = spin * spin; + for (el = ABS(spin); el < L; ++el) { + for (m = -el; m <= el; ++m) { + ident[el] += 8.0 * PI * PI / (2 * el + 1) * psi[j * L * L + ind] * + conj(psi[j * L * L + ind]); + ++ind; + } } + } - for (el = ABS(spin); el < L; ++el) - { - error = MAX(error, fabs(ident[el] - 1.0)); - } + for (el = ABS(spin); el < L; ++el) { + error = MAX(error, fabs(ident[el] - 1.0)); + } - return error; + return error; } diff --git a/src/main/c/s2let_transform_axisym_analysis_hpx_real.c b/src/main/c/s2let_transform_axisym_analysis_hpx_real.c index 27ccaaf8..7ef0f177 100644 --- a/src/main/c/s2let_transform_axisym_analysis_hpx_real.c +++ b/src/main/c/s2let_transform_axisym_analysis_hpx_real.c @@ -2,15 +2,16 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include #include +#include #include #include #include -#include #include +#include "s2let.h" + /*! * PROGRAM : s2let_transform_axisym_hpx_analysis_real * COMMAND : bin/s2let_transform_axisym_hpx_analysis_real file B J_min L @@ -21,8 +22,7 @@ * - L : bandlimit for the decomposition * OUTPUT : fits files containing the wavelet healpix maps */ -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { printf("--------------------------------------------------\n"); printf("S2LET library : axisymmetric wavelet transform\n"); printf("Real signal, HEALPIX sampling\n"); @@ -31,9 +31,9 @@ int main(int argc, char *argv[]) char file[100]; if (sscanf(argv[1], "%s", file) != 1) exit(-2); - printf("Input HEALPIX map : %s\n",file); + printf("Input HEALPIX map : %s\n", file); const int nside = s2let_fits_hpx_read_nside(file); - printf("- Detected bandlimit nside = %i\n",nside); + printf("- Detected bandlimit nside = %i\n", nside); int L, J_min; double B; if (sscanf(argv[2], "%i", &B) != 1) @@ -56,11 +56,12 @@ int main(int argc, char *argv[]) printf("- First wavelet scale to be used : %i\n", J_min); // Read MW map from file - double *f = (double*)calloc(12*nside*nside, sizeof(double)); + double *f = (double *)calloc(12 * nside * nside, sizeof(double)); s2let_hpx_read_map(f, file, nside); printf("File successfully read from file\n"); - printf("Performing wavelet decomposition...");fflush(NULL); + printf("Performing wavelet decomposition..."); + fflush(NULL); double *f_wav, *f_scal; s2let_transform_axisym_allocate_hpx_f_wav_real(&f_wav, &f_scal, nside, ¶meters); s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, nside, ¶meters); @@ -71,27 +72,26 @@ int main(int argc, char *argv[]) char outfile[100]; char params[100]; sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min); - int j; // Explicitly compute the maximum wavelet scale + int j; // Explicitly compute the maximum wavelet scale int offset = 0; // Start with the first wavelet char fileroot[100]; sscanf(file, "%[^.]", fileroot); - printf("File root = %s\n",fileroot); - for(j = J_min; j <= J; j++){ + printf("File root = %s\n", fileroot); + for (j = J_min; j <= J; j++) { sprintf(outfile, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits"); - printf("- Outfile_wav[j=%i] = %s\n",j,outfile); + printf("- Outfile_wav[j=%i] = %s\n", j, outfile); remove(outfile); // In case the file exists - s2let_hpx_write_map(outfile, f_wav + offset, nside); // Now write the map to fits file - offset += 12*nside*nside; // Go to the next wavelet + s2let_hpx_write_map( + outfile, f_wav + offset, nside); // Now write the map to fits file + offset += 12 * nside * nside; // Go to the next wavelet } // Finally write the scaling function sprintf(outfile, "%s%s%s%s", fileroot, "_scal_", params, ".fits"); - printf("- Outfile_scal = %s\n",outfile); - remove(outfile); // In case the file exists + printf("- Outfile_scal = %s\n", outfile); + remove(outfile); // In case the file exists s2let_hpx_write_map(outfile, f_scal, nside); // Now write the map to fits file printf("--------------------------------------------------\n"); return 0; } - - diff --git a/src/main/c/s2let_transform_axisym_analysis_mw_real.c b/src/main/c/s2let_transform_axisym_analysis_mw_real.c index 9c4cf944..bfd08fdd 100644 --- a/src/main/c/s2let_transform_axisym_analysis_mw_real.c +++ b/src/main/c/s2let_transform_axisym_analysis_mw_real.c @@ -2,15 +2,16 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include #include +#include #include #include #include -#include #include +#include "s2let.h" + /*! * PROGRAM : s2let_transform_axisym_mw_analysis_real * COMMAND : bin/s2let_transform_axisym_mw_analysis_real file B J_min multires @@ -21,8 +22,7 @@ * - multires : multiresolution flag (1: activated, 0: off) * OUTPUT : fits files containing the wavelet MW maps */ -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { printf("--------------------------------------------------\n"); printf("S2LET library : axisymmetric wavelet transform\n"); printf("Real signal, MW sampling\n"); @@ -31,9 +31,9 @@ int main(int argc, char *argv[]) char file[100]; if (sscanf(argv[1], "%s", file) != 1) exit(-2); - printf("Input MW map : %s\n",file); + printf("Input MW map : %s\n", file); const int L = s2let_fits_mw_read_bandlimit(file); - printf("- Detected bandlimit L = %i\n",L); + printf("- Detected bandlimit L = %i\n", L); int B, J_min, multires; if (sscanf(argv[2], "%i", &B) != 1) exit(-2); @@ -56,16 +56,18 @@ int main(int argc, char *argv[]) printf("- First wavelet scale to be used : %i\n", J_min); // Read MW map from file - double *f = (double*)calloc(L * (2 * L - 1), sizeof(double)); + double *f = (double *)calloc(L * (2 * L - 1), sizeof(double)); s2let_fits_mw_read_map(f, file, L); printf("File successfully read from file\n"); - printf("Performing wavelet decomposition...");fflush(NULL); + printf("Performing wavelet decomposition..."); + fflush(NULL); double *f_wav, *f_scal; - if(multires){ - s2let_transform_axisym_allocate_mw_f_wav_multires_real(&f_wav, &f_scal, ¶meters); + if (multires) { + s2let_transform_axisym_allocate_mw_f_wav_multires_real( + &f_wav, &f_scal, ¶meters); s2let_transform_axisym_wav_analysis_mw_multires_real(f_wav, f_scal, f, ¶meters); - }else{ + } else { s2let_transform_axisym_allocate_mw_f_wav_real(&f_wav, &f_scal, ¶meters); s2let_transform_axisym_wav_analysis_mw_real(f_wav, f_scal, f, ¶meters); } @@ -76,28 +78,29 @@ int main(int argc, char *argv[]) char outfile[100]; char params[100]; sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min); - int j, bl; // Explicitly compute the maximum wavelet scale + int j, bl; // Explicitly compute the maximum wavelet scale int offset = 0; // Start with the first wavelet char fileroot[100]; sscanf(file, "%[^.]", fileroot); - printf("File root = %s\n",fileroot); - for(j = J_min; j <= J; j++){ + printf("File root = %s\n", fileroot); + for (j = J_min; j <= J; j++) { sprintf(outfile, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits"); - printf("- Outfile_wav[j=%i] = %s\n",j,outfile); + printf("- Outfile_wav[j=%i] = %s\n", j, outfile); remove(outfile); // In case the file exists - if(multires) + if (multires) bl = MIN(s2let_bandlimit(j, ¶meters), L); else bl = L; - s2let_fits_mw_write_map(outfile, f_wav + offset, bl); // Now write the map to fits file - offset += (2*bl-1) * bl; // Go to the next wavelet + s2let_fits_mw_write_map( + outfile, f_wav + offset, bl); // Now write the map to fits file + offset += (2 * bl - 1) * bl; // Go to the next wavelet } // Finally write the scaling function sprintf(outfile, "%s%s%s%s", fileroot, "_scal_", params, ".fits"); - printf("- Outfile_scal = %s\n",outfile); + printf("- Outfile_scal = %s\n", outfile); remove(outfile); // In case the file exists - if(multires) - bl = MIN(s2let_bandlimit(J_min-1, ¶meters), L); + if (multires) + bl = MIN(s2let_bandlimit(J_min - 1, ¶meters), L); else bl = L; s2let_fits_mw_write_map(outfile, f_scal, bl); // Now write the map to fits file @@ -106,5 +109,3 @@ int main(int argc, char *argv[]) return 0; } - - diff --git a/src/main/c/s2let_transform_axisym_hpx.c b/src/main/c/s2let_transform_axisym_hpx.c index fc716129..f58d91c2 100644 --- a/src/main/c/s2let_transform_axisym_hpx.c +++ b/src/main/c/s2let_transform_axisym_hpx.c @@ -2,21 +2,26 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include #include -void s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters) -{ +#include "s2let.h" + +void s2let_transform_axisym_allocate_hpx_f_wav_real( + double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters) { int J_min = parameters->J_min; int J = s2let_j_max(parameters); - *f_wav = (double*)calloc((J+1-J_min) * 12*nside*nside, sizeof(double)); - *f_scal = (double*)calloc(12*nside*nside, sizeof(double)); + *f_wav = (double *)calloc((J + 1 - J_min) * 12 * nside * nside, sizeof(double)); + *f_scal = (double *)calloc(12 * nside * nside, sizeof(double)); } -void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters) -{ +void s2let_transform_axisym_wav_analysis_hpx_real( + double *f_wav, + double *f_scal, + const double *f, + int nside, + const s2let_parameters_t *parameters) { int L = parameters->L; int J_min = parameters->J_min; @@ -28,19 +33,20 @@ void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); + flm = (complex double *)calloc(L * L, sizeof(complex double)); s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); s2let_hpx_map2alm_real(flm, f, nside, L); - s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + s2let_transform_axisym_lm_wav_analysis_multires( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); s2let_hpx_alm2map_real(f_scal, f_scal_lm, nside, bandlimit); offset = 0; offset_lm = 0; - for(j = J_min; j <= J; j++){ + for (j = J_min; j <= J; j++) { bandlimit = MIN(s2let_bandlimit(j, parameters), L); s2let_hpx_alm2map_real(f_wav + offset, f_wav_lm + offset_lm, nside, bandlimit); offset_lm += bandlimit * bandlimit; @@ -52,8 +58,12 @@ void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, free(f_wav_lm); } -void s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters) -{ +void s2let_transform_axisym_wav_synthesis_hpx_real( + double *f, + const double *f_wav, + const double *f_scal, + int nside, + const s2let_parameters_t *parameters) { int L = parameters->L; int J_min = parameters->J_min; @@ -65,21 +75,22 @@ void s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wa s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); + flm = (complex double *)calloc(L * L, sizeof(complex double)); s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); s2let_hpx_map2alm_real(f_scal_lm, f_scal, nside, bandlimit); offset = 0; offset_lm = 0; - for(j = J_min; j <= J; j++){ + for (j = J_min; j <= J; j++) { bandlimit = MIN(s2let_bandlimit(j, parameters), L); s2let_hpx_map2alm_real(f_wav_lm + offset_lm, f_wav + offset, nside, bandlimit); offset_lm += bandlimit * bandlimit; offset += 12 * nside * nside; } - s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + s2let_transform_axisym_lm_wav_synthesis_multires( + flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); s2let_hpx_alm2map_real(f, flm, nside, L); diff --git a/src/main/c/s2let_transform_axisym_lm.c b/src/main/c/s2let_transform_axisym_lm.c index 2c61916c..69067e8d 100644 --- a/src/main/c/s2let_transform_axisym_lm.c +++ b/src/main/c/s2let_transform_axisym_lm.c @@ -2,15 +2,13 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include #include #include -static inline int lm2ind(int el, int m) -{ - return el*el + el + m; -} +#include "s2let.h" + +static inline int lm2ind(int el, int m) { return el * el + el + m; } /*! * Allocates arrays for wavelet transform in harmonic space. @@ -27,44 +25,39 @@ static inline int lm2ind(int el, int m) void s2let_transform_axisym_lm_allocate_f_wav( complex double **f_wav_lm, complex double **f_scal_lm, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int J = s2let_j_max(parameters); - *f_wav_lm = calloc((J+1-J_min) * L * L, sizeof **f_wav_lm); - *f_scal_lm = calloc(L * L, sizeof **f_scal_lm); + int J = s2let_j_max(parameters); + *f_wav_lm = calloc((J + 1 - J_min) * L * L, sizeof **f_wav_lm); + *f_scal_lm = calloc(L * L, sizeof **f_scal_lm); } /*! * Allocates multiresolution arrays for wavelet transforms in harmonic space. * - * \param[out] f_wav_lm Harmonic coefficients of the wavelet contributions. The size of each wavelet depends on its band-limit. - * \param[out] f_scal_lm Harmonic coefficients of the scaling contribution. - * \param[in] B Wavelet parameter. - * \param[in] L Angular harmonic band-limit. - * \param[in] J_min First wavelet scale to be used. - * \retval none + * \param[out] f_wav_lm Harmonic coefficients of the wavelet contributions. The size of + * each wavelet depends on its band-limit. \param[out] f_scal_lm Harmonic coefficients + * of the scaling contribution. \param[in] B Wavelet parameter. \param[in] L Angular + * harmonic band-limit. \param[in] J_min First wavelet scale to be used. \retval none */ void s2let_transform_axisym_lm_allocate_f_wav_multires( complex double **f_wav_lm, complex double **f_scal_lm, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int J = s2let_j_max(parameters); - int j, bandlimit, total = 0; - for (j = J_min; j <= J; ++j) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - total += bandlimit * bandlimit; - } - *f_wav_lm = calloc(total, sizeof **f_wav_lm); - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - *f_scal_lm = calloc(bandlimit * bandlimit, sizeof **f_scal_lm); + int J = s2let_j_max(parameters); + int j, bandlimit, total = 0; + for (j = J_min; j <= J; ++j) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + total += bandlimit * bandlimit; + } + *f_wav_lm = calloc(total, sizeof **f_wav_lm); + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + *f_scal_lm = calloc(bandlimit * bandlimit, sizeof **f_scal_lm); } /*! @@ -76,13 +69,13 @@ void s2let_transform_axisym_lm_allocate_f_wav_multires( * \param[in] L Angular harmonic band-limit. * \retval none */ -void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters) -{ - int L = parameters->L; +void s2let_transform_axisym_lm_allocate_wav( + double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters) { + int L = parameters->L; - int J = s2let_j_max(parameters); - *wav_lm = (double*)calloc((J+1) * L, sizeof(double)); - *scal_lm = (double*)calloc(L, sizeof(double)); + int J = s2let_j_max(parameters); + *wav_lm = (double *)calloc((J + 1) * L, sizeof(double)); + *scal_lm = (double *)calloc(L, sizeof(double)); } /*! @@ -95,46 +88,45 @@ void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, c * \param[in] J_min First wavelet scale to be used. * \retval none */ -void s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - int J_min = parameters->J_min; +void s2let_transform_axisym_lm_wav( + double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int j, l; - int J = s2let_j_max(parameters); - //int J_min = 0; - //int l_min = s2let_transform_axisym_el_min(B, J_min); - double k0; - double *kappa, *kappa0; - s2let_tiling_axisym_allocate(&kappa, &kappa0, parameters); - s2let_tiling_axisym(kappa, kappa0, parameters); + int j, l; + int J = s2let_j_max(parameters); + // int J_min = 0; + // int l_min = s2let_transform_axisym_el_min(B, J_min); + double k0; + double *kappa, *kappa0; + s2let_tiling_axisym_allocate(&kappa, &kappa0, parameters); + s2let_tiling_axisym(kappa, kappa0, parameters); - for (j = J_min; j <= J; j++){ - for (l = 0; l < L; l++){ - k0 = sqrt( (2 * l + 1) / (4.0 * PI) ) * kappa[l+j*L]; - wav_lm[j*L+l] = k0; - } - } - for (l = 0; l < L; l++){ - k0 = sqrt( (2 * l + 1) / (4.0 * PI) ) * kappa0[l]; - scal_lm[l] = k0; + for (j = J_min; j <= J; j++) { + for (l = 0; l < L; l++) { + k0 = sqrt((2 * l + 1) / (4.0 * PI)) * kappa[l + j * L]; + wav_lm[j * L + l] = k0; } + } + for (l = 0; l < L; l++) { + k0 = sqrt((2 * l + 1) / (4.0 * PI)) * kappa0[l]; + scal_lm[l] = k0; + } - free(kappa); - free(kappa0); + free(kappa); + free(kappa0); } /*! * Spherical wavelets : full resolution analysis in harmonic space. - * Perform wavelet transform from precomputed kernels and gives the harmonic coefficients. + * Perform wavelet transform from precomputed kernels and gives the harmonic + * coefficients. * - * \param[out] f_wav_lm Wavelet transform (harmonic coefficients of wavelet contribution). - * \param[out] f_scal_lm Wavelet transform (harmonic coefficients of scaling contribution). - * \param[in] flm Spherical harmonic decomposition of input function. - * \param[in] wav_lm Wavelet kernels. - * \param[in] scal_lm Scaling function kernels. - * \param[in] B Wavelet parameter. - * \param[in] L Angular harmonic band-limit. + * \param[out] f_wav_lm Wavelet transform (harmonic coefficients of wavelet + * contribution). \param[out] f_scal_lm Wavelet transform (harmonic coefficients of + * scaling contribution). \param[in] flm Spherical harmonic decomposition of input + * function. \param[in] wav_lm Wavelet kernels. \param[in] scal_lm Scaling function + * kernels. \param[in] B Wavelet parameter. \param[in] L Angular harmonic band-limit. * \param[in] J_min First wavelet scale to be used. * \retval none */ @@ -144,47 +136,44 @@ void s2let_transform_axisym_lm_wav_analysis( const complex double *flm, const double *wav_lm, const double *scal_lm, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int offset, j, l, m; - int J = s2let_j_max(parameters); - double wav0, scal0; - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int offset, j, l, m; + int J = s2let_j_max(parameters); + double wav0, scal0; + // int l_min = s2let_transform_axisym_el_min(B, J_min); - offset = 0; - for (j = J_min; j <= J; j++) { - for (l = 0; l < L; l++) { - wav0 = sqrt((4.0*PI)/(2.0*l+1.0)) * wav_lm[j*L+l]; - for (m = -l; m <= l; m++) { - f_wav_lm[offset + l*l + l + m] = flm[lm2ind(l,m)] * wav0 ; - } - } - offset += L * L; - } + offset = 0; + for (j = J_min; j <= J; j++) { for (l = 0; l < L; l++) { - scal0 = sqrt((4.0*PI)/(2.0*l+1.0)) * scal_lm[l]; - for (m = -l; m <= l; m++) { - f_scal_lm[lm2ind(l,m)] = flm[lm2ind(l,m)] * scal0 ; - } + wav0 = sqrt((4.0 * PI) / (2.0 * l + 1.0)) * wav_lm[j * L + l]; + for (m = -l; m <= l; m++) { + f_wav_lm[offset + l * l + l + m] = flm[lm2ind(l, m)] * wav0; + } } + offset += L * L; + } + for (l = 0; l < L; l++) { + scal0 = sqrt((4.0 * PI) / (2.0 * l + 1.0)) * scal_lm[l]; + for (m = -l; m <= l; m++) { + f_scal_lm[lm2ind(l, m)] = flm[lm2ind(l, m)] * scal0; + } + } } /*! * Spherical wavelets : full resolution synthesis in harmonic space. - * Perform wavelet transform in harmonic space from precomputed kernels and gives harmonic coefficients. + * Perform wavelet transform in harmonic space from precomputed kernels and gives + * harmonic coefficients. * * \param[out] flm Spherical harmonic decomposition of input function. - * \param[in] f_wav_lm Wavelet transform (harmonic coefficients of wavelet contribution). - * \param[in] f_scal_lm Wavelet transform (harmonic coefficients of scaling contribution). - * \param[in] wav_lm Wavelet kernels. - * \param[in] scal_lm Scaling function kernels. - * \param[in] B Wavelet parameter. - * \param[in] L Angular harmonic band-limit. - * \param[in] J_min First wavelet scale to be used. - * \retval none + * \param[in] f_wav_lm Wavelet transform (harmonic coefficients of wavelet + * contribution). \param[in] f_scal_lm Wavelet transform (harmonic coefficients of + * scaling contribution). \param[in] wav_lm Wavelet kernels. \param[in] scal_lm + * Scaling function kernels. \param[in] B Wavelet parameter. \param[in] L Angular + * harmonic band-limit. \param[in] J_min First wavelet scale to be used. \retval none */ void s2let_transform_axisym_lm_wav_synthesis( complex double *flm, @@ -192,37 +181,37 @@ void s2let_transform_axisym_lm_wav_synthesis( const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int offset, j, l, m; - int J = s2let_j_max(parameters); - double wav0, scal0; - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int offset, j, l, m; + int J = s2let_j_max(parameters); + double wav0, scal0; + // int l_min = s2let_transform_axisym_el_min(B, J_min); - offset = 0; - for (j = J_min; j <= J; j++) { - for (l = 0; l < L; l++) { - wav0 = sqrt((4.0*PI)/(2.0*l+1.0)) * wav_lm[j*L+l]; - for (m = -l; m <= l; m++) { - flm[lm2ind(l,m)] += f_wav_lm[offset + l*l + l + m] * wav0 ; - } - } - offset += L * L; - } + offset = 0; + for (j = J_min; j <= J; j++) { for (l = 0; l < L; l++) { - scal0 = sqrt((4.0*PI)/(2.0*l+1.0)) * scal_lm[l]; - for (m = -l; m <= l; m++) { - flm[lm2ind(l,m)] += f_scal_lm[lm2ind(l,m)] * scal0 ; - } + wav0 = sqrt((4.0 * PI) / (2.0 * l + 1.0)) * wav_lm[j * L + l]; + for (m = -l; m <= l; m++) { + flm[lm2ind(l, m)] += f_wav_lm[offset + l * l + l + m] * wav0; + } + } + offset += L * L; + } + for (l = 0; l < L; l++) { + scal0 = sqrt((4.0 * PI) / (2.0 * l + 1.0)) * scal_lm[l]; + for (m = -l; m <= l; m++) { + flm[lm2ind(l, m)] += f_scal_lm[lm2ind(l, m)] * scal0; } + } } /*! * Spherical wavelets : multiresolution analysis in harmonic space. - * Perform multiresolution wavelet transform in harmonic space from precomputed kernels and gives harmonic coefficients. + * Perform multiresolution wavelet transform in harmonic space from precomputed kernels + * and gives harmonic coefficients. * * \param[out] f_wav_lm Wavelet transform (SHA of wavelet contribution). * \param[out] f_scal_lm Wavelet transform (SHA of scaling contribution). @@ -240,38 +229,38 @@ void s2let_transform_axisym_lm_wav_analysis_multires( const complex double *flm, const double *wav_lm, const double *scal_lm, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int bandlimit, offset, j, l, m; - int J = s2let_j_max(parameters); - double wav0, scal0; + int bandlimit, offset, j, l, m; + int J = s2let_j_max(parameters); + double wav0, scal0; - offset = 0; - for (j = J_min; j <= J; j++){ - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - for (l = 0; l < bandlimit; l++){ - wav0 = sqrt((4.0*PI)/(2.0*l+1.0)) * wav_lm[j*L+l]; - for (m = -l; m <= l; m++){ - f_wav_lm[offset + l*l + l + m] = flm[lm2ind(l,m)] * wav0 ; - } - } - offset += bandlimit * bandlimit; + offset = 0; + for (j = J_min; j <= J; j++) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + for (l = 0; l < bandlimit; l++) { + wav0 = sqrt((4.0 * PI) / (2.0 * l + 1.0)) * wav_lm[j * L + l]; + for (m = -l; m <= l; m++) { + f_wav_lm[offset + l * l + l + m] = flm[lm2ind(l, m)] * wav0; + } } - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - for (l = 0; l < bandlimit; l++){ - scal0 = sqrt((4.0*PI)/(2.0*l+1.0)) * scal_lm[l]; - for (m = -l; m <= l; m++){ - f_scal_lm[lm2ind(l,m)] = flm[lm2ind(l,m)] * scal0 ; - } + offset += bandlimit * bandlimit; + } + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + for (l = 0; l < bandlimit; l++) { + scal0 = sqrt((4.0 * PI) / (2.0 * l + 1.0)) * scal_lm[l]; + for (m = -l; m <= l; m++) { + f_scal_lm[lm2ind(l, m)] = flm[lm2ind(l, m)] * scal0; } + } } /*! * Spherical wavelets : multiresolution synthesis in harmonic space. - * Perform multiresolution wavelet transform in harmonic space from precomputed kernels and gives harmonic coefficients. + * Perform multiresolution wavelet transform in harmonic space from precomputed kernels + * and gives harmonic coefficients. * * \param[out] flm Spherical harmonic decomposition of input function. * \param[in] f_wav_lm Wavelet transform (SHA of wavelet contribution). @@ -289,32 +278,31 @@ void s2let_transform_axisym_lm_wav_synthesis_multires( const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int bandlimit, offset, j, l, m; - int J = s2let_j_max(parameters); - double wav0, scal0; - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int bandlimit, offset, j, l, m; + int J = s2let_j_max(parameters); + double wav0, scal0; + // int l_min = s2let_transform_axisym_el_min(B, J_min); - offset = 0; - for (j = J_min; j <= J; j++){ - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - for (l = 0; l < bandlimit; l++){ - wav0 = sqrt((4.0*PI)/(2.0*l+1.0)) * wav_lm[j*L+l]; - for (m = -l; m <= l; m++){ - flm[lm2ind(l,m)] += f_wav_lm[offset + l*l + l + m] * wav0 ; - } - } - offset += bandlimit * bandlimit; + offset = 0; + for (j = J_min; j <= J; j++) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + for (l = 0; l < bandlimit; l++) { + wav0 = sqrt((4.0 * PI) / (2.0 * l + 1.0)) * wav_lm[j * L + l]; + for (m = -l; m <= l; m++) { + flm[lm2ind(l, m)] += f_wav_lm[offset + l * l + l + m] * wav0; + } } - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - for (l = 0; l < bandlimit; l++){ - scal0 = sqrt((4.0*PI)/(2.0*l+1.0)) * scal_lm[l]; - for (m = -l; m <= l; m++){ - flm[lm2ind(l,m)] += f_scal_lm[lm2ind(l,m)] * scal0 ; - } + offset += bandlimit * bandlimit; + } + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + for (l = 0; l < bandlimit; l++) { + scal0 = sqrt((4.0 * PI) / (2.0 * l + 1.0)) * scal_lm[l]; + for (m = -l; m <= l; m++) { + flm[lm2ind(l, m)] += f_scal_lm[lm2ind(l, m)] * scal0; } + } } diff --git a/src/main/c/s2let_transform_axisym_mw.c b/src/main/c/s2let_transform_axisym_mw.c index 9a352963..f3f8d701 100644 --- a/src/main/c/s2let_transform_axisym_mw.c +++ b/src/main/c/s2let_transform_axisym_mw.c @@ -2,14 +2,16 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" -#include #include +#include #include #include +#include "s2let.h" + /*! - * Allocates arrays for final wavelets and scaling functions in pixel space (MW sampling). + * Allocates arrays for final wavelets and scaling functions in pixel space (MW + * sampling). * * \param[out] f_wav Array of wavelets maps, MW sampling. * \param[out] f_scal Scaling function map, MW sampling. @@ -21,14 +23,13 @@ void s2let_transform_axisym_allocate_mw_f_wav( complex double **f_wav, complex double **f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int J = s2let_j_max(parameters); - *f_wav = calloc((J+1-J_min) * L *(2*L-1), sizeof **f_wav); - *f_scal = calloc(L * (2*L-1), sizeof **f_scal); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int J = s2let_j_max(parameters); + *f_wav = calloc((J + 1 - J_min) * L * (2 * L - 1), sizeof **f_wav); + *f_scal = calloc(L * (2 * L - 1), sizeof **f_scal); } /*! @@ -44,25 +45,24 @@ void s2let_transform_axisym_allocate_mw_f_wav( void s2let_transform_axisym_allocate_mw_f_wav_multires( complex double **f_wav, complex double **f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int J = s2let_j_max(parameters); - int j, bandlimit, total = 0; - for (j = J_min; j <= J; ++j) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - total += bandlimit * (2 * bandlimit - 1); - } - *f_wav = calloc(total, sizeof **f_wav); - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - *f_scal = calloc(bandlimit * (2*bandlimit-1), sizeof **f_scal); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int J = s2let_j_max(parameters); + int j, bandlimit, total = 0; + for (j = J_min; j <= J; ++j) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + total += bandlimit * (2 * bandlimit - 1); + } + *f_wav = calloc(total, sizeof **f_wav); + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + *f_scal = calloc(bandlimit * (2 * bandlimit - 1), sizeof **f_scal); } /*! - * Allocates arrays for final wavelets and scaling functions in pixel space (MW sampling). + * Allocates arrays for final wavelets and scaling functions in pixel space (MW + * sampling). * * \param[out] f_wav Array of wavelets maps, MW sampling. * \param[out] f_scal Scaling function map, MW sampling. @@ -71,18 +71,19 @@ void s2let_transform_axisym_allocate_mw_f_wav_multires( * \param[in] J_min First wavelet scale to be used. * \retval none */ -void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - int J_min = parameters->J_min; - - int J = s2let_j_max(parameters); - *f_wav = calloc((J+1-J_min) * L *(2*L-1), sizeof **f_wav); - *f_scal = calloc(L * (2*L-1), sizeof **f_scal); +void s2let_transform_axisym_allocate_mw_f_wav_real( + double **f_wav, double **f_scal, const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int J = s2let_j_max(parameters); + *f_wav = calloc((J + 1 - J_min) * L * (2 * L - 1), sizeof **f_wav); + *f_scal = calloc(L * (2 * L - 1), sizeof **f_scal); } /*! - * Allocates arrays for multiresolution wavelets and scaling functions in pixel space (MW sampling). + * Allocates arrays for multiresolution wavelets and scaling functions in pixel space + * (MW sampling). * * \param[out] f_wav Array of wavelets maps, MW sampling. * \param[out] f_scal Scaling function map, MW sampling. @@ -91,21 +92,20 @@ void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_sc * \param[in] J_min First wavelet scale to be used. * \retval none */ -void s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters) -{ - int L = parameters->L; - int J_min = parameters->J_min; - - int J = s2let_j_max(parameters); - int j, bandlimit, total = 0; - for (j = J_min; j <= J; ++j) - { - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - total += bandlimit * (2 * bandlimit - 1); - } - *f_wav = calloc(total, sizeof **f_wav); - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - *f_scal = calloc(bandlimit * (2*bandlimit-1), sizeof **f_scal); +void s2let_transform_axisym_allocate_mw_f_wav_multires_real( + double **f_wav, double **f_scal, const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int J = s2let_j_max(parameters); + int j, bandlimit, total = 0; + for (j = J_min; j <= J; ++j) { + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + total += bandlimit * (2 * bandlimit - 1); + } + *f_wav = calloc(total, sizeof **f_wav); + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + *f_scal = calloc(bandlimit * (2 * bandlimit - 1), sizeof **f_scal); } /*! @@ -125,52 +125,51 @@ void s2let_transform_axisym_wav_analysis_mw( complex double *f_wav, complex double *f_scal, const complex double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int spin = 0; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; + int spin = 0; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; - int j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); - ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity); + ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity); - s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + s2let_transform_axisym_lm_wav_analysis( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); - ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, L, spin, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for (j = J_min; j <= J; ++j) - { - int i; + ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, L, spin, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; ++j) { + int i; - ssht_core_mw_inverse_sov_sym(f_wav + offset, f_wav_lm + offset_lm, L, spin, dl_method, verbosity); + ssht_core_mw_inverse_sov_sym( + f_wav + offset, f_wav_lm + offset_lm, L, spin, dl_method, verbosity); - for (i = 0; i < L*(2*L-1); ++i) - { - f_wav[offset+i] /= sqrt(2*PI); - } - - offset_lm += L * L; - offset += L * (2 * L - 1); + for (i = 0; i < L * (2 * L - 1); ++i) { + f_wav[offset + i] /= sqrt(2 * PI); } - free(flm); - free(f_scal_lm); - free(f_wav_lm); + offset_lm += L * L; + offset += L * (2 * L - 1); + } + + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! @@ -190,53 +189,53 @@ void s2let_transform_axisym_wav_analysis_adjoint_mw( complex double *f, const complex double *f_wav, const complex double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int spin = 0; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; - - int j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); - - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - - complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); - - ssht_adjoint_mw_inverse_sov_sym(f_scal_lm, f_scal, L, spin, dl_method, verbosity); - offset = 0; - offset_lm = 0; - - f_wav_norm = malloc(L*(2*L-1) * sizeof *f_wav_norm); - for(j = J_min; j <= J; j++){ - int i; - - for (i = 0; i < L*(2*L-1); ++i) - { - f_wav_norm[i] = f_wav[offset+i] / sqrt(2*PI); - } - - ssht_adjoint_mw_inverse_sov_sym(f_wav_lm + offset_lm, f_wav_norm, L, spin, dl_method, verbosity); - offset_lm += L * L; - offset += L * (2 * L - 1); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int spin = 0; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; + + int j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); + + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + + ssht_adjoint_mw_inverse_sov_sym(f_scal_lm, f_scal, L, spin, dl_method, verbosity); + offset = 0; + offset_lm = 0; + + f_wav_norm = malloc(L * (2 * L - 1) * sizeof *f_wav_norm); + for (j = J_min; j <= J; j++) { + int i; + + for (i = 0; i < L * (2 * L - 1); ++i) { + f_wav_norm[i] = f_wav[offset + i] / sqrt(2 * PI); } - free(f_wav_norm); - s2let_transform_axisym_lm_wav_synthesis(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + ssht_adjoint_mw_inverse_sov_sym( + f_wav_lm + offset_lm, f_wav_norm, L, spin, dl_method, verbosity); + offset_lm += L * L; + offset += L * (2 * L - 1); + } + free(f_wav_norm); + + s2let_transform_axisym_lm_wav_synthesis( + flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); - ssht_adjoint_mw_forward_sov_sym(f, flm, L, spin, dl_method, verbosity); + ssht_adjoint_mw_forward_sov_sym(f, flm, L, spin, dl_method, verbosity); - free(flm); - free(f_scal_lm); - free(f_wav_lm); + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! @@ -256,56 +255,54 @@ void s2let_transform_axisym_wav_synthesis_mw( complex double *f, const complex double *f_wav, const complex double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int spin = 0; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; - - int j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); - - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - - complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); - - ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, L, spin, dl_method, verbosity); - offset = 0; - offset_lm = 0; - - f_wav_norm = malloc(L*(2*L-1) * sizeof *f_wav_norm); - for(j = J_min; j <= J; j++){ - int i; - - for (i = 0; i < L*(2*L-1); ++i) - { - f_wav_norm[i] = f_wav[offset+i] * sqrt(2*PI); - } - - ssht_core_mw_forward_sov_conv_sym(f_wav_lm + offset_lm, f_wav_norm, L, spin, dl_method, verbosity); - offset_lm += L * L; - offset += L * (2 * L - 1); - } - free(f_wav_norm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - s2let_transform_axisym_lm_wav_synthesis(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + int spin = 0; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; - ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity); + int j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); - free(flm); - free(f_scal_lm); - free(f_wav_lm); -} + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + + ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, L, spin, dl_method, verbosity); + offset = 0; + offset_lm = 0; + + f_wav_norm = malloc(L * (2 * L - 1) * sizeof *f_wav_norm); + for (j = J_min; j <= J; j++) { + int i; + + for (i = 0; i < L * (2 * L - 1); ++i) { + f_wav_norm[i] = f_wav[offset + i] * sqrt(2 * PI); + } + + ssht_core_mw_forward_sov_conv_sym( + f_wav_lm + offset_lm, f_wav_norm, L, spin, dl_method, verbosity); + offset_lm += L * L; + offset += L * (2 * L - 1); + } + free(f_wav_norm); + s2let_transform_axisym_lm_wav_synthesis( + flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity); + + free(flm); + free(f_scal_lm); + free(f_wav_lm); +} /*! * Spherical wavelets : full resolution synthesis in real space adjoint, MW sampling. @@ -324,59 +321,57 @@ void s2let_transform_axisym_wav_synthesis_adjoint_mw( complex double *f_wav, complex double *f_scal, const complex double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int spin = 0; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int spin = 0; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + int j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - ssht_adjoint_mw_inverse_sov_sym(flm, f, L, spin, dl_method, verbosity); + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); - s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + ssht_adjoint_mw_inverse_sov_sym(flm, f, L, spin, dl_method, verbosity); - ssht_adjoint_mw_forward_sov_sym(f_scal, f_scal_lm, L, spin, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for (j = J_min; j <= J; ++j) - { - int i; + s2let_transform_axisym_lm_wav_analysis( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); - ssht_adjoint_mw_forward_sov_sym(f_wav + offset, f_wav_lm + offset_lm, L, spin, dl_method, verbosity); + ssht_adjoint_mw_forward_sov_sym(f_scal, f_scal_lm, L, spin, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; ++j) { + int i; - for (i = 0; i < L*(2*L-1); ++i) - { - f_wav[offset+i] *= sqrt(2*PI); - } + ssht_adjoint_mw_forward_sov_sym( + f_wav + offset, f_wav_lm + offset_lm, L, spin, dl_method, verbosity); - offset_lm += L * L; - offset += L * (2 * L - 1); + for (i = 0; i < L * (2 * L - 1); ++i) { + f_wav[offset + i] *= sqrt(2 * PI); } - free(flm); - free(f_scal_lm); - free(f_wav_lm); -} + offset_lm += L * L; + offset += L * (2 * L - 1); + } + free(flm); + free(f_scal_lm); + free(f_wav_lm); +} /*! * Spherical wavelets : multiresolution analysis in real space, MW sampling. - * Perform multiresolution wavelet transform in real space (from scratch, gives wavelet maps). - * Sampling scheme : MW sampling. + * Perform multiresolution wavelet transform in real space (from scratch, gives wavelet + * maps). Sampling scheme : MW sampling. * * \param[out] f_wav Array of wavelets maps, MW sampling. * \param[out] f_scal Scaling function map, MW sampling. @@ -390,59 +385,60 @@ void s2let_transform_axisym_wav_analysis_mw_multires( complex double *f_wav, complex double *f_scal, const complex double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int spin = 0; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int bandlimit, j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int spin = 0; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + int bandlimit, j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity); + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); - s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity); - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, bandlimit, spin, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; + s2let_transform_axisym_lm_wav_analysis_multires( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - ssht_core_mw_inverse_sov_sym(f_wav + offset, f_wav_lm + offset_lm, bandlimit, spin, dl_method, verbosity); + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + ssht_core_mw_inverse_sov_sym( + f_scal, f_scal_lm, bandlimit, spin, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; - for (i = 0; i < bandlimit*(2*bandlimit-1); ++i) - { - f_wav[offset+i] /= sqrt(2*PI); - } + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + ssht_core_mw_inverse_sov_sym( + f_wav + offset, f_wav_lm + offset_lm, bandlimit, spin, dl_method, verbosity); - offset_lm += bandlimit * bandlimit; - offset += bandlimit * (2 * bandlimit - 1); + for (i = 0; i < bandlimit * (2 * bandlimit - 1); ++i) { + f_wav[offset + i] /= sqrt(2 * PI); } - free(flm); - free(f_scal_lm); - free(f_wav_lm); + offset_lm += bandlimit * bandlimit; + offset += bandlimit * (2 * bandlimit - 1); + } + + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! * Spherical wavelets : multiresolution analysis adjoint in real space, MW sampling. - * Perform multiresolution wavelet transform adjoint in real space (from scratch, gives wavelet maps). - * Sampling scheme : MW sampling. + * Perform multiresolution wavelet transform adjoint in real space (from scratch, gives + * wavelet maps). Sampling scheme : MW sampling. * * \param[out] f Input function (MW sampling) * \param[in] f_wav Array of wavelets maps, MW sampling. @@ -456,62 +452,63 @@ void s2let_transform_axisym_wav_analysis_adjoint_mw_multires( complex double *f, const complex double *f_wav, const complex double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int spin = 0; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; - - int bandlimit, j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); - - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - - complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); - - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - ssht_adjoint_mw_inverse_sov_sym(f_scal_lm, f_scal, bandlimit, spin, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - - f_wav_norm = malloc(bandlimit*(2*bandlimit-1) * sizeof *f_wav_norm); - - for (i = 0; i < bandlimit*(2*bandlimit-1); ++i) - { - f_wav_norm[i] = f_wav[offset+i] / sqrt(2*PI); - } - - ssht_adjoint_mw_inverse_sov_sym(f_wav_lm + offset_lm, f_wav_norm, bandlimit, spin, dl_method, verbosity); - offset_lm += bandlimit * bandlimit; - offset += bandlimit * (2 * bandlimit - 1); - - free(f_wav_norm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int spin = 0; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; + + int bandlimit, j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); + + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + ssht_adjoint_mw_inverse_sov_sym( + f_scal_lm, f_scal, bandlimit, spin, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + + f_wav_norm = malloc(bandlimit * (2 * bandlimit - 1) * sizeof *f_wav_norm); + + for (i = 0; i < bandlimit * (2 * bandlimit - 1); ++i) { + f_wav_norm[i] = f_wav[offset + i] / sqrt(2 * PI); } - s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + ssht_adjoint_mw_inverse_sov_sym( + f_wav_lm + offset_lm, f_wav_norm, bandlimit, spin, dl_method, verbosity); + offset_lm += bandlimit * bandlimit; + offset += bandlimit * (2 * bandlimit - 1); - ssht_adjoint_mw_forward_sov_sym(f, flm, L, spin, dl_method, verbosity); + free(f_wav_norm); + } + + s2let_transform_axisym_lm_wav_synthesis_multires( + flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + + ssht_adjoint_mw_forward_sov_sym(f, flm, L, spin, dl_method, verbosity); - free(flm); - free(f_scal_lm); - free(f_wav_lm); + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! * Spherical wavelets : multiresolution synthesis in real space, MW sampling. - * Perform multiresolution wavelet transform in real space (from scratch, gives wavelet maps). - * Sampling scheme : MW sampling. + * Perform multiresolution wavelet transform in real space (from scratch, gives wavelet + * maps). Sampling scheme : MW sampling. * * \param[out] f Input function (MW sampling) * \param[in] f_wav Array of wavelets maps, MW sampling. @@ -525,62 +522,63 @@ void s2let_transform_axisym_wav_synthesis_mw_multires( complex double *f, const complex double *f_wav, const complex double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int spin = 0; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; - - int bandlimit, j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); - - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - - complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); - - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, bandlimit, spin, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - - f_wav_norm = malloc(bandlimit*(2*bandlimit-1) * sizeof *f_wav_norm); - - for (i = 0; i < bandlimit*(2*bandlimit-1); ++i) - { - f_wav_norm[i] = f_wav[offset+i] * sqrt(2*PI); - } - - ssht_core_mw_forward_sov_conv_sym(f_wav_lm + offset_lm, f_wav_norm, bandlimit, spin, dl_method, verbosity); - offset_lm += bandlimit * bandlimit; - offset += bandlimit * (2 * bandlimit - 1); - - free(f_wav_norm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int spin = 0; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; + + int bandlimit, j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); + + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + ssht_core_mw_forward_sov_conv_sym( + f_scal_lm, f_scal, bandlimit, spin, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + + f_wav_norm = malloc(bandlimit * (2 * bandlimit - 1) * sizeof *f_wav_norm); + + for (i = 0; i < bandlimit * (2 * bandlimit - 1); ++i) { + f_wav_norm[i] = f_wav[offset + i] * sqrt(2 * PI); } - s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + ssht_core_mw_forward_sov_conv_sym( + f_wav_lm + offset_lm, f_wav_norm, bandlimit, spin, dl_method, verbosity); + offset_lm += bandlimit * bandlimit; + offset += bandlimit * (2 * bandlimit - 1); - ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity); + free(f_wav_norm); + } - free(flm); - free(f_scal_lm); - free(f_wav_lm); + s2let_transform_axisym_lm_wav_synthesis_multires( + flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + + ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity); + + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! * Spherical wavelets : multiresolution synthesis adjoint in real space, MW sampling. - * Perform multiresolution wavelet inverse transform adjoint in real space (from scratch, gives wavelet maps). - * Sampling scheme : MW sampling. + * Perform multiresolution wavelet inverse transform adjoint in real space (from + * scratch, gives wavelet maps). Sampling scheme : MW sampling. * * \param[out] f_wav Array of wavelets maps, MW sampling. * \param[out] f_scal Scaling function map, MW sampling. @@ -594,53 +592,54 @@ void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires( complex double *f_wav, complex double *f_scal, const complex double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int spin = 0; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int bandlimit, j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int spin = 0; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + int bandlimit, j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - ssht_adjoint_mw_inverse_sov_sym(flm, f, L, spin, dl_method, verbosity); + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); - s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + ssht_adjoint_mw_inverse_sov_sym(flm, f, L, spin, dl_method, verbosity); - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - ssht_adjoint_mw_forward_sov_sym(f_scal, f_scal_lm, bandlimit, spin, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; + s2let_transform_axisym_lm_wav_analysis_multires( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - ssht_adjoint_mw_forward_sov_sym(f_wav + offset, f_wav_lm + offset_lm, bandlimit, spin, dl_method, verbosity); + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + ssht_adjoint_mw_forward_sov_sym( + f_scal, f_scal_lm, bandlimit, spin, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; - for (i = 0; i < bandlimit*(2*bandlimit-1); ++i) - { - f_wav[offset+i] *= sqrt(2*PI); - } + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + ssht_adjoint_mw_forward_sov_sym( + f_wav + offset, f_wav_lm + offset_lm, bandlimit, spin, dl_method, verbosity); - offset_lm += bandlimit * bandlimit; - offset += bandlimit * (2 * bandlimit - 1); + for (i = 0; i < bandlimit * (2 * bandlimit - 1); ++i) { + f_wav[offset + i] *= sqrt(2 * PI); } - free(flm); - free(f_scal_lm); - free(f_wav_lm); + offset_lm += bandlimit * bandlimit; + offset += bandlimit * (2 * bandlimit - 1); + } + + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! @@ -661,50 +660,50 @@ void s2let_transform_axisym_wav_analysis_mw_real( double *f_wav, double *f_scal, const double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + int j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity); + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); - s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity); - ssht_core_mw_inverse_sov_sym_real(f_scal, f_scal_lm, L, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; + s2let_transform_axisym_lm_wav_analysis( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); - ssht_core_mw_inverse_sov_sym_real(f_wav + offset, f_wav_lm + offset_lm, L, dl_method, verbosity); + ssht_core_mw_inverse_sov_sym_real(f_scal, f_scal_lm, L, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; - for (i = 0; i < L*(2*L-1); ++i) - { - f_wav[offset+i] /= sqrt(2*PI); - } + ssht_core_mw_inverse_sov_sym_real( + f_wav + offset, f_wav_lm + offset_lm, L, dl_method, verbosity); - offset_lm += L * L; - offset += L * (2 * L - 1); + for (i = 0; i < L * (2 * L - 1); ++i) { + f_wav[offset + i] /= sqrt(2 * PI); } - free(flm); - free(f_scal_lm); - free(f_wav_lm); + offset_lm += L * L; + offset += L * (2 * L - 1); + } + + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! @@ -725,51 +724,51 @@ void s2let_transform_axisym_wav_analysis_adjoint_mw_real( double *f, const double *f_wav, const double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; - - int j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); - - double *f_wav_norm, *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); - - ssht_adjoint_mw_inverse_sov_sym_real(f_scal_lm, f_scal, L, dl_method, verbosity); - offset = 0; - offset_lm = 0; - f_wav_norm = malloc(L*(2*L-1) * sizeof *f_wav_norm); - for(j = J_min; j <= J; j++){ - int i; - - for (i = 0; i < L*(2*L-1); ++i) - { - f_wav_norm[i] = f_wav[offset+i] / sqrt(2*PI); - } - - ssht_adjoint_mw_inverse_sov_sym_real(f_wav_lm + offset_lm, f_wav_norm, L, dl_method, verbosity); - offset_lm += L * L; - offset += L * (2 * L - 1); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; + + int j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); + + double *f_wav_norm, *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + + ssht_adjoint_mw_inverse_sov_sym_real(f_scal_lm, f_scal, L, dl_method, verbosity); + offset = 0; + offset_lm = 0; + f_wav_norm = malloc(L * (2 * L - 1) * sizeof *f_wav_norm); + for (j = J_min; j <= J; j++) { + int i; + + for (i = 0; i < L * (2 * L - 1); ++i) { + f_wav_norm[i] = f_wav[offset + i] / sqrt(2 * PI); } - free(f_wav_norm); - s2let_transform_axisym_lm_wav_synthesis(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + ssht_adjoint_mw_inverse_sov_sym_real( + f_wav_lm + offset_lm, f_wav_norm, L, dl_method, verbosity); + offset_lm += L * L; + offset += L * (2 * L - 1); + } + free(f_wav_norm); + + s2let_transform_axisym_lm_wav_synthesis( + flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); - ssht_adjoint_mw_forward_sov_sym_real(f, flm, L, dl_method, verbosity); + ssht_adjoint_mw_forward_sov_sym_real(f, flm, L, dl_method, verbosity); - free(flm); - free(f_scal_lm); - free(f_wav_lm); + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! @@ -790,58 +789,57 @@ void s2let_transform_axisym_wav_synthesis_mw_real( double *f, const double *f_wav, const double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; - - int j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); - - double *f_wav_norm, *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); - - ssht_core_mw_forward_sov_conv_sym_real(f_scal_lm, f_scal, L, dl_method, verbosity); - offset = 0; - offset_lm = 0; - f_wav_norm = malloc(L*(2*L-1) * sizeof *f_wav_norm); - for(j = J_min; j <= J; j++){ - int i; - - for (i = 0; i < L*(2*L-1); ++i) - { - f_wav_norm[i] = f_wav[offset+i] * sqrt(2*PI); - } - - ssht_core_mw_forward_sov_conv_sym_real(f_wav_lm + offset_lm, f_wav_norm, L, dl_method, verbosity); - offset_lm += L * L; - offset += L * (2 * L - 1); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; + + int j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); + + double *f_wav_norm, *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + + ssht_core_mw_forward_sov_conv_sym_real(f_scal_lm, f_scal, L, dl_method, verbosity); + offset = 0; + offset_lm = 0; + f_wav_norm = malloc(L * (2 * L - 1) * sizeof *f_wav_norm); + for (j = J_min; j <= J; j++) { + int i; + + for (i = 0; i < L * (2 * L - 1); ++i) { + f_wav_norm[i] = f_wav[offset + i] * sqrt(2 * PI); } - free(f_wav_norm); - s2let_transform_axisym_lm_wav_synthesis(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + ssht_core_mw_forward_sov_conv_sym_real( + f_wav_lm + offset_lm, f_wav_norm, L, dl_method, verbosity); + offset_lm += L * L; + offset += L * (2 * L - 1); + } + free(f_wav_norm); + + s2let_transform_axisym_lm_wav_synthesis( + flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); - ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity); + ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity); - free(flm); - free(f_scal_lm); - free(f_wav_lm); + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! - * Perform wavelet inverse transform adjoint in real space (from scratch, gives wavelet maps). - * Input function is real. - * Sampling scheme : MW sampling. - * Spherical wavelets : analysis in real space, MW sampling. + * Perform wavelet inverse transform adjoint in real space (from scratch, gives wavelet + * maps). Input function is real. Sampling scheme : MW sampling. Spherical wavelets : + * analysis in real space, MW sampling. * * \param[out] f_wav Array of wavelets maps, MW sampling. * \param[out] f_scal Scaling function map, MW sampling. @@ -855,57 +853,56 @@ void s2let_transform_axisym_wav_synthesis_adjoint_mw_real( double *f_wav, double *f_scal, const double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; - int j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters); - ssht_adjoint_mw_inverse_sov_sym_real(flm, f, L, dl_method, verbosity); - - s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + ssht_adjoint_mw_inverse_sov_sym_real(flm, f, L, dl_method, verbosity); - ssht_adjoint_mw_forward_sov_sym_real(f_scal, f_scal_lm, L, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; + s2let_transform_axisym_lm_wav_analysis( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); - ssht_adjoint_mw_forward_sov_sym_real(f_wav + offset, f_wav_lm + offset_lm, L, dl_method, verbosity); + ssht_adjoint_mw_forward_sov_sym_real(f_scal, f_scal_lm, L, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; - for (i = 0; i < L*(2*L-1); ++i) - { - f_wav[offset+i] *= sqrt(2*PI); - } + ssht_adjoint_mw_forward_sov_sym_real( + f_wav + offset, f_wav_lm + offset_lm, L, dl_method, verbosity); - offset_lm += L * L; - offset += L * (2 * L - 1); + for (i = 0; i < L * (2 * L - 1); ++i) { + f_wav[offset + i] *= sqrt(2 * PI); } - free(flm); - free(f_scal_lm); - free(f_wav_lm); + offset_lm += L * L; + offset += L * (2 * L - 1); + } + + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! * Spherical wavelets : multiresolution analysis in real space, MW sampling. - * Perform multiresolution wavelet transform in real space (from scratch, gives wavelet maps). - * Input function is real. - * Sampling scheme : MW sampling. + * Perform multiresolution wavelet transform in real space (from scratch, gives wavelet + * maps). Input function is real. Sampling scheme : MW sampling. * * \param[out] f_wav Array of wavelets maps, MW sampling. * \param[out] f_scal Scaling function map, MW sampling. @@ -919,52 +916,52 @@ void s2let_transform_axisym_wav_analysis_mw_multires_real( double *f_wav, double *f_scal, const double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int bandlimit, j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + int bandlimit, j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity); + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); - s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity); - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - ssht_core_mw_inverse_sov_sym_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; + s2let_transform_axisym_lm_wav_analysis_multires( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - ssht_core_mw_inverse_sov_sym_real(f_wav + offset, f_wav_lm + offset_lm, bandlimit, dl_method, verbosity); + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + ssht_core_mw_inverse_sov_sym_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; - for (i = 0; i < bandlimit*(2*bandlimit-1); ++i) - { - f_wav[offset+i] /= sqrt(2*PI); - } + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + ssht_core_mw_inverse_sov_sym_real( + f_wav + offset, f_wav_lm + offset_lm, bandlimit, dl_method, verbosity); - offset_lm += bandlimit * bandlimit; - offset += bandlimit * (2 * bandlimit - 1); + for (i = 0; i < bandlimit * (2 * bandlimit - 1); ++i) { + f_wav[offset + i] /= sqrt(2 * PI); } - free(flm); - free(f_scal_lm); - free(f_wav_lm); + offset_lm += bandlimit * bandlimit; + offset += bandlimit * (2 * bandlimit - 1); + } + + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! @@ -985,55 +982,56 @@ void s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real( double *f, const double *f_wav, const double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; - - int bandlimit, j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); - - double *f_wav_norm, *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); - - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - ssht_adjoint_mw_inverse_sov_sym_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - - f_wav_norm = malloc(bandlimit*(2*bandlimit-1) * sizeof *f_wav_norm); - - for (i = 0; i < bandlimit*(2*bandlimit-1); ++i) - { - f_wav_norm[i] = f_wav[offset+i] / sqrt(2*PI); - } - - ssht_adjoint_mw_inverse_sov_sym_real(f_wav_lm + offset_lm, f_wav_norm, bandlimit, dl_method, verbosity); - offset_lm += bandlimit * bandlimit; - offset += bandlimit * (2 * bandlimit - 1); - - free(f_wav_norm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; + + int bandlimit, j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); + + double *f_wav_norm, *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + ssht_adjoint_mw_inverse_sov_sym_real( + f_scal_lm, f_scal, bandlimit, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + + f_wav_norm = malloc(bandlimit * (2 * bandlimit - 1) * sizeof *f_wav_norm); + + for (i = 0; i < bandlimit * (2 * bandlimit - 1); ++i) { + f_wav_norm[i] = f_wav[offset + i] / sqrt(2 * PI); } - s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + ssht_adjoint_mw_inverse_sov_sym_real( + f_wav_lm + offset_lm, f_wav_norm, bandlimit, dl_method, verbosity); + offset_lm += bandlimit * bandlimit; + offset += bandlimit * (2 * bandlimit - 1); + + free(f_wav_norm); + } + + s2let_transform_axisym_lm_wav_synthesis_multires( + flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); - ssht_adjoint_mw_forward_sov_sym_real(f, flm, L, dl_method, verbosity); + ssht_adjoint_mw_forward_sov_sym_real(f, flm, L, dl_method, verbosity); - free(flm); - free(f_scal_lm); - free(f_wav_lm); + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! @@ -1054,62 +1052,62 @@ void s2let_transform_axisym_wav_synthesis_mw_multires_real( double *f, const double *f_wav, const double *f_scal, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; - - int bandlimit, j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); - - double *f_wav_norm, *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); - - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - ssht_core_mw_forward_sov_conv_sym_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - - f_wav_norm = malloc(bandlimit*(2*bandlimit-1) * sizeof *f_wav_norm); - - for (i = 0; i < bandlimit*(2*bandlimit-1); ++i) - { - f_wav_norm[i] = f_wav[offset+i] * sqrt(2*PI); - } - - ssht_core_mw_forward_sov_conv_sym_real(f_wav_lm + offset_lm, f_wav_norm, bandlimit, dl_method, verbosity); - offset_lm += bandlimit * bandlimit; - offset += bandlimit * (2 * bandlimit - 1); - - free(f_wav_norm); + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; + + int bandlimit, j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); + + double *f_wav_norm, *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + ssht_core_mw_forward_sov_conv_sym_real( + f_scal_lm, f_scal, bandlimit, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + + f_wav_norm = malloc(bandlimit * (2 * bandlimit - 1) * sizeof *f_wav_norm); + + for (i = 0; i < bandlimit * (2 * bandlimit - 1); ++i) { + f_wav_norm[i] = f_wav[offset + i] * sqrt(2 * PI); } - s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + ssht_core_mw_forward_sov_conv_sym_real( + f_wav_lm + offset_lm, f_wav_norm, bandlimit, dl_method, verbosity); + offset_lm += bandlimit * bandlimit; + offset += bandlimit * (2 * bandlimit - 1); - ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity); + free(f_wav_norm); + } + + s2let_transform_axisym_lm_wav_synthesis_multires( + flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters); + + ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity); - free(flm); - free(f_scal_lm); - free(f_wav_lm); + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! * Spherical wavelets : multiresolution synthesis adjoint in real space, MW sampling. - * Perform multiresolution wavelet inverse transform adjoint in real space (from scratch, gives wavelet maps). - * Input function is real. - * Sampling scheme : MW sampling. + * Perform multiresolution wavelet inverse transform adjoint in real space (from + * scratch, gives wavelet maps). Input function is real. Sampling scheme : MW sampling. * * \param[out] f_wav Array of wavelets maps, MW sampling. * \param[out] f_scal Scaling function map, MW sampling. @@ -1123,52 +1121,53 @@ void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real( double *f_wav, double *f_scal, const double *f, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; + const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; - int verbosity = 0; - ssht_dl_method_t dl_method = SSHT_DL_RISBO; + int verbosity = 0; + ssht_dl_method_t dl_method = SSHT_DL_RISBO; - int bandlimit, j, offset, offset_lm; - int J = s2let_j_max(parameters); - //int l_min = s2let_transform_axisym_el_min(B, J_min); + int bandlimit, j, offset, offset_lm; + int J = s2let_j_max(parameters); + // int l_min = s2let_transform_axisym_el_min(B, J_min); - double *wav_lm, *scal_lm; - s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); - s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); + double *wav_lm, *scal_lm; + s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters); + s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters); - complex double *flm, *f_wav_lm, *f_scal_lm; - flm = (complex double*)calloc(L * L, sizeof(complex double)); - s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); + complex double *flm, *f_wav_lm, *f_scal_lm; + flm = (complex double *)calloc(L * L, sizeof(complex double)); + s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters); - ssht_adjoint_mw_inverse_sov_sym_real(flm, f, L, dl_method, verbosity); + ssht_adjoint_mw_inverse_sov_sym_real(flm, f, L, dl_method, verbosity); - s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); + s2let_transform_axisym_lm_wav_analysis_multires( + f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters); - bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L); - ssht_adjoint_mw_forward_sov_sym_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity); - offset = 0; - offset_lm = 0; - for(j = J_min; j <= J; j++){ - int i; + bandlimit = MIN(s2let_bandlimit(J_min - 1, parameters), L); + ssht_adjoint_mw_forward_sov_sym_real( + f_scal, f_scal_lm, bandlimit, dl_method, verbosity); + offset = 0; + offset_lm = 0; + for (j = J_min; j <= J; j++) { + int i; - bandlimit = MIN(s2let_bandlimit(j, parameters), L); - ssht_adjoint_mw_forward_sov_sym_real(f_wav + offset, f_wav_lm + offset_lm, bandlimit, dl_method, verbosity); + bandlimit = MIN(s2let_bandlimit(j, parameters), L); + ssht_adjoint_mw_forward_sov_sym_real( + f_wav + offset, f_wav_lm + offset_lm, bandlimit, dl_method, verbosity); - for (i = 0; i < bandlimit*(2*bandlimit-1); ++i) - { - f_wav[offset+i] *= sqrt(2*PI); - } - - offset_lm += bandlimit * bandlimit; - offset += bandlimit * (2 * bandlimit - 1); + for (i = 0; i < bandlimit * (2 * bandlimit - 1); ++i) { + f_wav[offset + i] *= sqrt(2 * PI); } - free(flm); - free(f_scal_lm); - free(f_wav_lm); + offset_lm += bandlimit * bandlimit; + offset += bandlimit * (2 * bandlimit - 1); + } + + free(flm); + free(f_scal_lm); + free(f_wav_lm); } /*! @@ -1182,23 +1181,20 @@ void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real( * \retval none */ void s2let_transform_axisym_wav_hardthreshold_real( - double *g_wav, - const double *threshold, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int J = s2let_j_max(parameters); - int i, j, offset = 0; - for(j = J_min; j <= J; j++){ - int bl = L; - for(i = 0; i < bl*(2*bl-1); i++){ - if( abs(g_wav[offset + i]) < threshold[j-J_min] ) - g_wav[offset + i] = 0; - } - offset += bl*(2*bl-1); + double *g_wav, const double *threshold, const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int J = s2let_j_max(parameters); + int i, j, offset = 0; + for (j = J_min; j <= J; j++) { + int bl = L; + for (i = 0; i < bl * (2 * bl - 1); i++) { + if (abs(g_wav[offset + i]) < threshold[j - J_min]) + g_wav[offset + i] = 0; } + offset += bl * (2 * bl - 1); + } } /*! @@ -1212,23 +1208,18 @@ void s2let_transform_axisym_wav_hardthreshold_real( * \retval none */ void s2let_transform_axisym_wav_hardthreshold_multires_real( - double *g_wav, - const double *threshold, - const s2let_parameters_t *parameters -) { - int L = parameters->L; - int J_min = parameters->J_min; - - int J = s2let_j_max(parameters); - int i, j, offset = 0; - for(j = J_min; j <= J; j++){ - int bl = MIN(s2let_bandlimit(j, parameters), L); - for(i = 0; i < bl*(2*bl-1); i++){ - if( abs(g_wav[offset + i]) < threshold[j-J_min] ) - g_wav[offset + i] = 0; - } - offset += bl*(2*bl-1); + double *g_wav, const double *threshold, const s2let_parameters_t *parameters) { + int L = parameters->L; + int J_min = parameters->J_min; + + int J = s2let_j_max(parameters); + int i, j, offset = 0; + for (j = J_min; j <= J; j++) { + int bl = MIN(s2let_bandlimit(j, parameters), L); + for (i = 0; i < bl * (2 * bl - 1); i++) { + if (abs(g_wav[offset + i]) < threshold[j - J_min]) + g_wav[offset + i] = 0; } + offset += bl * (2 * bl - 1); + } } - - diff --git a/src/main/c/s2let_transform_axisym_synthesis_hpx_real.c b/src/main/c/s2let_transform_axisym_synthesis_hpx_real.c index 2eb74565..90186d42 100644 --- a/src/main/c/s2let_transform_axisym_synthesis_hpx_real.c +++ b/src/main/c/s2let_transform_axisym_synthesis_hpx_real.c @@ -2,15 +2,16 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include #include +#include #include #include #include -#include #include +#include "s2let.h" + /*! * PROGRAM : s2let_transform_axisym_hpx_synthesis_real * COMMAND : bin/s2let_transform_axisym_hpx_synthesis_real file B J_min L @@ -21,8 +22,7 @@ * - L : bandlimit for the decomposition * OUTPUT : fits files containing the reconstructed healpix map */ -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { printf("--------------------------------------------------\n"); printf("S2LET library : axisymmetric wavelet transform\n"); printf("Real signal, HEALPIX sampling\n"); @@ -55,31 +55,32 @@ int main(int argc, char *argv[]) char file[100]; sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min); int j, offset = 0; - printf("File root = %s\n",fileroot); + printf("File root = %s\n", fileroot); // Init read procedure, read nside sprintf(file, "%s%s%s%s", fileroot, "_scal_", params, ".fits"); - printf("- Infile_scal = %s\n",file); + printf("- Infile_scal = %s\n", file); const int nside = s2let_fits_hpx_read_nside(file); - printf("- Detected bandlimit nside = %i\n",nside); + printf("- Detected bandlimit nside = %i\n", nside); // Allocate memory for wavelets double *f_wav, *f_scal; s2let_transform_axisym_allocate_hpx_f_wav_real(&f_wav, &f_scal, nside, ¶meters); // Read the scaling function s2let_hpx_read_map(f_scal, file, nside); // Now write the map to fits file // Read the wavelets - for(j = J_min; j <= J; j++){ + for (j = J_min; j <= J; j++) { sprintf(file, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits"); - printf("- Infile_wav[j=%i] = %s\n",j,file); + printf("- Infile_wav[j=%i] = %s\n", j, file); s2let_hpx_read_map(f_wav + offset, file, nside); // Now write the map to fits file - offset += 12*nside*nside; // Go to the next wavelet + offset += 12 * nside * nside; // Go to the next wavelet } // Allocate memory for reconstruction - double *f = (double*)calloc(12*nside*nside, sizeof(double)); + double *f = (double *)calloc(12 * nside * nside, sizeof(double)); printf("File successfully read from file\n"); - printf("Performing wavelet reconstruction...");fflush(NULL); + printf("Performing wavelet reconstruction..."); + fflush(NULL); s2let_transform_axisym_wav_synthesis_hpx_real(f, f_wav, f_scal, nside, ¶meters); printf("done\n"); @@ -87,13 +88,11 @@ int main(int argc, char *argv[]) printf("Writing reconsturcted map to FITS files\n"); char outfile[100]; sprintf(outfile, "%s%s%s%s", fileroot, "_recon_", params, ".fits"); - printf("- Outfile = %s\n",outfile); - remove(outfile); // In case the file exists + printf("- Outfile = %s\n", outfile); + remove(outfile); // In case the file exists s2let_hpx_write_map(outfile, f, nside); // Now write the map to fits file printf("--------------------------------------------------\n"); return 0; } - - diff --git a/src/main/c/s2let_transform_axisym_synthesis_mw_real.c b/src/main/c/s2let_transform_axisym_synthesis_mw_real.c index 4d362e1b..48555b31 100644 --- a/src/main/c/s2let_transform_axisym_synthesis_mw_real.c +++ b/src/main/c/s2let_transform_axisym_synthesis_mw_real.c @@ -2,15 +2,16 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" #include #include +#include #include #include #include -#include #include +#include "s2let.h" + /*! * PROGRAM : s2let_transform_axisym_mw_synthesis_real * COMMAND : bin/s2let_transform_axisym_mw_synthesis_real file B J_min L @@ -21,8 +22,7 @@ * - L : band-limit of the output map / of the finest wavelet map * OUTPUT : fits file containing the reconstructed MW map */ -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { printf("--------------------------------------------------\n"); printf("S2LET library : axisymmetric wavelet transform\n"); printf("Real signal, MW sampling\n"); @@ -57,79 +57,81 @@ int main(int argc, char *argv[]) char params[100]; sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min); int j, bl, offset = 0; - printf("File root = %s\n",fileroot); + printf("File root = %s\n", fileroot); // Read band-limits and see if multiresolution was activated int multires_ok = 1, monores_ok = 1; - for(j = J; j >= J_min; j--){ + for (j = J; j >= J_min; j--) { sprintf(file, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits"); - printf("- Infile_wav[j=%i] = %s\n",j,file); + printf("- Infile_wav[j=%i] = %s\n", j, file); bl = s2let_fits_mw_read_bandlimit(file); - printf(" Detected bandlimit bl = %i\n",bl); - if( bl != MIN(s2let_bandlimit(j, ¶meters), L) ) + printf(" Detected bandlimit bl = %i\n", bl); + if (bl != MIN(s2let_bandlimit(j, ¶meters), L)) multires_ok = 0; - if( bl != L ) + if (bl != L) monores_ok = 0; } // Read the scaling function sprintf(file, "%s%s%s%s", fileroot, "_scal_", params, ".fits"); - printf("- Infile_scal = %s\n",file); + printf("- Infile_scal = %s\n", file); bl = s2let_fits_mw_read_bandlimit(file); - printf(" Detected bandlimit bl = %i\n",bl); - if( bl != MIN(s2let_bandlimit(J_min-1, ¶meters), L) ) + printf(" Detected bandlimit bl = %i\n", bl); + if (bl != MIN(s2let_bandlimit(J_min - 1, ¶meters), L)) multires_ok = 0; - if( bl != L ) + if (bl != L) monores_ok = 0; // Are the parameters and the maps all consistent ? - if( monores_ok == 0 && multires_ok == 0 ){ + if (monores_ok == 0 && multires_ok == 0) { printf("The parameters don't match the bandlimits of the input maps"); printf("Neither the full or the multi-resolution algorithms are detected"); exit(-2); } // Activate full or multi-resolution - if(multires_ok == 1){ + if (multires_ok == 1) { multires = 1; printf("Multiresolution activated\n"); - }else{ + } else { multires = 0; printf("Multiresolution not activated\n"); } // Allocating memory for the wavelets double *f_wav, *f_scal; - if(multires){ - s2let_transform_axisym_allocate_mw_f_wav_multires_real(&f_wav, &f_scal, ¶meters); - }else{ + if (multires) { + s2let_transform_axisym_allocate_mw_f_wav_multires_real( + &f_wav, &f_scal, ¶meters); + } else { s2let_transform_axisym_allocate_mw_f_wav_real(&f_wav, &f_scal, ¶meters); } // Read the wavelets offset = 0; - for(j = J_min; j <= J; j++){ + for (j = J_min; j <= J; j++) { sprintf(file, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits"); - if(multires) + if (multires) bl = MIN(s2let_bandlimit(j, ¶meters), L); else bl = L; s2let_fits_mw_read_map(f_wav + offset, file, bl); // Now write the map to fits file - offset += (2*bl-1) * bl; // Go to the next wavelet + offset += (2 * bl - 1) * bl; // Go to the next wavelet } // Read the scaling function sprintf(file, "%s%s%s%s", fileroot, "_scal_", params, ".fits"); - if(multires) - bl = MIN(s2let_bandlimit(J_min-1, ¶meters), L); + if (multires) + bl = MIN(s2let_bandlimit(J_min - 1, ¶meters), L); else bl = L; s2let_fits_mw_read_map(f_scal, file, bl); - - printf("Performing wavelet decomposition...");fflush(NULL); - double *f = (double*)calloc(L * (2 * L - 1), sizeof(double)); - if(multires){ - s2let_transform_axisym_wav_synthesis_mw_multires_real(f, f_wav, f_scal, ¶meters); - }else{ + printf("Performing wavelet decomposition..."); + fflush(NULL); + double *f = (double *)calloc(L * (2 * L - 1), sizeof(double)); + if (multires) { + s2let_transform_axisym_wav_synthesis_mw_multires_real( + f, f_wav, f_scal, ¶meters); + } else { s2let_transform_axisym_wav_synthesis_mw_real(f, f_wav, f_scal, ¶meters); } printf("done\n"); @@ -138,13 +140,11 @@ int main(int argc, char *argv[]) char outfile[100]; printf("Writing the reconstructed map to a FITS file\n"); sprintf(outfile, "%s%s%s%s", fileroot, "_recon_", params, ".fits"); - printf("- Outfile = %s\n",outfile); - remove(outfile); // In case the file exists + printf("- Outfile = %s\n", outfile); + remove(outfile); // In case the file exists s2let_fits_mw_write_map(outfile, f, L); // Now write the map to fits file printf("--------------------------------------------------\n"); return 0; } - - From 01e173b042d53c3d35c8bca18b1d0f1bf87e38ac Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Thu, 15 Oct 2020 23:12:50 +0100 Subject: [PATCH 07/23] Update C API documentation --- CMakeLists.txt | 5 +- docs/c/annotated.html | 10 +- docs/c/classes.html | 10 +- docs/c/dir_000002_000000.html | 77 + docs/c/dir_000003_000000.html | 77 + docs/c/dir_000004_000000.html | 77 + docs/c/dir_000005_000000.html | 77 + .../dir_120ed4da3e3217b1e7fc0b4f48568e79.html | 22 +- ...r_120ed4da3e3217b1e7fc0b4f48568e79_dep.map | 7 + ...r_120ed4da3e3217b1e7fc0b4f48568e79_dep.md5 | 1 + .../dir_2756d41f8717da58192571bd3d5ae320.html | 35 +- ...r_2756d41f8717da58192571bd3d5ae320_dep.map | 6 + ...r_2756d41f8717da58192571bd3d5ae320_dep.md5 | 1 + .../dir_5eb159725f84c66aafd839904a4acdd0.html | 22 +- ...r_5eb159725f84c66aafd839904a4acdd0_dep.map | 7 + ...r_5eb159725f84c66aafd839904a4acdd0_dep.md5 | 1 + .../dir_68267d1309a1af8e8297ef4c3efbcdba.html | 23 +- ...r_68267d1309a1af8e8297ef4c3efbcdba_dep.map | 8 + ...r_68267d1309a1af8e8297ef4c3efbcdba_dep.md5 | 1 + .../dir_7420a7c8f71871d771403938d4d24c4a.html | 73 +- ...r_7420a7c8f71871d771403938d4d24c4a_dep.map | 6 + ...r_7420a7c8f71871d771403938d4d24c4a_dep.md5 | 1 + .../dir_d44c64559bbebec7f509842c48db8b23.html | 10 +- docs/c/dynsections.js | 7 - docs/c/files.html | 72 +- docs/c/functions.html | 10 +- docs/c/functions_vars.html | 10 +- docs/c/globals.html | 10 +- docs/c/globals_b.html | 10 +- docs/c/globals_defs.html | 13 +- docs/c/globals_enum.html | 10 +- docs/c/globals_eval.html | 10 +- docs/c/globals_f.html | 10 +- docs/c/globals_func.html | 10 +- docs/c/globals_func_f.html | 10 +- docs/c/globals_func_g.html | 13 +- docs/c/globals_func_h.html | 10 +- docs/c/globals_func_m.html | 23 +- docs/c/globals_func_n.html | 10 +- docs/c/globals_func_p.html | 10 +- docs/c/globals_func_r.html | 10 +- docs/c/globals_func_s.html | 14 +- docs/c/globals_func_t.html | 161 + docs/c/globals_func_w.html | 10 +- docs/c/globals_g.html | 13 +- docs/c/globals_h.html | 10 +- docs/c/globals_i.html | 10 +- docs/c/globals_m.html | 19 +- docs/c/globals_n.html | 10 +- docs/c/globals_p.html | 10 +- docs/c/globals_r.html | 10 +- docs/c/globals_s.html | 87 +- docs/c/globals_t.html | 161 + docs/c/globals_type.html | 10 +- docs/c/globals_vars.html | 16 +- docs/c/globals_w.html | 10 +- docs/c/graph_legend.html | 137 + docs/c/graph_legend.md5 | 1 + docs/c/index.html | 12 +- docs/c/menudata.js | 2 + docs/c/s2let_8h.html | 85 +- docs/c/s2let_8h__dep__incl.map | 35 + docs/c/s2let_8h__dep__incl.md5 | 1 + docs/c/s2let_8h__incl.map | 28 + docs/c/s2let_8h__incl.md5 | 1 + docs/c/s2let_8h_source.html | 52 +- docs/c/s2let__about_8c.html | 25 +- docs/c/s2let__about_8c__incl.map | 4 + docs/c/s2let__about_8c__incl.md5 | 1 + docs/c/s2let__about_8c_source.html | 104 - docs/c/s2let__alloc_8c.html | 84 +- docs/c/s2let__alloc_8c__incl.map | 31 + docs/c/s2let__alloc_8c__incl.md5 | 1 + docs/c/s2let__alloc_8c_source.html | 193 -- docs/c/s2let__alloc_8h.html | 78 +- docs/c/s2let__alloc_8h__dep__incl.map | 36 + docs/c/s2let__alloc_8h__dep__incl.md5 | 1 + docs/c/s2let__alloc_8h__incl.map | 5 + docs/c/s2let__alloc_8h__incl.md5 | 1 + docs/c/s2let__alloc_8h_source.html | 104 +- docs/c/s2let__analysis_8c.html | 88 +- docs/c/s2let__analysis_8c__incl.map | 31 + docs/c/s2let__analysis_8c__incl.md5 | 1 + docs/c/s2let__analysis_8c_source.html | 582 ---- docs/c/s2let__analysis_8h.html | 62 +- docs/c/s2let__analysis_8h__dep__incl.map | 36 + docs/c/s2let__analysis_8h__dep__incl.md5 | 1 + docs/c/s2let__analysis_8h__incl.map | 4 + docs/c/s2let__analysis_8h__incl.md5 | 1 + docs/c/s2let__analysis_8h_source.html | 16 +- docs/c/s2let__analysis__adjoint_8c.html | 90 +- docs/c/s2let__analysis__adjoint_8c__incl.map | 31 + docs/c/s2let__analysis__adjoint_8c__incl.md5 | 1 + .../c/s2let__analysis__adjoint_8c_source.html | 616 ---- docs/c/s2let__analysis__adjoint_8h.html | 62 +- ...s2let__analysis__adjoint_8h__dep__incl.map | 36 + ...s2let__analysis__adjoint_8h__dep__incl.md5 | 1 + docs/c/s2let__analysis__adjoint_8h__incl.map | 4 + docs/c/s2let__analysis__adjoint_8h__incl.md5 | 1 + .../c/s2let__analysis__adjoint_8h_source.html | 16 +- docs/c/s2let__axisym__denoising__demo_8c.html | 66 +- ...2let__axisym__denoising__demo_8c__incl.map | 33 + ...2let__axisym__denoising__demo_8c__incl.md5 | 1 + ...et__axisym__denoising__demo_8c_source.html | 276 -- docs/c/s2let__axisym__denoising__demo_8h.html | 25 +- ...2let__axisym__denoising__demo_8h__incl.map | 4 + ...2let__axisym__denoising__demo_8h__incl.md5 | 1 + ...et__axisym__denoising__demo_8h_source.html | 17 +- docs/c/s2let__denoising__demo_8c.html | 68 +- docs/c/s2let__denoising__demo_8c__incl.map | 33 + docs/c/s2let__denoising__demo_8c__incl.md5 | 1 + docs/c/s2let__denoising__demo_8c_source.html | 300 -- docs/c/s2let__denoising__demo_8h.html | 27 +- docs/c/s2let__denoising__demo_8h__incl.map | 4 + docs/c/s2let__denoising__demo_8h__incl.md5 | 1 + docs/c/s2let__denoising__demo_8h_source.html | 21 +- docs/c/s2let__error_8h.html | 65 +- docs/c/s2let__error_8h__dep__incl.map | 36 + docs/c/s2let__error_8h__dep__incl.md5 | 1 + docs/c/s2let__error_8h__incl.map | 5 + docs/c/s2let__error_8h__incl.md5 | 1 + docs/c/s2let__error_8h_source.html | 10 +- docs/c/s2let__fits_8c.html | 69 +- docs/c/s2let__fits_8c__incl.map | 30 + docs/c/s2let__fits_8c__incl.md5 | 1 + docs/c/s2let__fits_8c_source.html | 772 ----- docs/c/s2let__fits_8h.html | 73 +- docs/c/s2let__fits_8h__dep__incl.map | 36 + docs/c/s2let__fits_8h__dep__incl.md5 | 1 + docs/c/s2let__fits_8h_source.html | 30 +- docs/c/s2let__helper_8c.html | 70 +- docs/c/s2let__helper_8c__incl.map | 29 + docs/c/s2let__helper_8c__incl.md5 | 1 + docs/c/s2let__helper_8c_source.html | 224 -- docs/c/s2let__helper_8h.html | 80 +- docs/c/s2let__helper_8h__dep__incl.map | 36 + docs/c/s2let__helper_8h__dep__incl.md5 | 1 + docs/c/s2let__helper_8h__incl.map | 4 + docs/c/s2let__helper_8h__incl.md5 | 1 + docs/c/s2let__helper_8h_source.html | 32 +- docs/c/s2let__hpx_8c.html | 69 +- docs/c/s2let__hpx_8c__incl.map | 30 + docs/c/s2let__hpx_8c__incl.md5 | 1 + docs/c/s2let__hpx_8c_source.html | 155 - docs/c/s2let__hpx_8h.html | 69 +- docs/c/s2let__hpx_8h__dep__incl.map | 36 + docs/c/s2let__hpx_8h__dep__incl.md5 | 1 + docs/c/s2let__hpx_8h__incl.map | 5 + docs/c/s2let__hpx_8h__incl.md5 | 1 + docs/c/s2let__hpx_8h_source.html | 20 +- docs/c/s2let__hpx__demo_8c.html | 60 +- docs/c/s2let__hpx__demo_8c__incl.map | 33 + docs/c/s2let__hpx__demo_8c__incl.md5 | 1 + docs/c/s2let__hpx__demo_8c_source.html | 169 - docs/c/s2let__hpx__test_8c.html | 79 +- docs/c/s2let__hpx__test_8c__incl.map | 34 + docs/c/s2let__hpx__test_8c__incl.md5 | 1 + docs/c/s2let__hpx__test_8c_source.html | 579 ---- docs/c/s2let__idl__hpx_8c.html | 66 +- docs/c/s2let__idl__hpx_8c__incl.map | 29 + docs/c/s2let__idl__hpx_8c__incl.md5 | 1 + docs/c/s2let__idl__hpx_8c_source.html | 206 -- docs/c/s2let__idl__hpx_8h.html | 64 +- docs/c/s2let__idl__hpx_8h__dep__incl.map | 36 + docs/c/s2let__idl__hpx_8h__dep__incl.md5 | 1 + docs/c/s2let__idl__hpx_8h__incl.map | 4 + docs/c/s2let__idl__hpx_8h__incl.md5 | 1 + docs/c/s2let__idl__hpx_8h_source.html | 14 +- docs/c/s2let__idl__mw_8c.html | 84 +- docs/c/s2let__idl__mw_8c__incl.map | 29 + docs/c/s2let__idl__mw_8c__incl.md5 | 1 + docs/c/s2let__idl__mw_8c_source.html | 384 --- docs/c/s2let__idl__mw_8h.html | 69 +- docs/c/s2let__idl__mw_8h__dep__incl.map | 36 + docs/c/s2let__idl__mw_8h__dep__incl.md5 | 1 + docs/c/s2let__idl__mw_8h_source.html | 26 +- docs/c/s2let__lm_8c.html | 66 +- docs/c/s2let__lm_8c__incl.map | 31 + docs/c/s2let__lm_8c__incl.md5 | 1 + docs/c/s2let__lm_8c_source.html | 133 - docs/c/s2let__lm_8h.html | 64 +- docs/c/s2let__lm_8h__dep__incl.map | 36 + docs/c/s2let__lm_8h__dep__incl.md5 | 1 + docs/c/s2let__lm_8h__incl.map | 4 + docs/c/s2let__lm_8h__incl.md5 | 1 + docs/c/s2let__lm_8h_source.html | 17 +- docs/c/s2let__math_8c.html | 74 +- docs/c/s2let__math_8c__incl.map | 31 + docs/c/s2let__math_8c__incl.md5 | 1 + docs/c/s2let__math_8c_source.html | 330 -- docs/c/s2let__math_8h.html | 80 +- docs/c/s2let__math_8h__dep__incl.map | 36 + docs/c/s2let__math_8h__dep__incl.md5 | 1 + docs/c/s2let__math_8h__incl.map | 4 + docs/c/s2let__math_8h__incl.md5 | 1 + docs/c/s2let__math_8h_source.html | 24 +- docs/c/s2let__mex_8h.html | 16 +- docs/c/s2let__mex_8h_source.html | 10 +- docs/c/s2let__mw_8c.html | 66 +- docs/c/s2let__mw_8c__incl.map | 31 + docs/c/s2let__mw_8c__incl.md5 | 1 + docs/c/s2let__mw_8c_source.html | 141 - docs/c/s2let__mw_8h.html | 62 +- docs/c/s2let__mw_8h__dep__incl.map | 36 + docs/c/s2let__mw_8h__dep__incl.md5 | 1 + docs/c/s2let__mw_8h__incl.map | 4 + docs/c/s2let__mw_8h__incl.md5 | 1 + docs/c/s2let__mw_8h_source.html | 14 +- docs/c/s2let__so3_8h.html | 65 +- docs/c/s2let__so3_8h__dep__incl.map | 36 + docs/c/s2let__so3_8h__dep__incl.md5 | 1 + docs/c/s2let__so3_8h__incl.map | 5 + docs/c/s2let__so3_8h__incl.md5 | 1 + docs/c/s2let__so3_8h_source.html | 28 +- docs/c/s2let__spin__denoising__demo_8c.html | 66 +- .../s2let__spin__denoising__demo_8c__incl.map | 33 + .../s2let__spin__denoising__demo_8c__incl.md5 | 1 + ...2let__spin__denoising__demo_8c_source.html | 378 --- docs/c/s2let__synthesis_8c.html | 90 +- docs/c/s2let__synthesis_8c__incl.map | 31 + docs/c/s2let__synthesis_8c__incl.md5 | 1 + docs/c/s2let__synthesis_8c_source.html | 603 ---- docs/c/s2let__synthesis_8h.html | 62 +- docs/c/s2let__synthesis_8h__dep__incl.map | 36 + docs/c/s2let__synthesis_8h__dep__incl.md5 | 1 + docs/c/s2let__synthesis_8h__incl.map | 4 + docs/c/s2let__synthesis_8h__incl.md5 | 1 + docs/c/s2let__synthesis_8h_source.html | 16 +- docs/c/s2let__synthesis__adjoint_8c.html | 88 +- docs/c/s2let__synthesis__adjoint_8c__incl.map | 31 + docs/c/s2let__synthesis__adjoint_8c__incl.md5 | 1 + .../s2let__synthesis__adjoint_8c_source.html | 588 ---- docs/c/s2let__synthesis__adjoint_8h.html | 62 +- ...2let__synthesis__adjoint_8h__dep__incl.map | 36 + ...2let__synthesis__adjoint_8h__dep__incl.md5 | 1 + docs/c/s2let__synthesis__adjoint_8h__incl.map | 4 + docs/c/s2let__synthesis__adjoint_8h__incl.md5 | 1 + .../s2let__synthesis__adjoint_8h_source.html | 16 +- docs/c/s2let__test_8c.html | 213 +- docs/c/s2let__test_8c__incl.map | 32 + docs/c/s2let__test_8c__incl.md5 | 1 + docs/c/s2let__test_8c_source.html | 2980 ----------------- docs/c/s2let__test__csv_8c.html | 56 +- docs/c/s2let__test__csv_8c__incl.map | 31 + docs/c/s2let__test__csv_8c__incl.md5 | 1 + docs/c/s2let__test__csv_8c_source.html | 277 -- docs/c/s2let__tiling_8c.html | 94 +- docs/c/s2let__tiling_8c__incl.map | 31 + docs/c/s2let__tiling_8c__incl.md5 | 1 + docs/c/s2let__tiling_8c_source.html | 531 --- docs/c/s2let__tiling_8h.html | 78 +- docs/c/s2let__tiling_8h__dep__incl.map | 36 + docs/c/s2let__tiling_8h__dep__incl.md5 | 1 + docs/c/s2let__tiling_8h__incl.map | 4 + docs/c/s2let__tiling_8h__incl.md5 | 1 + docs/c/s2let__tiling_8h_source.html | 28 +- ...sform__axisym__analysis__hpx__real_8c.html | 58 +- ...__axisym__analysis__hpx__real_8c__incl.map | 33 + ...__axisym__analysis__hpx__real_8c__incl.md5 | 1 + ...axisym__analysis__hpx__real_8c_source.html | 180 - ...nsform__axisym__analysis__mw__real_8c.html | 58 +- ...m__axisym__analysis__mw__real_8c__incl.map | 33 + ...m__axisym__analysis__mw__real_8c__incl.md5 | 1 + ..._axisym__analysis__mw__real_8c_source.html | 197 -- docs/c/s2let__transform__axisym__hpx_8c.html | 57 +- ...s2let__transform__axisym__hpx_8c__incl.map | 30 + ...s2let__transform__axisym__hpx_8c__incl.md5 | 1 + ...let__transform__axisym__hpx_8c_source.html | 187 -- docs/c/s2let__transform__axisym__hpx_8h.html | 59 +- ...__transform__axisym__hpx_8h__dep__incl.map | 36 + ...__transform__axisym__hpx_8h__dep__incl.md5 | 1 + ...let__transform__axisym__hpx_8h_source.html | 18 +- docs/c/s2let__transform__axisym__lm_8c.html | 104 +- .../s2let__transform__axisym__lm_8c__incl.map | 31 + .../s2let__transform__axisym__lm_8c__incl.md5 | 1 + ...2let__transform__axisym__lm_8c_source.html | 322 -- docs/c/s2let__transform__axisym__lm_8h.html | 64 +- ...t__transform__axisym__lm_8h__dep__incl.map | 36 + ...t__transform__axisym__lm_8h__dep__incl.md5 | 1 + .../s2let__transform__axisym__lm_8h__incl.map | 4 + .../s2let__transform__axisym__lm_8h__incl.md5 | 1 + ...2let__transform__axisym__lm_8h_source.html | 18 +- docs/c/s2let__transform__axisym__mw_8c.html | 96 +- .../s2let__transform__axisym__mw_8c__incl.map | 31 + .../s2let__transform__axisym__mw_8c__incl.md5 | 1 + ...2let__transform__axisym__mw_8c_source.html | 1077 ------ docs/c/s2let__transform__axisym__mw_8h.html | 84 +- ...t__transform__axisym__mw_8h__dep__incl.map | 36 + ...t__transform__axisym__mw_8h__dep__incl.md5 | 1 + .../s2let__transform__axisym__mw_8h__incl.map | 4 + .../s2let__transform__axisym__mw_8h__incl.md5 | 1 + ...2let__transform__axisym__mw_8h_source.html | 38 +- ...form__axisym__synthesis__hpx__real_8c.html | 58 +- ..._axisym__synthesis__hpx__real_8c__incl.map | 33 + ..._axisym__synthesis__hpx__real_8c__incl.md5 | 1 + ...xisym__synthesis__hpx__real_8c_source.html | 182 - ...sform__axisym__synthesis__mw__real_8c.html | 58 +- ...__axisym__synthesis__mw__real_8c__incl.map | 33 + ...__axisym__synthesis__mw__real_8c__incl.md5 | 1 + ...axisym__synthesis__mw__real_8c_source.html | 237 -- docs/c/s2let__types_8h.html | 65 +- docs/c/s2let__types_8h__dep__incl.map | 37 + docs/c/s2let__types_8h__dep__incl.md5 | 1 + docs/c/s2let__types_8h__incl.map | 4 + docs/c/s2let__types_8h__incl.md5 | 1 + docs/c/s2let__types_8h_source.html | 42 +- docs/c/search/all_10.js | 2 +- docs/c/search/all_11.js | 3 +- docs/c/search/all_12.html | 36 + docs/c/search/all_12.js | 5 + docs/c/search/all_4.js | 3 +- docs/c/search/all_5.js | 12 +- docs/c/search/all_6.js | 12 +- docs/c/search/all_7.js | 2 +- docs/c/search/all_8.js | 2 +- docs/c/search/all_9.js | 10 +- docs/c/search/all_a.js | 8 +- docs/c/search/all_b.js | 2 +- docs/c/search/all_c.js | 4 +- docs/c/search/all_d.js | 8 +- docs/c/search/all_e.js | 542 +-- docs/c/search/all_f.js | 33 +- docs/c/search/classes_0.js | 2 +- docs/c/search/defines_0.js | 2 +- docs/c/search/defines_1.js | 4 +- docs/c/search/defines_2.js | 4 +- docs/c/search/defines_3.js | 2 +- docs/c/search/defines_4.js | 2 +- docs/c/search/defines_5.js | 17 +- docs/c/search/enums_0.js | 4 +- docs/c/search/enumvalues_0.js | 2 +- docs/c/search/enumvalues_1.js | 10 +- docs/c/search/files_0.js | 106 +- docs/c/search/files_1.html | 36 + docs/c/search/files_1.js | 7 + docs/c/search/functions_0.js | 4 +- docs/c/search/functions_1.js | 4 +- docs/c/search/functions_2.js | 3 +- docs/c/search/functions_3.js | 12 +- docs/c/search/functions_4.js | 7 +- docs/c/search/functions_5.js | 2 +- docs/c/search/functions_6.js | 2 +- docs/c/search/functions_7.js | 6 +- docs/c/search/functions_8.js | 396 +-- docs/c/search/functions_9.js | 30 +- docs/c/search/functions_a.html | 36 + docs/c/search/functions_a.js | 5 + docs/c/search/searchdata.js | 6 +- docs/c/search/typedefs_0.js | 8 +- docs/c/search/variables_0.js | 2 +- docs/c/search/variables_1.js | 2 +- docs/c/search/variables_2.js | 2 +- docs/c/search/variables_3.js | 2 +- docs/c/search/variables_4.js | 2 +- docs/c/search/variables_5.js | 2 +- docs/c/search/variables_6.js | 2 +- docs/c/search/variables_7.js | 7 +- docs/c/search/variables_8.js | 2 +- docs/c/search/variables_9.js | 2 +- .../c/structs2let__parameters__t-members.html | 91 + docs/c/structs2let__parameters__t.html | 36 +- docs/c/test__adjoint_8c.html | 368 ++ docs/c/test__adjoint_8c__incl.map | 33 + docs/c/test__adjoint_8c__incl.md5 | 1 + docs/c/test__axisym__vs__directional_8c.html | 242 ++ ...test__axisym__vs__directional_8c__incl.map | 33 + ...test__axisym__vs__directional_8c__incl.md5 | 1 + docs/c/test__back__and__forth_8c.html | 501 +++ docs/c/test__back__and__forth_8c__incl.map | 33 + docs/c/test__back__and__forth_8c__incl.md5 | 1 + docs/c/test__tiling_8c.html | 255 ++ docs/c/test__tiling_8c__incl.map | 33 + docs/c/test__tiling_8c__incl.md5 | 1 + 373 files changed, 8319 insertions(+), 15343 deletions(-) create mode 100644 docs/c/dir_000002_000000.html create mode 100644 docs/c/dir_000003_000000.html create mode 100644 docs/c/dir_000004_000000.html create mode 100644 docs/c/dir_000005_000000.html create mode 100644 docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79_dep.map create mode 100644 docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79_dep.md5 create mode 100644 docs/c/dir_2756d41f8717da58192571bd3d5ae320_dep.map create mode 100644 docs/c/dir_2756d41f8717da58192571bd3d5ae320_dep.md5 create mode 100644 docs/c/dir_5eb159725f84c66aafd839904a4acdd0_dep.map create mode 100644 docs/c/dir_5eb159725f84c66aafd839904a4acdd0_dep.md5 create mode 100644 docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba_dep.map create mode 100644 docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba_dep.md5 create mode 100644 docs/c/dir_7420a7c8f71871d771403938d4d24c4a_dep.map create mode 100644 docs/c/dir_7420a7c8f71871d771403938d4d24c4a_dep.md5 create mode 100644 docs/c/globals_func_t.html create mode 100644 docs/c/globals_t.html create mode 100644 docs/c/graph_legend.html create mode 100644 docs/c/graph_legend.md5 create mode 100644 docs/c/s2let_8h__dep__incl.map create mode 100644 docs/c/s2let_8h__dep__incl.md5 create mode 100644 docs/c/s2let_8h__incl.map create mode 100644 docs/c/s2let_8h__incl.md5 create mode 100644 docs/c/s2let__about_8c__incl.map create mode 100644 docs/c/s2let__about_8c__incl.md5 delete mode 100644 docs/c/s2let__about_8c_source.html create mode 100644 docs/c/s2let__alloc_8c__incl.map create mode 100644 docs/c/s2let__alloc_8c__incl.md5 delete mode 100644 docs/c/s2let__alloc_8c_source.html create mode 100644 docs/c/s2let__alloc_8h__dep__incl.map create mode 100644 docs/c/s2let__alloc_8h__dep__incl.md5 create mode 100644 docs/c/s2let__alloc_8h__incl.map create mode 100644 docs/c/s2let__alloc_8h__incl.md5 create mode 100644 docs/c/s2let__analysis_8c__incl.map create mode 100644 docs/c/s2let__analysis_8c__incl.md5 delete mode 100644 docs/c/s2let__analysis_8c_source.html create mode 100644 docs/c/s2let__analysis_8h__dep__incl.map create mode 100644 docs/c/s2let__analysis_8h__dep__incl.md5 create mode 100644 docs/c/s2let__analysis_8h__incl.map create mode 100644 docs/c/s2let__analysis_8h__incl.md5 create mode 100644 docs/c/s2let__analysis__adjoint_8c__incl.map create mode 100644 docs/c/s2let__analysis__adjoint_8c__incl.md5 delete mode 100644 docs/c/s2let__analysis__adjoint_8c_source.html create mode 100644 docs/c/s2let__analysis__adjoint_8h__dep__incl.map create mode 100644 docs/c/s2let__analysis__adjoint_8h__dep__incl.md5 create mode 100644 docs/c/s2let__analysis__adjoint_8h__incl.map create mode 100644 docs/c/s2let__analysis__adjoint_8h__incl.md5 create mode 100644 docs/c/s2let__axisym__denoising__demo_8c__incl.map create mode 100644 docs/c/s2let__axisym__denoising__demo_8c__incl.md5 delete mode 100644 docs/c/s2let__axisym__denoising__demo_8c_source.html create mode 100644 docs/c/s2let__axisym__denoising__demo_8h__incl.map create mode 100644 docs/c/s2let__axisym__denoising__demo_8h__incl.md5 create mode 100644 docs/c/s2let__denoising__demo_8c__incl.map create mode 100644 docs/c/s2let__denoising__demo_8c__incl.md5 delete mode 100644 docs/c/s2let__denoising__demo_8c_source.html create mode 100644 docs/c/s2let__denoising__demo_8h__incl.map create mode 100644 docs/c/s2let__denoising__demo_8h__incl.md5 create mode 100644 docs/c/s2let__error_8h__dep__incl.map create mode 100644 docs/c/s2let__error_8h__dep__incl.md5 create mode 100644 docs/c/s2let__error_8h__incl.map create mode 100644 docs/c/s2let__error_8h__incl.md5 create mode 100644 docs/c/s2let__fits_8c__incl.map create mode 100644 docs/c/s2let__fits_8c__incl.md5 delete mode 100644 docs/c/s2let__fits_8c_source.html create mode 100644 docs/c/s2let__fits_8h__dep__incl.map create mode 100644 docs/c/s2let__fits_8h__dep__incl.md5 create mode 100644 docs/c/s2let__helper_8c__incl.map create mode 100644 docs/c/s2let__helper_8c__incl.md5 delete mode 100644 docs/c/s2let__helper_8c_source.html create mode 100644 docs/c/s2let__helper_8h__dep__incl.map create mode 100644 docs/c/s2let__helper_8h__dep__incl.md5 create mode 100644 docs/c/s2let__helper_8h__incl.map create mode 100644 docs/c/s2let__helper_8h__incl.md5 create mode 100644 docs/c/s2let__hpx_8c__incl.map create mode 100644 docs/c/s2let__hpx_8c__incl.md5 delete mode 100644 docs/c/s2let__hpx_8c_source.html create mode 100644 docs/c/s2let__hpx_8h__dep__incl.map create mode 100644 docs/c/s2let__hpx_8h__dep__incl.md5 create mode 100644 docs/c/s2let__hpx_8h__incl.map create mode 100644 docs/c/s2let__hpx_8h__incl.md5 create mode 100644 docs/c/s2let__hpx__demo_8c__incl.map create mode 100644 docs/c/s2let__hpx__demo_8c__incl.md5 delete mode 100644 docs/c/s2let__hpx__demo_8c_source.html create mode 100644 docs/c/s2let__hpx__test_8c__incl.map create mode 100644 docs/c/s2let__hpx__test_8c__incl.md5 delete mode 100644 docs/c/s2let__hpx__test_8c_source.html create mode 100644 docs/c/s2let__idl__hpx_8c__incl.map create mode 100644 docs/c/s2let__idl__hpx_8c__incl.md5 delete mode 100644 docs/c/s2let__idl__hpx_8c_source.html create mode 100644 docs/c/s2let__idl__hpx_8h__dep__incl.map create mode 100644 docs/c/s2let__idl__hpx_8h__dep__incl.md5 create mode 100644 docs/c/s2let__idl__hpx_8h__incl.map create mode 100644 docs/c/s2let__idl__hpx_8h__incl.md5 create mode 100644 docs/c/s2let__idl__mw_8c__incl.map create mode 100644 docs/c/s2let__idl__mw_8c__incl.md5 delete mode 100644 docs/c/s2let__idl__mw_8c_source.html create mode 100644 docs/c/s2let__idl__mw_8h__dep__incl.map create mode 100644 docs/c/s2let__idl__mw_8h__dep__incl.md5 create mode 100644 docs/c/s2let__lm_8c__incl.map create mode 100644 docs/c/s2let__lm_8c__incl.md5 delete mode 100644 docs/c/s2let__lm_8c_source.html create mode 100644 docs/c/s2let__lm_8h__dep__incl.map create mode 100644 docs/c/s2let__lm_8h__dep__incl.md5 create mode 100644 docs/c/s2let__lm_8h__incl.map create mode 100644 docs/c/s2let__lm_8h__incl.md5 create mode 100644 docs/c/s2let__math_8c__incl.map create mode 100644 docs/c/s2let__math_8c__incl.md5 delete mode 100644 docs/c/s2let__math_8c_source.html create mode 100644 docs/c/s2let__math_8h__dep__incl.map create mode 100644 docs/c/s2let__math_8h__dep__incl.md5 create mode 100644 docs/c/s2let__math_8h__incl.map create mode 100644 docs/c/s2let__math_8h__incl.md5 create mode 100644 docs/c/s2let__mw_8c__incl.map create mode 100644 docs/c/s2let__mw_8c__incl.md5 delete mode 100644 docs/c/s2let__mw_8c_source.html create mode 100644 docs/c/s2let__mw_8h__dep__incl.map create mode 100644 docs/c/s2let__mw_8h__dep__incl.md5 create mode 100644 docs/c/s2let__mw_8h__incl.map create mode 100644 docs/c/s2let__mw_8h__incl.md5 create mode 100644 docs/c/s2let__so3_8h__dep__incl.map create mode 100644 docs/c/s2let__so3_8h__dep__incl.md5 create mode 100644 docs/c/s2let__so3_8h__incl.map create mode 100644 docs/c/s2let__so3_8h__incl.md5 create mode 100644 docs/c/s2let__spin__denoising__demo_8c__incl.map create mode 100644 docs/c/s2let__spin__denoising__demo_8c__incl.md5 delete mode 100644 docs/c/s2let__spin__denoising__demo_8c_source.html create mode 100644 docs/c/s2let__synthesis_8c__incl.map create mode 100644 docs/c/s2let__synthesis_8c__incl.md5 delete mode 100644 docs/c/s2let__synthesis_8c_source.html create mode 100644 docs/c/s2let__synthesis_8h__dep__incl.map create mode 100644 docs/c/s2let__synthesis_8h__dep__incl.md5 create mode 100644 docs/c/s2let__synthesis_8h__incl.map create mode 100644 docs/c/s2let__synthesis_8h__incl.md5 create mode 100644 docs/c/s2let__synthesis__adjoint_8c__incl.map create mode 100644 docs/c/s2let__synthesis__adjoint_8c__incl.md5 delete mode 100644 docs/c/s2let__synthesis__adjoint_8c_source.html create mode 100644 docs/c/s2let__synthesis__adjoint_8h__dep__incl.map create mode 100644 docs/c/s2let__synthesis__adjoint_8h__dep__incl.md5 create mode 100644 docs/c/s2let__synthesis__adjoint_8h__incl.map create mode 100644 docs/c/s2let__synthesis__adjoint_8h__incl.md5 create mode 100644 docs/c/s2let__test_8c__incl.map create mode 100644 docs/c/s2let__test_8c__incl.md5 delete mode 100644 docs/c/s2let__test_8c_source.html create mode 100644 docs/c/s2let__test__csv_8c__incl.map create mode 100644 docs/c/s2let__test__csv_8c__incl.md5 delete mode 100644 docs/c/s2let__test__csv_8c_source.html create mode 100644 docs/c/s2let__tiling_8c__incl.map create mode 100644 docs/c/s2let__tiling_8c__incl.md5 delete mode 100644 docs/c/s2let__tiling_8c_source.html create mode 100644 docs/c/s2let__tiling_8h__dep__incl.map create mode 100644 docs/c/s2let__tiling_8h__dep__incl.md5 create mode 100644 docs/c/s2let__tiling_8h__incl.map create mode 100644 docs/c/s2let__tiling_8h__incl.md5 create mode 100644 docs/c/s2let__transform__axisym__analysis__hpx__real_8c__incl.map create mode 100644 docs/c/s2let__transform__axisym__analysis__hpx__real_8c__incl.md5 delete mode 100644 docs/c/s2let__transform__axisym__analysis__hpx__real_8c_source.html create mode 100644 docs/c/s2let__transform__axisym__analysis__mw__real_8c__incl.map create mode 100644 docs/c/s2let__transform__axisym__analysis__mw__real_8c__incl.md5 delete mode 100644 docs/c/s2let__transform__axisym__analysis__mw__real_8c_source.html create mode 100644 docs/c/s2let__transform__axisym__hpx_8c__incl.map create mode 100644 docs/c/s2let__transform__axisym__hpx_8c__incl.md5 delete mode 100644 docs/c/s2let__transform__axisym__hpx_8c_source.html create mode 100644 docs/c/s2let__transform__axisym__hpx_8h__dep__incl.map create mode 100644 docs/c/s2let__transform__axisym__hpx_8h__dep__incl.md5 create mode 100644 docs/c/s2let__transform__axisym__lm_8c__incl.map create mode 100644 docs/c/s2let__transform__axisym__lm_8c__incl.md5 delete mode 100644 docs/c/s2let__transform__axisym__lm_8c_source.html create mode 100644 docs/c/s2let__transform__axisym__lm_8h__dep__incl.map create mode 100644 docs/c/s2let__transform__axisym__lm_8h__dep__incl.md5 create mode 100644 docs/c/s2let__transform__axisym__lm_8h__incl.map create mode 100644 docs/c/s2let__transform__axisym__lm_8h__incl.md5 create mode 100644 docs/c/s2let__transform__axisym__mw_8c__incl.map create mode 100644 docs/c/s2let__transform__axisym__mw_8c__incl.md5 delete mode 100644 docs/c/s2let__transform__axisym__mw_8c_source.html create mode 100644 docs/c/s2let__transform__axisym__mw_8h__dep__incl.map create mode 100644 docs/c/s2let__transform__axisym__mw_8h__dep__incl.md5 create mode 100644 docs/c/s2let__transform__axisym__mw_8h__incl.map create mode 100644 docs/c/s2let__transform__axisym__mw_8h__incl.md5 create mode 100644 docs/c/s2let__transform__axisym__synthesis__hpx__real_8c__incl.map create mode 100644 docs/c/s2let__transform__axisym__synthesis__hpx__real_8c__incl.md5 delete mode 100644 docs/c/s2let__transform__axisym__synthesis__hpx__real_8c_source.html create mode 100644 docs/c/s2let__transform__axisym__synthesis__mw__real_8c__incl.map create mode 100644 docs/c/s2let__transform__axisym__synthesis__mw__real_8c__incl.md5 delete mode 100644 docs/c/s2let__transform__axisym__synthesis__mw__real_8c_source.html create mode 100644 docs/c/s2let__types_8h__dep__incl.map create mode 100644 docs/c/s2let__types_8h__dep__incl.md5 create mode 100644 docs/c/s2let__types_8h__incl.map create mode 100644 docs/c/s2let__types_8h__incl.md5 create mode 100644 docs/c/search/all_12.html create mode 100644 docs/c/search/all_12.js create mode 100644 docs/c/search/files_1.html create mode 100644 docs/c/search/files_1.js create mode 100644 docs/c/search/functions_a.html create mode 100644 docs/c/search/functions_a.js create mode 100644 docs/c/structs2let__parameters__t-members.html create mode 100644 docs/c/test__adjoint_8c.html create mode 100644 docs/c/test__adjoint_8c__incl.map create mode 100644 docs/c/test__adjoint_8c__incl.md5 create mode 100644 docs/c/test__axisym__vs__directional_8c.html create mode 100644 docs/c/test__axisym__vs__directional_8c__incl.map create mode 100644 docs/c/test__axisym__vs__directional_8c__incl.md5 create mode 100644 docs/c/test__back__and__forth_8c.html create mode 100644 docs/c/test__back__and__forth_8c__incl.map create mode 100644 docs/c/test__back__and__forth_8c__incl.md5 create mode 100644 docs/c/test__tiling_8c.html create mode 100644 docs/c/test__tiling_8c__incl.map create mode 100644 docs/c/test__tiling_8c__incl.md5 diff --git a/CMakeLists.txt b/CMakeLists.txt index cf4ff1cb..92c718c8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -58,5 +58,8 @@ endif() find_package(Doxygen) if(DOXYGEN_FOUND) - doxygen_add_docs(docs WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/docs) + set(DOXYGEN_PROJECT_LOGO ${PROJECT_SOURCE_DIR}/docs/images/wav.png) + set(DOXYGEN_OPTIMIZE_OUTPUT_FOR_C "YES") + set(DOXYGEN_EXTRACT_ALL "YES") + doxygen_add_docs(docs src/main/c src/test/c include) endif() diff --git a/docs/c/annotated.html b/docs/c/annotated.html index 5697cc57..c4b474f0 100644 --- a/docs/c/annotated.html +++ b/docs/c/annotated.html @@ -5,7 +5,7 @@ -S2LET: Data Structures +s2let: Data Structures @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -76,7 +76,7 @@
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/classes.html b/docs/c/classes.html index 18fb6dec..c2092153 100644 --- a/docs/c/classes.html +++ b/docs/c/classes.html @@ -5,7 +5,7 @@ -S2LET: Data Structure Index +s2let: Data Structure Index @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -82,7 +82,7 @@
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/dir_000002_000000.html b/docs/c/dir_000002_000000.html new file mode 100644 index 00000000..60e6d2c6 --- /dev/null +++ b/docs/c/dir_000002_000000.html @@ -0,0 +1,77 @@ + + + + + + + +s2let: src/main -> include Relation + + + + + + + + + +
+
+ + + + + + + +
+
s2let +  2.2.0 +
+
Fast wavelets on the sphere
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+

main → include Relation

File in src/mainIncludes file in include
c / s2let_alloc.cs2let.h
c / s2let_analysis.cs2let.h
c / s2let_analysis_adjoint.cs2let.h
c / s2let_axisym_denoising_demo.cs2let.h
c / s2let_denoising_demo.cs2let.h
c / s2let_fits.cs2let.h
c / s2let_helper.cs2let.h
c / s2let_hpx.cs2let.h
c / s2let_hpx_demo.cs2let.h
c / s2let_idl_hpx.cs2let.h
c / s2let_idl_mw.cs2let.h
c / s2let_lm.cs2let.h
c / s2let_math.cs2let.h
c / s2let_mw.cs2let.h
c / s2let_spin_denoising_demo.cs2let.h
c / s2let_synthesis.cs2let.h
c / s2let_synthesis_adjoint.cs2let.h
c / s2let_tiling.cs2let.h
c / s2let_transform_axisym_analysis_hpx_real.cs2let.h
c / s2let_transform_axisym_analysis_mw_real.cs2let.h
c / s2let_transform_axisym_hpx.cs2let.h
c / s2let_transform_axisym_lm.cs2let.h
c / s2let_transform_axisym_mw.cs2let.h
c / s2let_transform_axisym_synthesis_hpx_real.cs2let.h
c / s2let_transform_axisym_synthesis_mw_real.cs2let.h
+ +
+Generated by doxygen 1.8.19 +
+ + diff --git a/docs/c/dir_000003_000000.html b/docs/c/dir_000003_000000.html new file mode 100644 index 00000000..f3b9d5b2 --- /dev/null +++ b/docs/c/dir_000003_000000.html @@ -0,0 +1,77 @@ + + + + + + + +s2let: src/main/c -> include Relation + + + + + + + + + +
+
+ + + + + + + +
+
s2let +  2.2.0 +
+
Fast wavelets on the sphere
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+

c → include Relation

File in src/main/cIncludes file in include
s2let_alloc.cs2let.h
s2let_analysis.cs2let.h
s2let_analysis_adjoint.cs2let.h
s2let_axisym_denoising_demo.cs2let.h
s2let_denoising_demo.cs2let.h
s2let_fits.cs2let.h
s2let_helper.cs2let.h
s2let_hpx.cs2let.h
s2let_hpx_demo.cs2let.h
s2let_idl_hpx.cs2let.h
s2let_idl_mw.cs2let.h
s2let_lm.cs2let.h
s2let_math.cs2let.h
s2let_mw.cs2let.h
s2let_spin_denoising_demo.cs2let.h
s2let_synthesis.cs2let.h
s2let_synthesis_adjoint.cs2let.h
s2let_tiling.cs2let.h
s2let_transform_axisym_analysis_hpx_real.cs2let.h
s2let_transform_axisym_analysis_mw_real.cs2let.h
s2let_transform_axisym_hpx.cs2let.h
s2let_transform_axisym_lm.cs2let.h
s2let_transform_axisym_mw.cs2let.h
s2let_transform_axisym_synthesis_hpx_real.cs2let.h
s2let_transform_axisym_synthesis_mw_real.cs2let.h
+ +
+Generated by doxygen 1.8.19 +
+ + diff --git a/docs/c/dir_000004_000000.html b/docs/c/dir_000004_000000.html new file mode 100644 index 00000000..2d4c5a90 --- /dev/null +++ b/docs/c/dir_000004_000000.html @@ -0,0 +1,77 @@ + + + + + + + +s2let: src/test -> include Relation + + + + + + + + + +
+
+ + + + + + + +
+
s2let +  2.2.0 +
+
Fast wavelets on the sphere
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+

test → include Relation

File in src/testIncludes file in include
c / s2let_hpx_test.cs2let.h
c / s2let_test.cs2let.h
c / s2let_test_csv.cs2let.h
c / test_adjoint.cs2let.h
c / test_axisym_vs_directional.cs2let.h
c / test_back_and_forth.cs2let.h
c / test_tiling.cs2let.h
+ +
+Generated by doxygen 1.8.19 +
+ + diff --git a/docs/c/dir_000005_000000.html b/docs/c/dir_000005_000000.html new file mode 100644 index 00000000..2a287d13 --- /dev/null +++ b/docs/c/dir_000005_000000.html @@ -0,0 +1,77 @@ + + + + + + + +s2let: src/test/c -> include Relation + + + + + + + + + +
+
+ + + + + + + +
+
s2let +  2.2.0 +
+
Fast wavelets on the sphere
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+

c → include Relation

File in src/test/cIncludes file in include
s2let_hpx_test.cs2let.h
s2let_test.cs2let.h
s2let_test_csv.cs2let.h
test_adjoint.cs2let.h
test_axisym_vs_directional.cs2let.h
test_back_and_forth.cs2let.h
test_tiling.cs2let.h
+ +
+Generated by doxygen 1.8.19 +
+ + diff --git a/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79.html b/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79.html index f2d5957b..f105eba1 100644 --- a/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79.html +++ b/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79.html @@ -5,7 +5,7 @@ -S2LET: src/test Directory Reference +s2let: src/test Directory Reference @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -72,6 +72,18 @@
test Directory Reference
+
+Directory dependency graph for test:
+
+
src/test
+ + + + + + + +
@@ -81,7 +93,7 @@
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79_dep.map b/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79_dep.map new file mode 100644 index 00000000..1c19eb87 --- /dev/null +++ b/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79_dep.map @@ -0,0 +1,7 @@ + + + + + + + diff --git a/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79_dep.md5 b/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79_dep.md5 new file mode 100644 index 00000000..c33a5657 --- /dev/null +++ b/docs/c/dir_120ed4da3e3217b1e7fc0b4f48568e79_dep.md5 @@ -0,0 +1 @@ +9d2c749d53438a276a668c54951803ba \ No newline at end of file diff --git a/docs/c/dir_2756d41f8717da58192571bd3d5ae320.html b/docs/c/dir_2756d41f8717da58192571bd3d5ae320.html index afc65e54..e0e092e0 100644 --- a/docs/c/dir_2756d41f8717da58192571bd3d5ae320.html +++ b/docs/c/dir_2756d41f8717da58192571bd3d5ae320.html @@ -5,7 +5,7 @@ -S2LET: src/test/c Directory Reference +s2let: src/test/c Directory Reference @@ -22,10 +22,10 @@ @@ -72,20 +72,39 @@
c Directory Reference
+
+Directory dependency graph for c:
+
+
src/test/c
+ + + + + + +

Directories

-
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
- + + + + + + + + + - + - +

Files

file  s2let_hpx_test.c [code]
file  s2let_hpx_test.c
 
file  s2let_test.c
 
file  s2let_test_csv.c
 
file  test_adjoint.c
 
file  test_axisym_vs_directional.c
 
file  s2let_test.c [code]
file  test_back_and_forth.c
 
file  s2let_test_csv.c [code]
file  test_tiling.c
 
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/dir_2756d41f8717da58192571bd3d5ae320_dep.map b/docs/c/dir_2756d41f8717da58192571bd3d5ae320_dep.map new file mode 100644 index 00000000..cb91ab91 --- /dev/null +++ b/docs/c/dir_2756d41f8717da58192571bd3d5ae320_dep.map @@ -0,0 +1,6 @@ + + + + + + diff --git a/docs/c/dir_2756d41f8717da58192571bd3d5ae320_dep.md5 b/docs/c/dir_2756d41f8717da58192571bd3d5ae320_dep.md5 new file mode 100644 index 00000000..5b1e44a6 --- /dev/null +++ b/docs/c/dir_2756d41f8717da58192571bd3d5ae320_dep.md5 @@ -0,0 +1 @@ +fb0b3897b7d876b96230e41423c0bc24 \ No newline at end of file diff --git a/docs/c/dir_5eb159725f84c66aafd839904a4acdd0.html b/docs/c/dir_5eb159725f84c66aafd839904a4acdd0.html index ba524b68..637a3d5c 100644 --- a/docs/c/dir_5eb159725f84c66aafd839904a4acdd0.html +++ b/docs/c/dir_5eb159725f84c66aafd839904a4acdd0.html @@ -5,7 +5,7 @@ -S2LET: src/main Directory Reference +s2let: src/main Directory Reference @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -72,6 +72,18 @@
main Directory Reference
+
+Directory dependency graph for main:
+
+
src/main
+ + + + + + + +
@@ -81,7 +93,7 @@
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/dir_5eb159725f84c66aafd839904a4acdd0_dep.map b/docs/c/dir_5eb159725f84c66aafd839904a4acdd0_dep.map new file mode 100644 index 00000000..10684cc3 --- /dev/null +++ b/docs/c/dir_5eb159725f84c66aafd839904a4acdd0_dep.map @@ -0,0 +1,7 @@ + + + + + + + diff --git a/docs/c/dir_5eb159725f84c66aafd839904a4acdd0_dep.md5 b/docs/c/dir_5eb159725f84c66aafd839904a4acdd0_dep.md5 new file mode 100644 index 00000000..3d7deea5 --- /dev/null +++ b/docs/c/dir_5eb159725f84c66aafd839904a4acdd0_dep.md5 @@ -0,0 +1 @@ +61f51a1513a402eb97432809781576b7 \ No newline at end of file diff --git a/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba.html index 57ac252f..41c6c29e 100644 --- a/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba.html +++ b/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -5,7 +5,7 @@ -S2LET: src Directory Reference +s2let: src Directory Reference @@ -22,10 +22,10 @@ @@ -72,6 +72,19 @@
src Directory Reference
+
+Directory dependency graph for src:
+
+
src
+ + + + + + + + +

Directories

-
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -83,7 +96,7 @@
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba_dep.map b/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba_dep.map new file mode 100644 index 00000000..e41cc586 --- /dev/null +++ b/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba_dep.map @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba_dep.md5 b/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba_dep.md5 new file mode 100644 index 00000000..c70684ed --- /dev/null +++ b/docs/c/dir_68267d1309a1af8e8297ef4c3efbcdba_dep.md5 @@ -0,0 +1 @@ +7651a30be759acc02ca6729d4223c00b \ No newline at end of file diff --git a/docs/c/dir_7420a7c8f71871d771403938d4d24c4a.html b/docs/c/dir_7420a7c8f71871d771403938d4d24c4a.html index d7743548..768bf832 100644 --- a/docs/c/dir_7420a7c8f71871d771403938d4d24c4a.html +++ b/docs/c/dir_7420a7c8f71871d771403938d4d24c4a.html @@ -5,7 +5,7 @@ -S2LET: src/main/c Directory Reference +s2let: src/main/c Directory Reference @@ -22,10 +22,10 @@ @@ -72,66 +72,77 @@
c Directory Reference
+
+Directory dependency graph for c:
+
+
src/main/c
+ + + + + + +

Directories

-
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
- + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - +

Files

file  s2let_about.c [code]
file  s2let_about.c
 
file  s2let_alloc.c [code]
file  s2let_alloc.c
 
file  s2let_analysis.c [code]
file  s2let_analysis.c
 
file  s2let_analysis_adjoint.c [code]
file  s2let_analysis_adjoint.c
 
file  s2let_axisym_denoising_demo.c [code]
file  s2let_axisym_denoising_demo.c
 
file  s2let_denoising_demo.c [code]
file  s2let_denoising_demo.c
 
file  s2let_fits.c [code]
file  s2let_fits.c
 
file  s2let_helper.c [code]
file  s2let_helper.c
 
file  s2let_hpx.c [code]
file  s2let_hpx.c
 
file  s2let_hpx_demo.c [code]
file  s2let_hpx_demo.c
 
file  s2let_idl_hpx.c [code]
file  s2let_idl_hpx.c
 
file  s2let_idl_mw.c [code]
file  s2let_idl_mw.c
 
file  s2let_lm.c [code]
file  s2let_lm.c
 
file  s2let_math.c [code]
file  s2let_math.c
 
file  s2let_mw.c [code]
file  s2let_mw.c
 
file  s2let_spin_denoising_demo.c [code]
file  s2let_spin_denoising_demo.c
 
file  s2let_synthesis.c [code]
file  s2let_synthesis.c
 
file  s2let_synthesis_adjoint.c [code]
file  s2let_synthesis_adjoint.c
 
file  s2let_tiling.c [code]
file  s2let_tiling.c
 
file  s2let_transform_axisym_analysis_hpx_real.c [code]
file  s2let_transform_axisym_analysis_hpx_real.c
 
file  s2let_transform_axisym_analysis_mw_real.c [code]
file  s2let_transform_axisym_analysis_mw_real.c
 
file  s2let_transform_axisym_hpx.c [code]
file  s2let_transform_axisym_hpx.c
 
file  s2let_transform_axisym_lm.c [code]
file  s2let_transform_axisym_lm.c
 
file  s2let_transform_axisym_mw.c [code]
file  s2let_transform_axisym_mw.c
 
file  s2let_transform_axisym_synthesis_hpx_real.c [code]
file  s2let_transform_axisym_synthesis_hpx_real.c
 
file  s2let_transform_axisym_synthesis_mw_real.c [code]
file  s2let_transform_axisym_synthesis_mw_real.c
 
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/dir_7420a7c8f71871d771403938d4d24c4a_dep.map b/docs/c/dir_7420a7c8f71871d771403938d4d24c4a_dep.map new file mode 100644 index 00000000..f00fff9c --- /dev/null +++ b/docs/c/dir_7420a7c8f71871d771403938d4d24c4a_dep.map @@ -0,0 +1,6 @@ + + + + + + diff --git a/docs/c/dir_7420a7c8f71871d771403938d4d24c4a_dep.md5 b/docs/c/dir_7420a7c8f71871d771403938d4d24c4a_dep.md5 new file mode 100644 index 00000000..7314907a --- /dev/null +++ b/docs/c/dir_7420a7c8f71871d771403938d4d24c4a_dep.md5 @@ -0,0 +1 @@ +c9cb171af120dbf61dd4af19196862b4 \ No newline at end of file diff --git a/docs/c/dir_d44c64559bbebec7f509842c48db8b23.html b/docs/c/dir_d44c64559bbebec7f509842c48db8b23.html index 88263adb..8f40a330 100644 --- a/docs/c/dir_d44c64559bbebec7f509842c48db8b23.html +++ b/docs/c/dir_d44c64559bbebec7f509842c48db8b23.html @@ -5,7 +5,7 @@ -S2LET: include Directory Reference +s2let: include Directory Reference @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -127,7 +127,7 @@
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/dynsections.js b/docs/c/dynsections.js index 88f2c27e..3174bd7b 100644 --- a/docs/c/dynsections.js +++ b/docs/c/dynsections.js @@ -119,10 +119,3 @@ function toggleInherit(id) } } /* @license-end */ - -$(document).ready(function() { - $('.code,.codeRef').each(function() { - $(this).data('powertip',$('#a'+$(this).attr('href').replace(/.*\//,'').replace(/[^a-z_A-Z0-9]/g,'_')).html()); - $(this).powerTip({ placement: 's', smartPlacement: true, mouseOnToPopup: true }); - }); -}); diff --git a/docs/c/files.html b/docs/c/files.html index 503f9c24..8eda25ad 100644 --- a/docs/c/files.html +++ b/docs/c/files.html @@ -5,7 +5,7 @@ -S2LET: File List +s2let: File List @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -98,43 +98,47 @@  ▼ src  ▼ main  ▼ c - s2let_about.c - s2let_alloc.c - s2let_analysis.c - s2let_analysis_adjoint.c - s2let_axisym_denoising_demo.c - s2let_denoising_demo.c - s2let_fits.c - s2let_helper.c - s2let_hpx.c - s2let_hpx_demo.c - s2let_idl_hpx.c - s2let_idl_mw.c - s2let_lm.c - s2let_math.c - s2let_mw.c - s2let_spin_denoising_demo.c - s2let_synthesis.c - s2let_synthesis_adjoint.c - s2let_tiling.c - s2let_transform_axisym_analysis_hpx_real.c - s2let_transform_axisym_analysis_mw_real.c - s2let_transform_axisym_hpx.c - s2let_transform_axisym_lm.c - s2let_transform_axisym_mw.c - s2let_transform_axisym_synthesis_hpx_real.c - s2let_transform_axisym_synthesis_mw_real.c + s2let_about.c + s2let_alloc.c + s2let_analysis.c + s2let_analysis_adjoint.c + s2let_axisym_denoising_demo.c + s2let_denoising_demo.c + s2let_fits.c + s2let_helper.c + s2let_hpx.c + s2let_hpx_demo.c + s2let_idl_hpx.c + s2let_idl_mw.c + s2let_lm.c + s2let_math.c + s2let_mw.c + s2let_spin_denoising_demo.c + s2let_synthesis.c + s2let_synthesis_adjoint.c + s2let_tiling.c + s2let_transform_axisym_analysis_hpx_real.c + s2let_transform_axisym_analysis_mw_real.c + s2let_transform_axisym_hpx.c + s2let_transform_axisym_lm.c + s2let_transform_axisym_mw.c + s2let_transform_axisym_synthesis_hpx_real.c + s2let_transform_axisym_synthesis_mw_real.c  ▼ test  ▼ c - s2let_hpx_test.c - s2let_test.c - s2let_test_csv.c + s2let_hpx_test.c + s2let_test.c + s2let_test_csv.c + test_adjoint.c + test_axisym_vs_directional.c + test_back_and_forth.c + test_tiling.c
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/functions.html b/docs/c/functions.html index 8647f21f..a7c8dcc0 100644 --- a/docs/c/functions.html +++ b/docs/c/functions.html @@ -5,7 +5,7 @@ -S2LET: Data Fields +s2let: Data Fields @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -102,7 +102,7 @@
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/functions_vars.html b/docs/c/functions_vars.html index 4da500b3..90627817 100644 --- a/docs/c/functions_vars.html +++ b/docs/c/functions_vars.html @@ -5,7 +5,7 @@ -S2LET: Data Fields - Variables +s2let: Data Fields - Variables @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -102,7 +102,7 @@
-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/globals.html b/docs/c/globals.html index 3466b6db..a553879b 100644 --- a/docs/c/globals.html +++ b/docs/c/globals.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -74,7 +74,7 @@

- a -

-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/globals_b.html b/docs/c/globals_b.html index 0b4abd63..24ff050f 100644 --- a/docs/c/globals_b.html +++ b/docs/c/globals_b.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -78,7 +78,7 @@

- b -

-Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
diff --git a/docs/c/globals_defs.html b/docs/c/globals_defs.html index d0d538dc..cf0cdb2e 100644 --- a/docs/c/globals_defs.html +++ b/docs/c/globals_defs.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
S2LET -  1.2.0 +
s2let +  2.2.0
-
Exact wavelets on the sphere
+
Fast wavelets on the sphere
@@ -113,11 +113,14 @@
  • S2LET_STRING_LEN : s2let_mex.h
    • +
  • S2LET_TESTS +: test_back_and_forth.c +
    • -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_enum.html b/docs/c/globals_enum.html index fea1fc37..eda1602f 100644 --- a/docs/c/globals_enum.html +++ b/docs/c/globals_enum.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,7 +75,7 @@
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_eval.html b/docs/c/globals_eval.html index 8335660f..1db796d1 100644 --- a/docs/c/globals_eval.html +++ b/docs/c/globals_eval.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -87,7 +87,7 @@
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_f.html b/docs/c/globals_f.html index 7170fd46..be5e5cdb 100644 --- a/docs/c/globals_f.html +++ b/docs/c/globals_f.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -77,7 +77,7 @@

    - f -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func.html b/docs/c/globals_func.html index 23bcf27d..c9f5dc67 100644 --- a/docs/c/globals_func.html +++ b/docs/c/globals_func.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -78,7 +78,7 @@

    - b -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func_f.html b/docs/c/globals_func_f.html index 54c877c7..e248a7fe 100644 --- a/docs/c/globals_func_f.html +++ b/docs/c/globals_func_f.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -77,7 +77,7 @@

    - f -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func_g.html b/docs/c/globals_func_g.html index 709b891a..421da110 100644 --- a/docs/c/globals_func_g.html +++ b/docs/c/globals_func_g.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -67,6 +67,9 @@  

    - g -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func_h.html b/docs/c/globals_func_h.html index 5862404a..257f6372 100644 --- a/docs/c/globals_func_h.html +++ b/docs/c/globals_func_h.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -90,7 +90,7 @@

    - h -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func_m.html b/docs/c/globals_func_m.html index 3e81ef01..54390f57 100644 --- a/docs/c/globals_func_m.html +++ b/docs/c/globals_func_m.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func_n.html b/docs/c/globals_func_n.html index ab57e687..9eb52999 100644 --- a/docs/c/globals_func_n.html +++ b/docs/c/globals_func_n.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,7 +75,7 @@

    - n -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func_p.html b/docs/c/globals_func_p.html index 37b81bf6..7bcfc42e 100644 --- a/docs/c/globals_func_p.html +++ b/docs/c/globals_func_p.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,7 +74,7 @@

    - p -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func_r.html b/docs/c/globals_func_r.html index 469cf936..a3b1d9a7 100644 --- a/docs/c/globals_func_r.html +++ b/docs/c/globals_func_r.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -82,7 +82,7 @@

    - r -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func_s.html b/docs/c/globals_func_s.html index f29f688a..4b826bdd 100644 --- a/docs/c/globals_func_s.html +++ b/docs/c/globals_func_s.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -72,8 +72,8 @@

    - s -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_func_t.html b/docs/c/globals_func_t.html new file mode 100644 index 00000000..2865edf0 --- /dev/null +++ b/docs/c/globals_func_t.html @@ -0,0 +1,161 @@ + + + + + + + +s2let: Globals + + + + + + + + + +
    +
    + + + + + + + +
    +
    s2let +  2.2.0 +
    +
    Fast wavelets on the sphere
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +  + +

    - t -

    +
    + +
    +Generated by doxygen 1.8.19 +
    + + diff --git a/docs/c/globals_func_w.html b/docs/c/globals_func_w.html index b73b8048..d35deef9 100644 --- a/docs/c/globals_func_w.html +++ b/docs/c/globals_func_w.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -79,7 +79,7 @@

    - w -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_g.html b/docs/c/globals_g.html index c2395233..f67a488c 100644 --- a/docs/c/globals_g.html +++ b/docs/c/globals_g.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -67,6 +67,9 @@
    Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:

    - g -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_h.html b/docs/c/globals_h.html index 1dad0c19..4d7e587b 100644 --- a/docs/c/globals_h.html +++ b/docs/c/globals_h.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -90,7 +90,7 @@

    - h -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_i.html b/docs/c/globals_i.html index c9de91d3..bf8af0a9 100644 --- a/docs/c/globals_i.html +++ b/docs/c/globals_i.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -95,7 +95,7 @@

    - i -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_m.html b/docs/c/globals_m.html index 11c060be..50b960c0 100644 --- a/docs/c/globals_m.html +++ b/docs/c/globals_m.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_n.html b/docs/c/globals_n.html index ca580994..7972617d 100644 --- a/docs/c/globals_n.html +++ b/docs/c/globals_n.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -81,7 +81,7 @@

    - n -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_p.html b/docs/c/globals_p.html index 9cc5c3f1..4375b238 100644 --- a/docs/c/globals_p.html +++ b/docs/c/globals_p.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -78,7 +78,7 @@

    - p -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_r.html b/docs/c/globals_r.html index 6d43f8c9..0d013a25 100644 --- a/docs/c/globals_r.html +++ b/docs/c/globals_r.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -82,7 +82,7 @@

    - r -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_s.html b/docs/c/globals_s.html index 86d0b943..7e11c742 100644 --- a/docs/c/globals_s.html +++ b/docs/c/globals_s.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,8 +75,8 @@

    - s -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_t.html b/docs/c/globals_t.html new file mode 100644 index 00000000..d0e90d37 --- /dev/null +++ b/docs/c/globals_t.html @@ -0,0 +1,161 @@ + + + + + + + +s2let: Globals + + + + + + + + + +
    +
    + + + + + + + +
    +
    s2let +  2.2.0 +
    +
    Fast wavelets on the sphere
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +
    Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
    + +

    - t -

    +
    + +
    +Generated by doxygen 1.8.19 +
    + + diff --git a/docs/c/globals_type.html b/docs/c/globals_type.html index b46b2ec4..f1f157aa 100644 --- a/docs/c/globals_type.html +++ b/docs/c/globals_type.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -85,7 +85,7 @@
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_vars.html b/docs/c/globals_vars.html index dc7f415d..f640466a 100644 --- a/docs/c/globals_vars.html +++ b/docs/c/globals_vars.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -68,11 +68,17 @@
  • s2let_kernel : s2let_tiling.c
    • +
  • seed +: test_tiling.c +, test_back_and_forth.c +, test_axisym_vs_directional.c +, test_adjoint.c +
    • -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/globals_w.html b/docs/c/globals_w.html index 260193e2..5abd711a 100644 --- a/docs/c/globals_w.html +++ b/docs/c/globals_w.html @@ -5,7 +5,7 @@ -S2LET: Globals +s2let: Globals @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -79,7 +79,7 @@

    - w -

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/graph_legend.html b/docs/c/graph_legend.html new file mode 100644 index 00000000..6ce5f7cb --- /dev/null +++ b/docs/c/graph_legend.html @@ -0,0 +1,137 @@ + + + + + + + +s2let: Graph Legend + + + + + + + + + +
    +
    + + + + + + + +
    +
    s2let +  2.2.0 +
    +
    Fast wavelets on the sphere
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +
    +
    Graph Legend
    +
    +
    +

    This page explains how to interpret the graphs that are generated by doxygen.

    +

    Consider the following example:

    /*! Invisible class because of truncation */
    +
    class Invisible { };
    +
    +
    /*! Truncated class, inheritance relation is hidden */
    +
    class Truncated : public Invisible { };
    +
    +
    /* Class not documented with doxygen comments */
    +
    class Undocumented { };
    +
    +
    /*! Class that is inherited using public inheritance */
    +
    class PublicBase : public Truncated { };
    +
    +
    /*! A template class */
    +
    template<class T> class Templ { };
    +
    +
    /*! Class that is inherited using protected inheritance */
    +
    class ProtectedBase { };
    +
    +
    /*! Class that is inherited using private inheritance */
    +
    class PrivateBase { };
    +
    +
    /*! Class that is used by the Inherited class */
    +
    class Used { };
    +
    +
    /*! Super class that inherits a number of other classes */
    +
    class Inherited : public PublicBase,
    +
    protected ProtectedBase,
    +
    private PrivateBase,
    +
    public Undocumented,
    +
    public Templ<int>
    +
    {
    +
    private:
    +
    Used *m_usedClass;
    +
    };
    +

    This will result in the following graph:

    +

    The boxes in the above graph have the following meaning:

    +
      +
    • +A filled gray box represents the struct or class for which the graph is generated.
      • +
    • +A box with a black border denotes a documented struct or class.
      • +
    • +A box with a gray border denotes an undocumented struct or class.
      • +
    • +A box with a red border denotes a documented struct or class forwhich not all inheritance/containment relations are shown. A graph is truncated if it does not fit within the specified boundaries.
      • +
    +

    The arrows have the following meaning:

    +
      +
    • +A dark blue arrow is used to visualize a public inheritance relation between two classes.
      • +
    • +A dark green arrow is used for protected inheritance.
      • +
    • +A dark red arrow is used for private inheritance.
      • +
    • +A purple dashed arrow is used if a class is contained or used by another class. The arrow is labelled with the variable(s) through which the pointed class or struct is accessible.
      • +
    • +A yellow dashed arrow denotes a relation between a template instance and the template class it was instantiated from. The arrow is labelled with the template parameters of the instance.
      • +
    +
    + +
    +Generated by doxygen 1.8.19 +
    + + diff --git a/docs/c/graph_legend.md5 b/docs/c/graph_legend.md5 new file mode 100644 index 00000000..8fcdccd1 --- /dev/null +++ b/docs/c/graph_legend.md5 @@ -0,0 +1 @@ +f51bf6e9a10430aafef59831b08dcbfe \ No newline at end of file diff --git a/docs/c/index.html b/docs/c/index.html index ece95c6f..e63d53e4 100644 --- a/docs/c/index.html +++ b/docs/c/index.html @@ -5,7 +5,7 @@ -S2LET: Main Page +s2let: Main Page @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -65,13 +65,13 @@
    -
    S2LET Documentation
    +
    s2let Documentation
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/menudata.js b/docs/c/menudata.js index 8c4e5107..ebcfb0b5 100644 --- a/docs/c/menudata.js +++ b/docs/c/menudata.js @@ -45,6 +45,7 @@ var menudata={children:[ {text:"p",url:"globals_p.html#index_p"}, {text:"r",url:"globals_r.html#index_r"}, {text:"s",url:"globals_s.html#index_s"}, +{text:"t",url:"globals_t.html#index_t"}, {text:"w",url:"globals_w.html#index_w"}]}, {text:"Functions",url:"globals_func.html",children:[ {text:"b",url:"globals_func.html#index_b"}, @@ -56,6 +57,7 @@ var menudata={children:[ {text:"p",url:"globals_func_p.html#index_p"}, {text:"r",url:"globals_func_r.html#index_r"}, {text:"s",url:"globals_func_s.html#index_s"}, +{text:"t",url:"globals_func_t.html#index_t"}, {text:"w",url:"globals_func_w.html#index_w"}]}, {text:"Variables",url:"globals_vars.html"}, {text:"Typedefs",url:"globals_type.html"}, diff --git a/docs/c/s2let_8h.html b/docs/c/s2let_8h.html index 8e74dcb3..cecd8a62 100644 --- a/docs/c/s2let_8h.html +++ b/docs/c/s2let_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let.h File Reference +s2let: include/s2let.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -73,7 +73,6 @@
    #include <ssht/ssht.h>
    -#include "s2let_types.h"
    #include "s2let_alloc.h"
    #include "s2let_analysis.h"
    #include "s2let_analysis_adjoint.h"
    @@ -93,12 +92,86 @@ #include "s2let_transform_axisym_hpx.h"
    #include "s2let_transform_axisym_lm.h"
    #include "s2let_transform_axisym_mw.h"
    +#include "s2let_types.h"
    +
    +Include dependency graph for s2let.h:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let_8h__dep__incl.map b/docs/c/s2let_8h__dep__incl.map new file mode 100644 index 00000000..2141d5a3 --- /dev/null +++ b/docs/c/s2let_8h__dep__incl.map @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let_8h__dep__incl.md5 b/docs/c/s2let_8h__dep__incl.md5 new file mode 100644 index 00000000..20b242ca --- /dev/null +++ b/docs/c/s2let_8h__dep__incl.md5 @@ -0,0 +1 @@ +ec0c18150ef9065ce3471c82f7c0eb0b \ No newline at end of file diff --git a/docs/c/s2let_8h__incl.map b/docs/c/s2let_8h__incl.map new file mode 100644 index 00000000..e7f70695 --- /dev/null +++ b/docs/c/s2let_8h__incl.map @@ -0,0 +1,28 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let_8h__incl.md5 b/docs/c/s2let_8h__incl.md5 new file mode 100644 index 00000000..b8af7414 --- /dev/null +++ b/docs/c/s2let_8h__incl.md5 @@ -0,0 +1 @@ +2c73976587779fac08e5ed3456d82266 \ No newline at end of file diff --git a/docs/c/s2let_8h_source.html b/docs/c/s2let_8h_source.html index 330180c2..8293a8f3 100644 --- a/docs/c/s2let_8h_source.html +++ b/docs/c/s2let_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let.h Source File +s2let: include/s2let.h Source File @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,27 +75,27 @@ Go to the documentation of this file.
    1 #ifndef S2LET
    2 #define S2LET
    3 #include <ssht/ssht.h>
    -
    4 #include "s2let_types.h"
    -
    5 
    -
    6 #include "s2let_alloc.h"
    -
    7 #include "s2let_analysis.h"
    -
    8 #include "s2let_analysis_adjoint.h"
    -
    9 #include "s2let_error.h"
    -
    10 #include "s2let_fits.h"
    -
    11 #include "s2let_helper.h"
    -
    12 #include "s2let_hpx.h"
    -
    13 #include "s2let_idl_hpx.h"
    -
    14 #include "s2let_idl_mw.h"
    -
    15 #include "s2let_lm.h"
    -
    16 #include "s2let_math.h"
    -
    17 #include "s2let_mw.h"
    -
    18 #include "s2let_so3.h"
    -
    19 #include "s2let_synthesis.h"
    -
    20 #include "s2let_synthesis_adjoint.h"
    -
    21 #include "s2let_tiling.h"
    -
    22 #include "s2let_transform_axisym_hpx.h"
    -
    23 #include "s2let_transform_axisym_lm.h"
    -
    24 #include "s2let_transform_axisym_mw.h"
    +
    4 
    +
    5 #include "s2let_alloc.h"
    +
    6 #include "s2let_analysis.h"
    +
    7 #include "s2let_analysis_adjoint.h"
    +
    8 #include "s2let_error.h"
    +
    9 #include "s2let_fits.h"
    +
    10 #include "s2let_helper.h"
    +
    11 #include "s2let_hpx.h"
    +
    12 #include "s2let_idl_hpx.h"
    +
    13 #include "s2let_idl_mw.h"
    +
    14 #include "s2let_lm.h"
    +
    15 #include "s2let_math.h"
    +
    16 #include "s2let_mw.h"
    +
    17 #include "s2let_so3.h"
    +
    18 #include "s2let_synthesis.h"
    +
    19 #include "s2let_synthesis_adjoint.h"
    +
    20 #include "s2let_tiling.h"
    +
    21 #include "s2let_transform_axisym_hpx.h"
    +
    22 #include "s2let_transform_axisym_lm.h"
    +
    23 #include "s2let_transform_axisym_mw.h"
    +
    24 #include "s2let_types.h"
    25 
    26 #endif
    @@ -121,7 +121,7 @@
    s2let_mw.h
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__about_8c.html b/docs/c/s2let__about_8c.html index 26f23a8d..6e10bd6f 100644 --- a/docs/c/s2let__about_8c.html +++ b/docs/c/s2let__about_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_about.c File Reference +s2let: src/main/c/s2let_about.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,9 +75,16 @@
    #include <stdio.h>
    +
    +Include dependency graph for s2let_about.c:
    +
    +
    + + + +
    -

    Go to the source code of this file.

    - +
    @@ -86,8 +93,6 @@

    Detailed Description

    Print information about the S2LET package, including version and build numbers.

    Usage: s2let_about

    - -

    Definition in file s2let_about.c.

    Function Documentation

    ◆ main()

    @@ -115,14 +120,12 @@

    -

    Definition at line 16 of file s2let_about.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__about_8c__incl.map b/docs/c/s2let__about_8c__incl.map new file mode 100644 index 00000000..22c494ac --- /dev/null +++ b/docs/c/s2let__about_8c__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__about_8c__incl.md5 b/docs/c/s2let__about_8c__incl.md5 new file mode 100644 index 00000000..47e21214 --- /dev/null +++ b/docs/c/s2let__about_8c__incl.md5 @@ -0,0 +1 @@ +1376194a41fb8260bd8eedef69739be2 \ No newline at end of file diff --git a/docs/c/s2let__about_8c_source.html b/docs/c/s2let__about_8c_source.html deleted file mode 100644 index 5a32b4be..00000000 --- a/docs/c/s2let__about_8c_source.html +++ /dev/null @@ -1,104 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_about.c Source File - - - - - - - - - -
    -
    -

    Functions

    int main (int argc, char *argv[])
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_about.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    14 #include <stdio.h>
    -
    15 
    -
    16 int main(int argc, char *argv[]) {
    -
    17 
    -
    18  printf("%s\n", "==========================================================");
    -
    19  printf("%s\n", " S2LET package");
    -
    20  printf("%s\n", " Fast Wavelets on the Sphere");
    -
    21  printf("%s\n", " By Boris Leistedt & Jason McEwen");
    -
    22 
    -
    23  printf("%s\n", " See LICENSE.txt for license details.");
    -
    24 
    -
    25  printf("%s%s\n", " Version: ", S2LET_VERSION);
    -
    26  printf("%s%s\n", " Build: ", S2LET_BUILD);
    -
    27  printf("%s\n", "==========================================================");
    -
    28 
    -
    29  return 0;
    -
    30 
    -
    31 }
    -
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_about.c:16
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__alloc_8c.html b/docs/c/s2let__alloc_8c.html index 5bf744b0..b602a000 100644 --- a/docs/c/s2let__alloc_8c.html +++ b/docs/c/s2let__alloc_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_alloc.c File Reference +s2let: src/main/c/s2let_alloc.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,16 +74,50 @@
    s2let_alloc.c File Reference
    -
    #include "s2let.h"
    +
    #include <complex.h>
    +#include <math.h>
    #include <so3/so3.h>
    #include <ssht/ssht.h>
    -#include <complex.h>
    -#include <math.h>
    -#include <stdlib.h>
    #include <stdio.h>
    +#include <stdlib.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_alloc.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -102,8 +136,8 @@ - - + +

    Functions

    void s2let_allocate_mw (complex double **f, int L)
     
    void s2let_allocate_f_wav_real (double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
     
    void s2let_allocate_f_wav_manual (complex double **f_wav, complex double **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, s2let_parameters_t *parameters)
     
    void s2let_allocate_f_wav_manual (complex double **f_wav, complex double **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, const s2let_parameters_t *parameters)
     

    Function Documentation

    @@ -153,12 +187,10 @@

    Definition at line 105 of file s2let_alloc.c.

    -

    - -

    ◆ s2let_allocate_f_wav_manual()

    + +

    ◆ s2let_allocate_f_wav_manual()

    @@ -202,7 +234,7 @@

    - s2let_parameters_t *  + const s2let_parameters_t *  parameters  @@ -232,8 +264,6 @@

    Definition at line 156 of file s2let_alloc.c.

    -

    @@ -283,8 +313,6 @@

    Definition at line 128 of file s2let_alloc.c.

    -

    @@ -327,8 +355,6 @@

    Definition at line 62 of file s2let_alloc.c.

    - @@ -378,8 +404,6 @@

    Definition at line 82 of file s2let_alloc.c.

    - @@ -415,8 +439,6 @@

    Definition at line 18 of file s2let_alloc.c.

    - @@ -452,8 +474,6 @@

    Definition at line 28 of file s2let_alloc.c.

    - @@ -489,8 +509,6 @@

    Definition at line 38 of file s2let_alloc.c.

    - @@ -526,14 +544,12 @@

    Definition at line 48 of file s2let_alloc.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__alloc_8c__incl.map b/docs/c/s2let__alloc_8c__incl.map new file mode 100644 index 00000000..fa5b1570 --- /dev/null +++ b/docs/c/s2let__alloc_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__alloc_8c__incl.md5 b/docs/c/s2let__alloc_8c__incl.md5 new file mode 100644 index 00000000..9ce87c2f --- /dev/null +++ b/docs/c/s2let__alloc_8c__incl.md5 @@ -0,0 +1 @@ +16c99823824ea97f090b2fc21a07f5dd \ No newline at end of file diff --git a/docs/c/s2let__alloc_8c_source.html b/docs/c/s2let__alloc_8c_source.html deleted file mode 100644 index 18fb38e7..00000000 --- a/docs/c/s2let__alloc_8c_source.html +++ /dev/null @@ -1,193 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_alloc.c Source File - - - - - - - - - -
    -
    - - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_alloc.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <so3/so3.h>
    -
    7 #include <ssht/ssht.h>
    -
    8 #include <complex.h>
    -
    9 #include <math.h>
    -
    10 #include <stdlib.h>
    -
    11 #include <stdio.h>
    -
    12 
    -
    18 void s2let_allocate_mw(complex double **f, int L)
    -
    19 {
    -
    20  *f = calloc(L * (2*L-1), sizeof **f);
    -
    21 }
    -
    22 
    -
    28 void s2let_allocate_mw_real(double **f, int L)
    -
    29 {
    -
    30  *f = calloc(L * (2*L-1), sizeof **f);
    -
    31 }
    -
    32 
    -
    38 void s2let_allocate_mwss(complex double **f, int L)
    -
    39 {
    -
    40  *f = calloc((2*L)*(L+1), sizeof **f);
    -
    41 }
    -
    42 
    -
    48 void s2let_allocate_mwss_real(double **f, int L)
    -
    49 {
    -
    50  *f = calloc((2*L)*(L+1), sizeof **f);
    -
    51 }
    -
    52 
    -
    62 void s2let_allocate_lm(complex double **flm, int L)
    -
    63 {
    -
    64  *flm = calloc(L * L, sizeof **flm);
    -
    65 }
    -
    66 
    -
    82 void s2let_allocate_lmn_f_wav(
    -
    83  complex double **f_wav_lmn,
    -
    84  complex double **f_scal_lm,
    -
    85  const s2let_parameters_t *parameters
    -
    86 ) {
    -
    87  *f_wav_lmn = calloc(s2let_n_lmn_wav(parameters), sizeof **f_wav_lmn);
    -
    88  *f_scal_lm = calloc(s2let_n_lm_scal(parameters), sizeof **f_scal_lm);
    -
    89 }
    -
    90 
    -
    105 void s2let_allocate_f_wav(
    -
    106  complex double **f_wav,
    -
    107  complex double **f_scal,
    -
    108  const s2let_parameters_t *parameters
    -
    109 ) {
    -
    110  *f_wav = calloc(s2let_n_wav(parameters), sizeof **f_wav);
    -
    111  *f_scal = calloc(s2let_n_scal(parameters), sizeof **f_scal);
    -
    112 }
    -
    113 
    -
    128 void s2let_allocate_f_wav_real(
    -
    129  double **f_wav,
    -
    130  double **f_scal,
    -
    131  const s2let_parameters_t *parameters
    -
    132 ) {
    -
    133  *f_wav = calloc(s2let_n_wav(parameters), sizeof **f_wav);
    -
    134  *f_scal = calloc(s2let_n_scal(parameters), sizeof **f_scal);
    -
    135 }
    -
    136 
    -
    156 void s2let_allocate_f_wav_manual(
    -
    157  complex double **f_wav,
    -
    158  complex double **f_scal,
    -
    159  int *wav_bandlimits,
    -
    160  int scal_bandlimit,
    -
    161  int N,
    -
    162  int J,
    -
    163  s2let_parameters_t *parameters
    -
    164 ) {
    -
    165 
    -
    166  so3_parameters_t so3_parameters = {};
    -
    167  fill_so3_parameters(&so3_parameters, parameters);
    -
    168 
    -
    169  int j, total=0;
    -
    170  for (j = 0; j <= J; ++j)
    -
    171  {
    -
    172  if (!parameters->upsample)
    -
    173  {
    -
    174  so3_parameters.L = wav_bandlimits[j];
    -
    175  }
    -
    176  total += so3_sampling_f_size(&so3_parameters);
    -
    177  }
    -
    178 
    -
    179  s2let_parameters_t bl_parameters = *parameters;
    -
    180  bl_parameters.L = scal_bandlimit;
    -
    181 
    -
    182  *f_wav = calloc(total, sizeof **f_wav);
    -
    183  *f_scal = calloc(s2let_n_phi(&bl_parameters) * s2let_n_theta(&bl_parameters), sizeof **f_scal);
    -
    184 }
    -
    -
    s2let_allocate_mwss_real
    void s2let_allocate_mwss_real(double **f, int L)
    Definition: s2let_alloc.c:48
    -
    s2let_allocate_f_wav_manual
    void s2let_allocate_f_wav_manual(complex double **f_wav, complex double **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:156
    -
    s2let_allocate_mw
    void s2let_allocate_mw(complex double **f, int L)
    Definition: s2let_alloc.c:18
    -
    s2let_allocate_f_wav_real
    void s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:128
    -
    s2let_n_lm_scal
    int s2let_n_lm_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:31
    -
    s2let_n_theta
    int s2let_n_theta(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:12
    -
    s2let_n_wav
    int s2let_n_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:88
    - -
    s2let_n_phi
    int s2let_n_phi(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:4
    -
    s2let_allocate_lmn_f_wav
    void s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:82
    -
    s2let_allocate_mw_real
    void s2let_allocate_mw_real(double **f, int L)
    Definition: s2let_alloc.c:28
    -
    s2let_n_scal
    int s2let_n_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:74
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_n_lmn_wav
    int s2let_n_lmn_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:42
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_allocate_f_wav
    void s2let_allocate_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:105
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_allocate_mwss
    void s2let_allocate_mwss(complex double **f, int L)
    Definition: s2let_alloc.c:38
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__alloc_8h.html b/docs/c/s2let__alloc_8h.html index 46e9dd8d..efcee801 100644 --- a/docs/c/s2let__alloc_8h.html +++ b/docs/c/s2let__alloc_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_alloc.h File Reference +s2let: include/s2let_alloc.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,58 @@
    #include <ssht/ssht.h>
    +#include "s2let_types.h"
    +
    +Include dependency graph for s2let_alloc.h:
    +
    +
    + + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -96,8 +148,8 @@ - - + +
     
    void s2let_allocate_f_wav_real (double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
     
    void s2let_allocate_f_wav_manual (S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, s2let_parameters_t *parameters)
     
    void s2let_allocate_f_wav_manual (S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, const s2let_parameters_t *parameters)
     

    Function Documentation

    @@ -135,8 +187,8 @@

    -

    ◆ s2let_allocate_f_wav_manual()

    + +

    ◆ s2let_allocate_f_wav_manual()

    @@ -180,7 +232,7 @@

    - s2let_parameters_t *  + const s2let_parameters_t *  parameters  @@ -240,8 +292,6 @@

    Definition at line 128 of file s2let_alloc.c.

    -

    @@ -370,8 +420,6 @@

    Definition at line 28 of file s2let_alloc.c.

    -

    @@ -435,14 +483,12 @@

    Definition at line 48 of file s2let_alloc.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__alloc_8h__dep__incl.map b/docs/c/s2let__alloc_8h__dep__incl.map new file mode 100644 index 00000000..39cf38fc --- /dev/null +++ b/docs/c/s2let__alloc_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__alloc_8h__dep__incl.md5 b/docs/c/s2let__alloc_8h__dep__incl.md5 new file mode 100644 index 00000000..74c2ff9d --- /dev/null +++ b/docs/c/s2let__alloc_8h__dep__incl.md5 @@ -0,0 +1 @@ +d5883afd5ecca568e6db571c60eb1b0c \ No newline at end of file diff --git a/docs/c/s2let__alloc_8h__incl.map b/docs/c/s2let__alloc_8h__incl.map new file mode 100644 index 00000000..19f0c20e --- /dev/null +++ b/docs/c/s2let__alloc_8h__incl.map @@ -0,0 +1,5 @@ + + + + + diff --git a/docs/c/s2let__alloc_8h__incl.md5 b/docs/c/s2let__alloc_8h__incl.md5 new file mode 100644 index 00000000..1a8cc459 --- /dev/null +++ b/docs/c/s2let__alloc_8h__incl.md5 @@ -0,0 +1 @@ +150b065c1da6ff32316fb2c7d03dbf92 \ No newline at end of file diff --git a/docs/c/s2let__alloc_8h_source.html b/docs/c/s2let__alloc_8h_source.html index 6a3953e2..b72dcd22 100644 --- a/docs/c/s2let__alloc_8h_source.html +++ b/docs/c/s2let__alloc_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_alloc.h Source File +s2let: include/s2let_alloc.h Source File @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -80,62 +80,64 @@
    6 #define S2LET_ALLOC
    7 
    8 #include <ssht/ssht.h>
    -
    9 
    -
    10 #ifdef __cplusplus
    -
    11 extern "C" {
    -
    12 #endif
    -
    13 
    -
    15 void s2let_allocate_mw(S2LET_COMPLEX(double) **f, int L);
    -
    16 void s2let_allocate_mw_real(double** f, int L);
    -
    17 
    -
    18 void s2let_allocate_mwss(S2LET_COMPLEX(double) **f, int L);
    -
    19 void s2let_allocate_mwss_real(double** f, int L);
    -
    20 
    -
    23 void s2let_allocate_lm(S2LET_COMPLEX(double) **flm, int L);
    -
    24 
    -
    27 void s2let_allocate_lmn_f_wav(
    -
    28  S2LET_COMPLEX(double) **f_wav_lmn,
    -
    29  S2LET_COMPLEX(double) **f_scal_lm,
    -
    30  const s2let_parameters_t* parameters);
    -
    31 
    -
    34 void s2let_allocate_f_wav(
    -
    35  S2LET_COMPLEX(double) **f_wav,
    -
    36  S2LET_COMPLEX(double) **f_scal,
    -
    37  const s2let_parameters_t* parameters);
    -
    38 
    -
    39 void s2let_allocate_f_wav_real(
    -
    40  double** f_wav,
    -
    41  double** f_scal,
    -
    42  const s2let_parameters_t* parameters);
    -
    43 
    -
    44 void s2let_allocate_f_wav_manual(
    -
    45  S2LET_COMPLEX(double) **f_wav,
    -
    46  S2LET_COMPLEX(double) **f_scal,
    -
    47  int* wav_bandlimits,
    -
    48  int scal_bandlimit,
    -
    49  int N,
    -
    50  int J,
    -
    51  s2let_parameters_t* parameters);
    -
    52 
    -
    53 #ifdef __cplusplus
    -
    54 }
    -
    55 #endif
    +
    9 #include "s2let_types.h"
    +
    10 
    +
    11 #ifdef __cplusplus
    +
    12 extern "C" {
    +
    13 #endif
    +
    14 
    +
    16 void s2let_allocate_mw(S2LET_COMPLEX(double) **f, int L);
    +
    17 void s2let_allocate_mw_real(double** f, int L);
    +
    18 
    +
    19 void s2let_allocate_mwss(S2LET_COMPLEX(double) **f, int L);
    +
    20 void s2let_allocate_mwss_real(double** f, int L);
    +
    21 
    +
    24 void s2let_allocate_lm(S2LET_COMPLEX(double) **flm, int L);
    +
    25 
    +
    28 void s2let_allocate_lmn_f_wav(
    +
    29  S2LET_COMPLEX(double) **f_wav_lmn,
    +
    30  S2LET_COMPLEX(double) **f_scal_lm,
    +
    31  const s2let_parameters_t* parameters);
    +
    32 
    +
    35 void s2let_allocate_f_wav(
    +
    36  S2LET_COMPLEX(double) **f_wav,
    +
    37  S2LET_COMPLEX(double) **f_scal,
    +
    38  const s2let_parameters_t* parameters);
    +
    39 
    +
    40 void s2let_allocate_f_wav_real(
    +
    41  double** f_wav,
    +
    42  double** f_scal,
    +
    43  const s2let_parameters_t* parameters);
    +
    44 
    +
    45 void s2let_allocate_f_wav_manual(
    +
    46  S2LET_COMPLEX(double) **f_wav,
    +
    47  S2LET_COMPLEX(double) **f_scal,
    +
    48  int* wav_bandlimits,
    +
    49  int scal_bandlimit,
    +
    50  int N,
    +
    51  int J,
    +
    52  const s2let_parameters_t* parameters);
    +
    53 
    +
    54 #ifdef __cplusplus
    +
    55 }
    56 #endif
    +
    57 #endif
    -
    s2let_allocate_f_wav_manual
    void s2let_allocate_f_wav_manual(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, s2let_parameters_t *parameters)
    s2let_allocate_mw
    void s2let_allocate_mw(S2LET_COMPLEX(double) **f, int L)
    s2let_allocate_lmn_f_wav
    void s2let_allocate_lmn_f_wav(S2LET_COMPLEX(double) **f_wav_lmn, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters)
    -
    s2let_allocate_mwss_real
    void s2let_allocate_mwss_real(double **f, int L)
    Definition: s2let_alloc.c:48
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    -
    s2let_allocate_mw_real
    void s2let_allocate_mw_real(double **f, int L)
    Definition: s2let_alloc.c:28
    +
    s2let_allocate_mwss_real
    void s2let_allocate_mwss_real(double **f, int L)
    Definition: s2let_alloc.c:46
    +
    s2let_allocate_f_wav_manual
    void s2let_allocate_f_wav_manual(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, const s2let_parameters_t *parameters)
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    s2let_allocate_mw_real
    void s2let_allocate_mw_real(double **f, int L)
    Definition: s2let_alloc.c:28
    s2let_allocate_lm
    void s2let_allocate_lm(S2LET_COMPLEX(double) **flm, int L)
    s2let_allocate_mwss
    void s2let_allocate_mwss(S2LET_COMPLEX(double) **f, int L)
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_allocate_f_wav_real
    void s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:128
    +
    s2let_types.h
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_allocate_f_wav_real
    void s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:122
    s2let_allocate_f_wav
    void s2let_allocate_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters)
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__analysis_8c.html b/docs/c/s2let__analysis_8c.html index ae0d3ecd..526050a2 100644 --- a/docs/c/s2let__analysis_8c.html +++ b/docs/c/s2let__analysis_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_analysis.c File Reference +s2let: src/main/c/s2let_analysis.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,16 +74,50 @@
    s2let_analysis.c File Reference
    -
    #include "s2let.h"
    +
    #include <complex.h>
    +#include <math.h>
    #include <so3/so3.h>
    #include <ssht/ssht.h>
    -#include <complex.h>
    -#include <math.h>
    -#include <stdlib.h>
    #include <stdio.h>
    +#include <stdlib.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_analysis.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -154,9 +188,9 @@

    Parameters

    Functions

    void s2let_analysis_lm2lmn (complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    - - - + + + @@ -170,8 +204,6 @@

    Definition at line 27 of file s2let_analysis.c.

    - @@ -226,12 +258,12 @@

    Parameters

    [out]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (Spherical harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic coefficients of input function.
    [out]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (Spherical harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic coefficients of input function.
    [in]wav_lmWavelet kernels in harmonic space.
    [in]scal_lScaling function kernels in harmonic space.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_analysis_lm2lmn_real instead for real signals.
    - - - - - - + + + + + +
    [out]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic coefficients of input function.
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_analysis_lm2lmn instead for complex signals.
    [out]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic coefficients of input function.
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_analysis_lm2lmn instead for complex signals.
    @@ -242,8 +274,6 @@

    Definition at line 112 of file s2let_analysis.c.

    -

    @@ -300,8 +330,6 @@

    Definition at line 321 of file s2let_analysis.c.

    -

    @@ -407,8 +435,6 @@

    Definition at line 207 of file s2let_analysis.c.

    - @@ -465,8 +491,6 @@

    Definition at line 409 of file s2let_analysis.c.

    - @@ -523,8 +547,6 @@

    Definition at line 498 of file s2let_analysis.c.

    - @@ -581,14 +603,12 @@

    Definition at line 541 of file s2let_analysis.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__analysis_8c__incl.map b/docs/c/s2let__analysis_8c__incl.map new file mode 100644 index 00000000..dc37e339 --- /dev/null +++ b/docs/c/s2let__analysis_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__analysis_8c__incl.md5 b/docs/c/s2let__analysis_8c__incl.md5 new file mode 100644 index 00000000..47ec67dd --- /dev/null +++ b/docs/c/s2let__analysis_8c__incl.md5 @@ -0,0 +1 @@ +6a066dac9df0ac78c8d8a4b63e574e9f \ No newline at end of file diff --git a/docs/c/s2let__analysis_8c_source.html b/docs/c/s2let__analysis_8c_source.html deleted file mode 100644 index f8a2b032..00000000 --- a/docs/c/s2let__analysis_8c_source.html +++ /dev/null @@ -1,582 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_analysis.c Source File - - - - - - - - - -
    -
    - - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_analysis.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <so3/so3.h>
    -
    7 #include <ssht/ssht.h>
    -
    8 #include <complex.h>
    -
    9 #include <math.h>
    -
    10 #include <stdlib.h>
    -
    11 #include <stdio.h>
    -
    12 
    -
    27 void s2let_analysis_lm2lmn(
    -
    28  complex double *f_wav_lmn,
    -
    29  complex double *f_scal_lm,
    -
    30  const complex double *flm,
    -
    31  const complex double *wav_lm,
    -
    32  const double *scal_l,
    -
    33  const s2let_parameters_t *parameters
    -
    34 ) {
    -
    35  int L = parameters->L;
    -
    36  int J_min = parameters->J_min;
    -
    37  int N = parameters->N;
    -
    38  int spin = parameters->spin;
    -
    39 
    -
    40  int j, el, m ,n;
    -
    41  int J = s2let_j_max(parameters);
    -
    42  int bandlimit = L;
    -
    43  int Nj = N;
    -
    44 
    -
    45  int lm_ind, lmn_ind;
    -
    46  so3_parameters_t so3_parameters = {};
    -
    47  fill_so3_parameters(&so3_parameters, parameters);
    -
    48 
    -
    49  complex double psi;
    -
    50  double phi;
    -
    51 
    -
    52  int offset = 0;
    -
    53 
    -
    54  for (j = J_min; j <= J; ++j)
    -
    55  {
    -
    56 
    -
    57  if (!parameters->upsample)
    -
    58  {
    -
    59  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    60  so3_parameters.L = bandlimit;
    -
    61  Nj = MIN(N,bandlimit);
    -
    62  // ensure N and Nj are both even or both odd
    -
    63  Nj += (Nj+N)%2;
    -
    64  so3_parameters.N = Nj;
    -
    65  }
    -
    66 
    -
    67  for (n = -Nj+1; n < Nj; n+=2)
    -
    68  {
    -
    69  for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el)
    -
    70  {
    -
    71  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    72  psi = 8*PI*PI/(2*el+1) * conj(wav_lm[j*L*L + lm_ind]);
    -
    73  for (m = -el; m <= el; ++m)
    -
    74  {
    -
    75  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    76  so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters);
    -
    77  f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi;
    -
    78  }
    -
    79  }
    -
    80  }
    -
    81  offset += so3_sampling_flmn_size(&so3_parameters);
    -
    82  }
    -
    83 
    -
    84  if (!parameters->upsample)
    -
    85  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    86 
    -
    87  for (el = ABS(spin); el < bandlimit; ++el)
    -
    88  {
    -
    89  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    90  for (m = -el; m <= el; ++m)
    -
    91  {
    -
    92  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    93  f_scal_lm[lm_ind] = flm[lm_ind] * phi;
    -
    94  }
    -
    95  }
    -
    96 }
    -
    97 
    -
    112 void s2let_analysis_lm2lmn_real(
    -
    113  complex double *f_wav_lmn,
    -
    114  complex double *f_scal_lm,
    -
    115  const complex double *flm,
    -
    116  const complex double *wav_lm,
    -
    117  const double *scal_l,
    -
    118  const s2let_parameters_t *parameters
    -
    119 ) {
    -
    120  int L = parameters->L;
    -
    121  int J_min = parameters->J_min;
    -
    122  int N = parameters->N;
    -
    123 
    -
    124  int j, el, m ,n;
    -
    125  int J = s2let_j_max(parameters);
    -
    126  int bandlimit = L;
    -
    127  int Nj = N;
    -
    128 
    -
    129  int lm_ind, lmn_ind;
    -
    130  so3_parameters_t so3_parameters = {};
    -
    131  fill_so3_parameters(&so3_parameters, parameters);
    -
    132 
    -
    133  complex double psi;
    -
    134  double phi;
    -
    135 
    -
    136  int offset = 0;
    -
    137 
    -
    138  for (j = J_min; j <= J; ++j)
    -
    139  {
    -
    140  if (!parameters->upsample)
    -
    141  {
    -
    142  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    143  so3_parameters.L = bandlimit;
    -
    144  int Nj = MIN(N,bandlimit);
    -
    145  // ensure N and Nj are both even or both odd
    -
    146  Nj += (Nj+N)%2;
    -
    147  so3_parameters.N = Nj;
    -
    148  }
    -
    149 
    -
    150  for (n = 1-Nj%2; n < Nj; n+=2)
    -
    151  {
    -
    152  for (el = n; el < bandlimit; ++el)
    -
    153  {
    -
    154  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    155  psi = 8*PI*PI/(2*el+1) * conj(wav_lm[j*L*L + lm_ind]);
    -
    156  for (m = -el; m <= el; ++m)
    -
    157  {
    -
    158  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    159  so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters);
    -
    160  f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi;
    -
    161  }
    -
    162  }
    -
    163  }
    -
    164  offset += so3_sampling_flmn_size(&so3_parameters);
    -
    165  }
    -
    166 
    -
    167  if (!parameters->upsample)
    -
    168  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    169 
    -
    170  for (el = 0; el < bandlimit; ++el)
    -
    171  {
    -
    172  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    173  for (m = -el; m <= el; ++m)
    -
    174  {
    -
    175  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    176  f_scal_lm[lm_ind] = flm[lm_ind] * phi;
    -
    177  }
    -
    178  }
    -
    179 }
    -
    180 
    -
    181 
    -
    207 void s2let_analysis_lm2wav_manual(
    -
    208  complex double *f_wav,
    -
    209  complex double *f_scal,
    -
    210  const complex double *flm,
    -
    211  const double *scal_l,
    -
    212  const complex double *wav_lm,
    -
    213  const int scal_bandlimit,
    -
    214  const int *wav_bandlimits,
    -
    215  int J,
    -
    216  int L,
    -
    217  int spin,
    -
    218  int N
    -
    219 ) {
    -
    220  s2let_parameters_t parameters = {};
    -
    221  parameters.L = L;
    -
    222  parameters.J_min = 0;
    -
    223  parameters.B = pow(L, 1.0/(float)(J+2));
    -
    224  parameters.N = N;
    -
    225  parameters.dl_method = SSHT_DL_RISBO;
    -
    226 
    -
    227  int bandlimit = L;
    -
    228  int verbosity = 0;
    -
    229  so3_parameters_t so3_parameters = {};
    -
    230  fill_so3_parameters(&so3_parameters, &parameters);
    -
    231 
    -
    232  int j, offset, offset_lmn;
    -
    233  complex double *f_wav_lmn, *f_scal_lm;
    -
    234  complex double psi, npsi;
    -
    235  double phi;
    -
    236  int el, m, n, lm_ind, lmn_ind;
    -
    237 
    -
    238  int Nj = N;
    -
    239 
    -
    240  bandlimit = MIN(scal_bandlimit, L);
    -
    241  f_scal_lm = (complex double*)calloc(bandlimit*bandlimit, sizeof(complex double));
    -
    242 
    -
    243  for (el = ABS(spin); el < bandlimit; ++el)
    -
    244  {
    -
    245  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    246  for (m = -el; m <= el; ++m)
    -
    247  {
    -
    248  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    249  f_scal_lm[lm_ind] = flm[lm_ind] * phi;
    -
    250  }
    -
    251  }
    -
    252 
    -
    253  switch (parameters.sampling_scheme)
    -
    254  {
    -
    255  case S2LET_SAMPLING_MW:
    -
    256  ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity);
    -
    257  break;
    -
    258  case S2LET_SAMPLING_MW_SS:
    -
    259  ssht_core_mw_inverse_sov_sym_ss(f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity);
    -
    260  break;
    -
    261  default:
    -
    262  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    263  }
    -
    264 
    -
    265  free(f_scal_lm);
    -
    266 
    -
    267  offset = 0;
    -
    268  for (j = 0; j <= J; ++j)
    -
    269  {
    -
    270  bandlimit = MIN(wav_bandlimits[j], L);
    -
    271  so3_parameters.L = bandlimit;
    -
    272  int Nj = MIN(N, bandlimit);
    -
    273  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    274  so3_parameters.N = Nj;
    -
    275  so3_parameters.L0 = 0;
    -
    276 
    -
    277  f_wav_lmn = (complex double*)calloc(so3_sampling_flmn_size(&so3_parameters), sizeof(complex double));
    -
    278 
    -
    279  for (n = -Nj+1; n < Nj; n+=2)
    -
    280  {
    -
    281  for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el)
    -
    282  {
    -
    283  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    284  psi = 8*PI*PI/(2*el+1) * conj(wav_lm[j*L*L + lm_ind]);
    -
    285  for (m = -el; m <= el; ++m)
    -
    286  {
    -
    287  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    288  so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters);
    -
    289  f_wav_lmn[lmn_ind] = flm[lm_ind] * psi;
    -
    290  }
    -
    291  }
    -
    292  }
    -
    293 
    -
    294 // so3_core_inverse_via_ssht(
    -
    295  so3_core_inverse_direct(
    -
    296  f_wav + offset,
    -
    297  f_wav_lmn,
    -
    298  &so3_parameters
    -
    299  );
    -
    300 
    -
    301  free(f_wav_lmn);
    -
    302  offset += so3_sampling_f_size(&so3_parameters);
    -
    303 
    -
    304  }
    -
    305 
    -
    306 }
    -
    307 
    -
    308 
    -
    321 void s2let_analysis_lm2wav(
    -
    322  complex double *f_wav,
    -
    323  complex double *f_scal,
    -
    324  const complex double *flm,
    -
    325  const s2let_parameters_t *parameters
    -
    326 ) {
    -
    327  int L = parameters->L;
    -
    328  int J_min = parameters->J_min;
    -
    329  int N = parameters->N;
    -
    330  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    331 
    -
    332  int bandlimit = L;
    -
    333  int verbosity = 0;
    -
    334  so3_parameters_t so3_parameters = {};
    -
    335  fill_so3_parameters(&so3_parameters, parameters);
    -
    336 
    -
    337  int j, offset, offset_lmn;
    -
    338  int J = s2let_j_max(parameters);
    -
    339 
    -
    340  complex double *wav_lm;
    -
    341  double *scal_l;
    -
    342  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters);
    -
    343  s2let_tiling_wavelet(wav_lm, scal_l, parameters);
    -
    344 
    -
    345  complex double *f_wav_lmn, *f_scal_lm;
    -
    346 
    -
    347  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters);
    -
    348  s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, parameters);
    -
    349 
    -
    350  if (!parameters->upsample)
    -
    351  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    352 
    -
    353  // Note, this is a spin-0 transform!
    -
    354  switch (parameters->sampling_scheme)
    -
    355  {
    -
    356  case S2LET_SAMPLING_MW:
    -
    357  ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity);
    -
    358  break;
    -
    359  case S2LET_SAMPLING_MW_SS:
    -
    360  ssht_core_mw_inverse_sov_sym_ss(f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity);
    -
    361  break;
    -
    362  default:
    -
    363  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    364  }
    -
    365 
    -
    366  offset = 0;
    -
    367  offset_lmn = 0;
    -
    368  for (j = J_min; j <= J; ++j)
    -
    369  {
    -
    370  if (!parameters->upsample)
    -
    371  {
    -
    372  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    373  so3_parameters.L = bandlimit;
    -
    374  int Nj = MIN(N,bandlimit);
    -
    375  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    376  so3_parameters.N = Nj;
    -
    377  }
    -
    378 
    -
    379  so3_parameters.L0 = s2let_L0(j, parameters);
    -
    380 
    -
    381 // so3_core_inverse_via_ssht(
    -
    382  so3_core_inverse_direct(
    -
    383  f_wav + offset,
    -
    384  f_wav_lmn + offset_lmn,
    -
    385  &so3_parameters
    -
    386  );
    -
    387  offset_lmn += so3_sampling_flmn_size(&so3_parameters);
    -
    388  offset += so3_sampling_f_size(&so3_parameters);
    -
    389  }
    -
    390 
    -
    391  free(wav_lm);
    -
    392  free(scal_l);
    -
    393  free(f_scal_lm);
    -
    394  free(f_wav_lmn);
    -
    395 }
    -
    396 
    -
    409 void s2let_analysis_lm2wav_real(
    -
    410  double *f_wav,
    -
    411  double *f_scal,
    -
    412  const complex double *flm,
    -
    413  const s2let_parameters_t *parameters
    -
    414 ) {
    -
    415  int L = parameters->L;
    -
    416  int J_min = parameters->J_min;
    -
    417  int N = parameters->N;
    -
    418  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    419 
    -
    420  s2let_parameters_t real_parameters = *parameters;
    -
    421  real_parameters.reality = 1;
    -
    422 
    -
    423  int bandlimit = L;
    -
    424  int verbosity = 0;
    -
    425  so3_parameters_t so3_parameters = {};
    -
    426  fill_so3_parameters(&so3_parameters, &real_parameters);
    -
    427 
    -
    428  int j, offset, offset_lmn;
    -
    429  int J = s2let_j_max(&real_parameters);
    -
    430 
    -
    431  complex double *wav_lm;
    -
    432  double *scal_l;
    -
    433  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters);
    -
    434  s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters);
    -
    435 
    -
    436  complex double *f_wav_lmn, *f_scal_lm;
    -
    437 
    -
    438  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters);
    -
    439  s2let_analysis_lm2lmn_real(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, &real_parameters);
    -
    440 
    -
    441  if (!parameters->upsample)
    -
    442  bandlimit = MIN(s2let_bandlimit(J_min-1, &real_parameters), L);
    -
    443 
    -
    444  switch (parameters->sampling_scheme)
    -
    445  {
    -
    446  case S2LET_SAMPLING_MW:
    -
    447  ssht_core_mw_inverse_sov_sym_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity);
    -
    448  break;
    -
    449  case S2LET_SAMPLING_MW_SS:
    -
    450  ssht_core_mw_inverse_sov_sym_ss_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity);
    -
    451  break;
    -
    452  default:
    -
    453  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    454  }
    -
    455 
    -
    456  offset = 0;
    -
    457  offset_lmn = 0;
    -
    458  for (j = J_min; j <= J; ++j)
    -
    459  {
    -
    460  if (!parameters->upsample)
    -
    461  {
    -
    462  bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L);
    -
    463  so3_parameters.L = bandlimit;
    -
    464  int Nj = MIN(N,bandlimit);
    -
    465  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    466  so3_parameters.N = Nj;
    -
    467  }
    -
    468 
    -
    469  so3_parameters.L0 = s2let_L0(j, parameters);
    -
    470 
    -
    471  so3_core_inverse_via_ssht_real(
    -
    472  f_wav + offset,
    -
    473  f_wav_lmn + offset_lmn,
    -
    474  &so3_parameters
    -
    475  );
    -
    476  offset_lmn += so3_sampling_flmn_size(&so3_parameters);
    -
    477  offset += so3_sampling_f_size(&so3_parameters);
    -
    478  }
    -
    479 
    -
    480  free(wav_lm);
    -
    481  free(scal_l);
    -
    482  free(f_scal_lm);
    -
    483  free(f_wav_lmn);
    -
    484 }
    -
    485 
    -
    498 void s2let_analysis_px2wav(
    -
    499  complex double *f_wav,
    -
    500  complex double *f_scal,
    -
    501  const complex double *f,
    -
    502  const s2let_parameters_t *parameters
    -
    503 ) {
    -
    504  int L = parameters->L;
    -
    505  int spin = parameters->spin;
    -
    506  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    507  int verbosity = parameters->verbosity;
    -
    508 
    -
    509  complex double *flm;
    -
    510  s2let_allocate_lm(&flm, L);
    -
    511 
    -
    512  switch (parameters->sampling_scheme)
    -
    513  {
    -
    514  case S2LET_SAMPLING_MW:
    -
    515  ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity);
    -
    516  break;
    -
    517  case S2LET_SAMPLING_MW_SS:
    -
    518  ssht_core_mw_forward_sov_conv_sym_ss(flm, f, L, spin, dl_method, verbosity);
    -
    519  break;
    -
    520  default:
    -
    521  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    522  }
    -
    523 
    -
    524  s2let_analysis_lm2wav(f_wav, f_scal, flm, parameters);
    -
    525 
    -
    526  free(flm);
    -
    527 }
    -
    528 
    -
    541 void s2let_analysis_px2wav_real(
    -
    542  double *f_wav,
    -
    543  double *f_scal,
    -
    544  const double *f,
    -
    545  const s2let_parameters_t *parameters
    -
    546 ) {
    -
    547  int L = parameters->L;
    -
    548  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    549  int verbosity = 0;
    -
    550 
    -
    551  complex double *flm;
    -
    552  s2let_allocate_lm(&flm, L);
    -
    553 
    -
    554  switch (parameters->sampling_scheme)
    -
    555  {
    -
    556  case S2LET_SAMPLING_MW:
    -
    557  ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity);
    -
    558  break;
    -
    559  case S2LET_SAMPLING_MW_SS:
    -
    560  ssht_core_mw_forward_sov_conv_sym_ss_real(flm, f, L, dl_method, verbosity);
    -
    561  break;
    -
    562  default:
    -
    563  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    564  }
    -
    565 
    -
    566  s2let_analysis_lm2wav_real(f_wav, f_scal, flm, parameters);
    -
    567 
    -
    568  free(flm);
    -
    569 }
    -
    -
    s2let_analysis_lm2wav_manual
    void s2let_analysis_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    Definition: s2let_analysis.c:207
    -
    s2let_analysis_lm2lmn_real
    void s2let_analysis_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:112
    -
    s2let_analysis_px2wav
    void s2let_analysis_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:498
    -
    s2let_analysis_lm2wav_real
    void s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:409
    -
    s2let_analysis_lm2lmn
    void s2let_analysis_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:27
    -
    s2let_tiling_wavelet_allocate
    void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:339
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    - -
    s2let_parameters_t::verbosity
    int verbosity
    Definition: s2let_types.h:61
    -
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    ABS
    #define ABS(a)
    Definition: s2let_math.h:13
    -
    s2let_allocate_lmn_f_wav
    void s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:82
    -
    S2LET_ERROR_GENERIC
    #define S2LET_ERROR_GENERIC(comment)
    Definition: s2let_error.h:13
    -
    S2LET_SAMPLING_MW_SS
    @ S2LET_SAMPLING_MW_SS
    Definition: s2let_types.h:32
    -
    s2let_tiling_wavelet
    void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:388
    -
    s2let_parameters_t::reality
    int reality
    Definition: s2let_types.h:70
    -
    PI
    #define PI
    Definition: s2let_math.h:9
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_L0
    int s2let_L0(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:83
    -
    s2let_analysis_px2wav_real
    void s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:541
    -
    MAX
    #define MAX(a, b)
    Definition: s2let_math.h:12
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    -
    S2LET_SAMPLING_MW
    @ S2LET_SAMPLING_MW
    Definition: s2let_types.h:25
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    -
    s2let_analysis_lm2wav
    void s2let_analysis_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:321
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__analysis_8h.html b/docs/c/s2let__analysis_8h.html index 58f52a79..5fed7767 100644 --- a/docs/c/s2let__analysis_8h.html +++ b/docs/c/s2let__analysis_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_analysis.h File Reference +s2let: include/s2let_analysis.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_analysis.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -462,14 +512,12 @@

    Definition at line 541 of file s2let_analysis.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__analysis_8h__dep__incl.map b/docs/c/s2let__analysis_8h__dep__incl.map new file mode 100644 index 00000000..f97c234c --- /dev/null +++ b/docs/c/s2let__analysis_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__analysis_8h__dep__incl.md5 b/docs/c/s2let__analysis_8h__dep__incl.md5 new file mode 100644 index 00000000..fd5680e4 --- /dev/null +++ b/docs/c/s2let__analysis_8h__dep__incl.md5 @@ -0,0 +1 @@ +93b9326699abf6a7df5afd87e47532fb \ No newline at end of file diff --git a/docs/c/s2let__analysis_8h__incl.map b/docs/c/s2let__analysis_8h__incl.map new file mode 100644 index 00000000..2a1bfa85 --- /dev/null +++ b/docs/c/s2let__analysis_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__analysis_8h__incl.md5 b/docs/c/s2let__analysis_8h__incl.md5 new file mode 100644 index 00000000..51416d65 --- /dev/null +++ b/docs/c/s2let__analysis_8h__incl.md5 @@ -0,0 +1 @@ +37ffb496906e87527328b2c8dc10fac7 \ No newline at end of file diff --git a/docs/c/s2let__analysis_8h_source.html b/docs/c/s2let__analysis_8h_source.html index 12f1f55b..f8f18bff 100644 --- a/docs/c/s2let__analysis_8h_source.html +++ b/docs/c/s2let__analysis_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_analysis.h Source File +s2let: include/s2let_analysis.h Source File @@ -22,10 +22,10 @@

    @@ -145,16 +145,16 @@
    s2let_analysis_lm2wav_real
    void s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters)
    s2let_analysis_lm2lmn_real
    void s2let_analysis_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    -
    s2let_analysis_px2wav_real
    void s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:541
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    s2let_analysis_px2wav_real
    void s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:497
    s2let_analysis_lm2lmn
    void s2let_analysis_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    s2let_analysis_lm2wav_manual
    void s2let_analysis_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    s2let_analysis_lm2wav
    void s2let_analysis_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters)
    s2let_analysis_px2wav
    void s2let_analysis_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters)
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__analysis__adjoint_8c.html b/docs/c/s2let__analysis__adjoint_8c.html index b7825289..ae42c9b6 100644 --- a/docs/c/s2let__analysis__adjoint_8c.html +++ b/docs/c/s2let__analysis__adjoint_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_analysis_adjoint.c File Reference +s2let: src/main/c/s2let_analysis_adjoint.c File Reference @@ -22,10 +22,10 @@ @@ -74,16 +74,50 @@
    s2let_analysis_adjoint.c File Reference
    -
    #include "s2let.h"
    +
    #include <complex.h>
    +#include <math.h>
    #include <so3/so3.h>
    #include <ssht/ssht.h>
    -#include <complex.h>
    -#include <math.h>
    -#include <stdlib.h>
    #include <stdio.h>
    +#include <stdlib.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_analysis_adjoint.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    @@ -156,11 +190,11 @@

    Parameters

    Functions

    void s2let_analysis_adjoint_lmn2lm (complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    - - - - - + + + + +
    [out]flmSpherical harmonic coefficients of input function.
    [in]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_synthesis_lmn2lm_real instead for real signals.
    [in]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_synthesis_lmn2lm_real instead for real signals.
    @@ -171,8 +205,6 @@

    Definition at line 27 of file s2let_analysis_adjoint.c.

    -

    @@ -228,11 +260,11 @@

    Parameters
    - - - - - + + + + +
    [out]flmSpherical harmonic coefficients of input function.
    [in]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_synthesis_lmn2lm instead for complex signals.
    [in]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_synthesis_lmn2lm instead for complex signals.
    @@ -243,8 +275,6 @@

    Definition at line 114 of file s2let_analysis_adjoint.c.

    - @@ -301,8 +331,6 @@

    Definition at line 339 of file s2let_analysis_adjoint.c.

    - @@ -408,8 +436,6 @@

    Definition at line 225 of file s2let_analysis_adjoint.c.

    - @@ -466,8 +492,6 @@

    Definition at line 440 of file s2let_analysis_adjoint.c.

    - @@ -524,8 +548,6 @@

    Definition at line 532 of file s2let_analysis_adjoint.c.

    - @@ -584,14 +606,12 @@

    Definition at line 576 of file s2let_analysis_adjoint.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__analysis__adjoint_8c__incl.map b/docs/c/s2let__analysis__adjoint_8c__incl.map new file mode 100644 index 00000000..d3acb686 --- /dev/null +++ b/docs/c/s2let__analysis__adjoint_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__analysis__adjoint_8c__incl.md5 b/docs/c/s2let__analysis__adjoint_8c__incl.md5 new file mode 100644 index 00000000..d41f4a22 --- /dev/null +++ b/docs/c/s2let__analysis__adjoint_8c__incl.md5 @@ -0,0 +1 @@ +48dba1966a91b76ce92362d5430e334b \ No newline at end of file diff --git a/docs/c/s2let__analysis__adjoint_8c_source.html b/docs/c/s2let__analysis__adjoint_8c_source.html deleted file mode 100644 index 5e97faa0..00000000 --- a/docs/c/s2let__analysis__adjoint_8c_source.html +++ /dev/null @@ -1,616 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_analysis_adjoint.c Source File - - - - - - - - - -
    -
    - - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_analysis_adjoint.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <so3/so3.h>
    -
    7 #include <ssht/ssht.h>
    -
    8 #include <complex.h>
    -
    9 #include <math.h>
    -
    10 #include <stdlib.h>
    -
    11 #include <stdio.h>
    -
    12 
    -
    27 void s2let_analysis_adjoint_lmn2lm(
    -
    28  complex double *flm,
    -
    29  const complex double *f_wav_lmn,
    -
    30  const complex double *f_scal_lm,
    -
    31  const complex double *wav_lm,
    -
    32  const double *scal_l,
    -
    33  const s2let_parameters_t *parameters
    -
    34 ) {
    -
    35  int L = parameters->L;
    -
    36  int J_min = parameters->J_min;
    -
    37  int N = parameters->N;
    -
    38  int spin = parameters->spin;
    -
    39 
    -
    40  int j, el, m ,n;
    -
    41  int J = s2let_j_max(parameters);
    -
    42  int bandlimit = L;
    -
    43  int Nj = N;
    -
    44 
    -
    45  int lm_ind, lmn_ind;
    -
    46  so3_parameters_t so3_parameters = {};
    -
    47  fill_so3_parameters(&so3_parameters, parameters);
    -
    48 
    -
    49  complex double psi;
    -
    50  double phi;
    -
    51 
    -
    52  int offset = 0;
    -
    53 
    -
    54  // Clear output
    -
    55  for (el = 0; el < L*L; ++el)
    -
    56  flm[el] = 0;
    -
    57 
    -
    58  for (j = J_min; j <= J; ++j)
    -
    59  {
    -
    60  if (!parameters->upsample)
    -
    61  {
    -
    62  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    63  so3_parameters.L = bandlimit;
    -
    64  int Nj = MIN(N,bandlimit);
    -
    65  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    66  so3_parameters.N = Nj;
    -
    67  }
    -
    68 
    -
    69  for (n = -Nj+1; n < Nj; n+=2)
    -
    70  {
    -
    71  for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el)
    -
    72  {
    -
    73  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    74  psi = 8*PI*PI/(2*el+1) * (wav_lm[j*L*L + lm_ind]);
    -
    75  for (m = -el; m <= el; ++m)
    -
    76  {
    -
    77  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    78  so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters);
    -
    79  flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi;
    -
    80  }
    -
    81  }
    -
    82  }
    -
    83  offset += so3_sampling_flmn_size(&so3_parameters);
    -
    84  }
    -
    85 
    -
    86  if (!parameters->upsample)
    -
    87  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    88 
    -
    89  for (el = ABS(spin); el < bandlimit; ++el)
    -
    90  {
    -
    91  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    92  for (m = -el; m <= el; ++m)
    -
    93  {
    -
    94  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    95  flm[lm_ind] += f_scal_lm[lm_ind] * phi;
    -
    96  }
    -
    97  }
    -
    98 }
    -
    99 
    -
    114 void s2let_analysis_adjoint_lmn2lm_real(
    -
    115  complex double *flm,
    -
    116  const complex double *f_wav_lmn,
    -
    117  const complex double *f_scal_lm,
    -
    118  const complex double *wav_lm,
    -
    119  const double *scal_l,
    -
    120  const s2let_parameters_t *parameters
    -
    121 ) {
    -
    122  int L = parameters->L;
    -
    123  int J_min = parameters->J_min;
    -
    124  int N = parameters->N;
    -
    125 
    -
    126  int j, el, m ,n;
    -
    127  int J = s2let_j_max(parameters);
    -
    128  int bandlimit = L;
    -
    129  int Nj = N;
    -
    130 
    -
    131  int lm_ind, lmn_ind;
    -
    132  so3_parameters_t so3_parameters = {};
    -
    133  fill_so3_parameters(&so3_parameters, parameters);
    -
    134 
    -
    135  complex double psi, npsi;
    -
    136  double phi;
    -
    137 
    -
    138  int offset = 0;
    -
    139 
    -
    140  // Clear output
    -
    141  for (el = 0; el < L*L; ++el)
    -
    142  flm[el] = 0;
    -
    143 
    -
    144  for (j = J_min; j <= J; ++j)
    -
    145  {
    -
    146  if (!parameters->upsample)
    -
    147  {
    -
    148  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    149  so3_parameters.L = bandlimit;
    -
    150  int Nj = MIN(N,bandlimit);
    -
    151  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    152  so3_parameters.N = Nj;
    -
    153  }
    -
    154 
    -
    155  for (n = 1-Nj%2; n < Nj; n+=2)
    -
    156  {
    -
    157  for (el = n; el < bandlimit; ++el)
    -
    158  {
    -
    159  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    160  psi = 8*PI*PI/(2*el+1) * wav_lm[j*L*L + lm_ind];
    -
    161 
    -
    162  if (n)
    -
    163  {
    -
    164  ssht_sampling_elm2ind(&lm_ind, el, -n);
    -
    165  npsi = 8*PI*PI/(2*el+1) * wav_lm[j*L*L + lm_ind];
    -
    166  }
    -
    167 
    -
    168  for (m = -el; m <= el; ++m)
    -
    169  {
    -
    170  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    171  so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters);
    -
    172  flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi;
    -
    173 
    -
    174  if (n)
    -
    175  {
    -
    176  so3_sampling_elmn2ind_real(&lmn_ind, el, -m, n, &so3_parameters);
    -
    177  int sign = (m+n)%2 ? -1 : 1;
    -
    178  flm[lm_ind] += sign * conj(f_wav_lmn[offset + lmn_ind]) * npsi;
    -
    179  }
    -
    180  }
    -
    181  }
    -
    182  }
    -
    183  offset += so3_sampling_flmn_size(&so3_parameters);
    -
    184  }
    -
    185 
    -
    186  if (!parameters->upsample)
    -
    187  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    188 
    -
    189  for (el = 0; el < bandlimit; ++el)
    -
    190  {
    -
    191  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    192  for (m = -el; m <= el; ++m)
    -
    193  {
    -
    194  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    195  flm[lm_ind] += f_scal_lm[lm_ind] * phi;
    -
    196  }
    -
    197  }
    -
    198 }
    -
    199 
    -
    225 void s2let_analysis_adjoint_wav2lm_manual(
    -
    226  complex double *flm,
    -
    227  const complex double *f_wav,
    -
    228  const complex double *f_scal,
    -
    229  const double *scal_l,
    -
    230  const complex double *wav_lm,
    -
    231  const int scal_bandlimit,
    -
    232  const int *wav_bandlimits,
    -
    233  int J,
    -
    234  int L,
    -
    235  int spin,
    -
    236  int N
    -
    237 ) {
    -
    238  s2let_parameters_t parameters = {};
    -
    239  parameters.L = L;
    -
    240  parameters.J_min = 0;
    -
    241  parameters.B = pow(L, 1.0/(float)J);
    -
    242  parameters.N = N;
    -
    243  parameters.dl_method = SSHT_DL_RISBO;
    -
    244 
    -
    245  int bandlimit = L;
    -
    246  int verbosity = 0;
    -
    247  so3_parameters_t so3_parameters = {};
    -
    248  fill_so3_parameters(&so3_parameters, &parameters);
    -
    249 
    -
    250  int j, offset;
    -
    251  complex double *f_wav_lmn, *f_scal_lm;
    -
    252  complex double psi;
    -
    253  double phi;
    -
    254  int el, m, n, lm_ind, lmn_ind;
    -
    255 
    -
    256  bandlimit = MIN(scal_bandlimit, L);
    -
    257 
    -
    258  f_scal_lm = (complex double*)calloc(bandlimit*bandlimit, sizeof(complex double));
    -
    259 
    -
    260  // Note, this is a spin-0 transform!
    -
    261  switch (parameters.sampling_scheme)
    -
    262  {
    -
    263  case S2LET_SAMPLING_MW:
    -
    264  ssht_adjoint_mw_inverse_sov_sym(f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity);
    -
    265  break;
    -
    266  case S2LET_SAMPLING_MW_SS:
    -
    267  ssht_adjoint_mw_inverse_sov_sym_ss(f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity);
    -
    268  break;
    -
    269  default:
    -
    270  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    271  }
    -
    272 
    -
    273  for (el = ABS(spin); el < bandlimit; ++el)
    -
    274  {
    -
    275  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    276  for (m = -el; m <= el; ++m)
    -
    277  {
    -
    278  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    279  flm[lm_ind] += f_scal_lm[lm_ind] * phi;
    -
    280  }
    -
    281  }
    -
    282 
    -
    283  free(f_scal_lm);
    -
    284 
    -
    285  offset = 0;
    -
    286  for (j = 0; j <= J; ++j)
    -
    287  {
    -
    288  bandlimit = MIN(wav_bandlimits[j], L);
    -
    289  so3_parameters.L = bandlimit;
    -
    290  int Nj = MIN(N,bandlimit);
    -
    291  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    292  so3_parameters.N = Nj;
    -
    293  so3_parameters.L0 = 0;
    -
    294 
    -
    295  f_wav_lmn = (complex double*)calloc(so3_sampling_flmn_size(&so3_parameters), sizeof(complex double));
    -
    296 
    -
    297 // so3_core_forward_direct(
    -
    298  so3_adjoint_inverse_direct(
    -
    299  f_wav_lmn,
    -
    300  f_wav + offset,
    -
    301  &so3_parameters
    -
    302  );
    -
    303 
    -
    304  for (n = -Nj+1; n < Nj; n+=2)
    -
    305  {
    -
    306  for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el)
    -
    307  {
    -
    308  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    309  psi = 8*PI*PI/(2*el+1) * conj(wav_lm[j*L*L + lm_ind]);
    -
    310  for (m = -el; m <= el; ++m)
    -
    311  {
    -
    312  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    313  so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters);
    -
    314  flm[lm_ind] += f_wav_lmn[lmn_ind] * psi;
    -
    315  }
    -
    316  }
    -
    317  }
    -
    318 
    -
    319  free(f_wav_lmn);
    -
    320  offset += so3_sampling_f_size(&so3_parameters);
    -
    321 
    -
    322  }
    -
    323 
    -
    324 }
    -
    325 
    -
    326 
    -
    339 void s2let_analysis_adjoint_wav2lm(
    -
    340  complex double *flm,
    -
    341  const complex double *f_wav,
    -
    342  const complex double *f_scal,
    -
    343  const s2let_parameters_t *parameters
    -
    344 ) {
    -
    345  int L = parameters->L;
    -
    346  int J_min = parameters->J_min;
    -
    347  int N = parameters->N;
    -
    348  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    349 
    -
    350  int bandlimit = L;
    -
    351  int verbosity = 0;
    -
    352  so3_parameters_t so3_parameters = {};
    -
    353  fill_so3_parameters(&so3_parameters, parameters);
    -
    354 
    -
    355  int j, offset, offset_lmn;
    -
    356  int J = s2let_j_max(parameters);
    -
    357 
    -
    358  complex double *wav_lm;
    -
    359  double *scal_l;
    -
    360  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters);
    -
    361  s2let_tiling_wavelet(wav_lm, scal_l, parameters);
    -
    362 
    -
    363  complex double *f_wav_lmn, *f_scal_lm;
    -
    364  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters);
    -
    365 
    -
    366  if (!parameters->upsample)
    -
    367  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    368 
    -
    369  // Note, this is a spin-0 transform!
    -
    370  switch (parameters->sampling_scheme)
    -
    371  {
    -
    372  case S2LET_SAMPLING_MW:
    -
    373  ssht_adjoint_mw_inverse_sov_sym(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity);
    -
    374  break;
    -
    375  case S2LET_SAMPLING_MW_SS:
    -
    376  ssht_adjoint_mw_inverse_sov_sym_ss(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity);
    -
    377  break;
    -
    378  default:
    -
    379  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    380  }
    -
    381  // switch (parameters->sampling_scheme)
    -
    382  // {
    -
    383  // case S2LET_SAMPLING_MW:
    -
    384  // ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity);
    -
    385  // break;
    -
    386  // case S2LET_SAMPLING_MW_SS:
    -
    387  // ssht_core_mw_forward_sov_conv_sym_ss(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity);
    -
    388  // break;
    -
    389  // default:
    -
    390  // S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    391  // }
    -
    392 
    -
    393  offset = 0;
    -
    394  offset_lmn = 0;
    -
    395  for (j = J_min; j <= J; ++j)
    -
    396  {
    -
    397  if (!parameters->upsample)
    -
    398  {
    -
    399  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    400  so3_parameters.L = bandlimit;
    -
    401  int Nj = MIN(N,bandlimit);
    -
    402  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    403  so3_parameters.N = Nj;
    -
    404  }
    -
    405 
    -
    406  so3_parameters.L0 = s2let_L0(j, parameters);
    -
    407 
    -
    408  so3_adjoint_inverse_direct(
    -
    409 // so3_core_forward_direct(
    -
    410 // so3_core_forward_via_ssht(
    -
    411  f_wav_lmn + offset_lmn,
    -
    412  f_wav + offset,
    -
    413  &so3_parameters
    -
    414  );
    -
    415  offset_lmn += so3_sampling_flmn_size(&so3_parameters);
    -
    416  offset += so3_sampling_f_size(&so3_parameters);
    -
    417  }
    -
    418 
    -
    419  s2let_analysis_adjoint_lmn2lm(flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, parameters);
    -
    420 // s2let_synthesis_lmn2lm(flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, parameters);
    -
    421 
    -
    422  free(wav_lm);
    -
    423  free(scal_l);
    -
    424  free(f_scal_lm);
    -
    425  free(f_wav_lmn);
    -
    426 }
    -
    427 
    -
    440 void s2let_analysis_adjoint_wav2lm_real(
    -
    441  complex double *flm,
    -
    442  const double *f_wav,
    -
    443  const double *f_scal,
    -
    444  const s2let_parameters_t *parameters
    -
    445 ) {
    -
    446  int L = parameters->L;
    -
    447  int J_min = parameters->J_min;
    -
    448  int N = parameters->N;
    -
    449  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    450 
    -
    451  s2let_parameters_t real_parameters = *parameters;
    -
    452  real_parameters.reality = 1;
    -
    453 
    -
    454  int bandlimit = L;
    -
    455  int verbosity = 0;
    -
    456  so3_parameters_t so3_parameters = {};
    -
    457  fill_so3_parameters(&so3_parameters, &real_parameters);
    -
    458 
    -
    459  int j, offset, offset_lmn;
    -
    460  int J = s2let_j_max(&real_parameters);
    -
    461 
    -
    462  complex double *wav_lm;
    -
    463  double *scal_l;
    -
    464  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters);
    -
    465  s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters);
    -
    466 
    -
    467  complex double *f_wav_lmn, *f_scal_lm;
    -
    468  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters);
    -
    469 
    -
    470  if (!parameters->upsample)
    -
    471  bandlimit = MIN(s2let_bandlimit(J_min-1, &real_parameters), L);
    -
    472 
    -
    473  switch (parameters->sampling_scheme)
    -
    474  {
    -
    475  case S2LET_SAMPLING_MW:
    -
    476  ssht_adjoint_mw_inverse_sov_sym_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity);
    -
    477  break;
    -
    478  case S2LET_SAMPLING_MW_SS:
    -
    479  ssht_adjoint_mw_inverse_sov_sym_ss_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity);
    -
    480  break;
    -
    481  default:
    -
    482  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    483  }
    -
    484 
    -
    485 
    -
    486  offset = 0;
    -
    487  offset_lmn = 0;
    -
    488  for (j = J_min; j <= J; ++j)
    -
    489  {
    -
    490  if (!parameters->upsample)
    -
    491  {
    -
    492  bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L);
    -
    493  so3_parameters.L = bandlimit;
    -
    494  int Nj = MIN(N,bandlimit);
    -
    495  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    496  so3_parameters.N = Nj;
    -
    497  }
    -
    498 
    -
    499  so3_parameters.L0 = s2let_L0(j, parameters);
    -
    500 
    -
    501  so3_adjoint_inverse_direct_real(
    -
    502  f_wav_lmn + offset_lmn,
    -
    503  f_wav + offset,
    -
    504  &so3_parameters
    -
    505  );
    -
    506 
    -
    507  offset_lmn += so3_sampling_flmn_size(&so3_parameters);
    -
    508  offset += so3_sampling_f_size(&so3_parameters);
    -
    509  }
    -
    510 
    -
    511  s2let_analysis_adjoint_lmn2lm_real(
    -
    512  flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, &real_parameters);
    -
    513 
    -
    514  free(wav_lm);
    -
    515  free(scal_l);
    -
    516  free(f_scal_lm);
    -
    517  free(f_wav_lmn);
    -
    518 }
    -
    519 
    -
    532 void s2let_analysis_adjoint_wav2px(
    -
    533  complex double *f,
    -
    534  const complex double *f_wav,
    -
    535  const complex double *f_scal,
    -
    536  const s2let_parameters_t *parameters
    -
    537 ) {
    -
    538  int L = parameters->L;
    -
    539  int spin = parameters->spin;
    -
    540  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    541  int verbosity = 0;
    -
    542 
    -
    543  complex double *flm;
    -
    544  s2let_allocate_lm(&flm, L);
    -
    545 
    -
    546 // s2let_synthesis_wav2lm(flm, f_wav, f_scal, parameters);
    -
    547  s2let_analysis_adjoint_wav2lm(flm, f_wav, f_scal, parameters);
    -
    548 
    -
    549  switch (parameters->sampling_scheme)
    -
    550  {
    -
    551  case S2LET_SAMPLING_MW:
    -
    552  ssht_adjoint_mw_forward_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    553  break;
    -
    554  case S2LET_SAMPLING_MW_SS:
    -
    555  ssht_adjoint_mw_forward_sov_sym_ss(f, flm, L, spin, dl_method, verbosity);
    -
    556  break;
    -
    557  default:
    -
    558  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    559  }
    -
    560 
    -
    561  free(flm);
    -
    562 }
    -
    563 
    -
    576 void s2let_analysis_adjoint_wav2px_real(
    -
    577  double *f,
    -
    578  const double *f_wav,
    -
    579  const double *f_scal,
    -
    580  const s2let_parameters_t *parameters
    -
    581 ) {
    -
    582  int L = parameters->L;
    -
    583  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    584  int verbosity = 0;
    -
    585 
    -
    586  complex double *flm;
    -
    587  s2let_allocate_lm(&flm, L);
    -
    588 
    -
    589  s2let_analysis_adjoint_wav2lm_real(flm, f_wav, f_scal, parameters);
    -
    590 
    -
    591  switch (parameters->sampling_scheme)
    -
    592  {
    -
    593  case S2LET_SAMPLING_MW:
    -
    594  ssht_adjoint_mw_forward_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    595  break;
    -
    596  case S2LET_SAMPLING_MW_SS:
    -
    597  ssht_adjoint_mw_forward_sov_sym_ss_real(f, flm, L, dl_method, verbosity);
    -
    598  break;
    -
    599  default:
    -
    600  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    601  }
    -
    602 
    -
    603  free(flm);
    -
    604 }
    -
    -
    s2let_analysis_adjoint_wav2px_real
    void s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_analysis_adjoint.c:576
    -
    s2let_analysis_adjoint_lmn2lm_real
    void s2let_analysis_adjoint_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_analysis_adjoint.c:114
    -
    s2let_analysis_adjoint_wav2lm_real
    void s2let_analysis_adjoint_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_analysis_adjoint.c:440
    -
    s2let_analysis_adjoint_wav2lm
    void s2let_analysis_adjoint_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_analysis_adjoint.c:339
    -
    s2let_tiling_wavelet_allocate
    void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:339
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_analysis_adjoint_wav2px
    void s2let_analysis_adjoint_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_analysis_adjoint.c:532
    -
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    -
    s2let_analysis_adjoint_lmn2lm
    void s2let_analysis_adjoint_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_analysis_adjoint.c:27
    - -
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    ABS
    #define ABS(a)
    Definition: s2let_math.h:13
    -
    s2let_analysis_adjoint_wav2lm_manual
    void s2let_analysis_adjoint_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    Definition: s2let_analysis_adjoint.c:225
    -
    s2let_allocate_lmn_f_wav
    void s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:82
    -
    S2LET_ERROR_GENERIC
    #define S2LET_ERROR_GENERIC(comment)
    Definition: s2let_error.h:13
    -
    S2LET_SAMPLING_MW_SS
    @ S2LET_SAMPLING_MW_SS
    Definition: s2let_types.h:32
    -
    s2let_tiling_wavelet
    void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:388
    -
    s2let_parameters_t::reality
    int reality
    Definition: s2let_types.h:70
    -
    PI
    #define PI
    Definition: s2let_math.h:9
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_L0
    int s2let_L0(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:83
    -
    MAX
    #define MAX(a, b)
    Definition: s2let_math.h:12
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    -
    S2LET_SAMPLING_MW
    @ S2LET_SAMPLING_MW
    Definition: s2let_types.h:25
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__analysis__adjoint_8h.html b/docs/c/s2let__analysis__adjoint_8h.html index 448c9ead..13dbea58 100644 --- a/docs/c/s2let__analysis__adjoint_8h.html +++ b/docs/c/s2let__analysis__adjoint_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_analysis_adjoint.h File Reference +s2let: include/s2let_analysis_adjoint.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_analysis_adjoint.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -584,14 +634,12 @@

    Definition at line 576 of file s2let_analysis_adjoint.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__analysis__adjoint_8h__dep__incl.map b/docs/c/s2let__analysis__adjoint_8h__dep__incl.map new file mode 100644 index 00000000..2585bb07 --- /dev/null +++ b/docs/c/s2let__analysis__adjoint_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__analysis__adjoint_8h__dep__incl.md5 b/docs/c/s2let__analysis__adjoint_8h__dep__incl.md5 new file mode 100644 index 00000000..a3dbb50b --- /dev/null +++ b/docs/c/s2let__analysis__adjoint_8h__dep__incl.md5 @@ -0,0 +1 @@ +cda72a3ab0ee0f26eb94da7936ec4a09 \ No newline at end of file diff --git a/docs/c/s2let__analysis__adjoint_8h__incl.map b/docs/c/s2let__analysis__adjoint_8h__incl.map new file mode 100644 index 00000000..242c06a5 --- /dev/null +++ b/docs/c/s2let__analysis__adjoint_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__analysis__adjoint_8h__incl.md5 b/docs/c/s2let__analysis__adjoint_8h__incl.md5 new file mode 100644 index 00000000..2ab921aa --- /dev/null +++ b/docs/c/s2let__analysis__adjoint_8h__incl.md5 @@ -0,0 +1 @@ +c5a45ca843eb42b28a5352ac38b093a8 \ No newline at end of file diff --git a/docs/c/s2let__analysis__adjoint_8h_source.html b/docs/c/s2let__analysis__adjoint_8h_source.html index edaafd6e..eb69030b 100644 --- a/docs/c/s2let__analysis__adjoint_8h_source.html +++ b/docs/c/s2let__analysis__adjoint_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_analysis_adjoint.h Source File +s2let: include/s2let_analysis_adjoint.h Source File @@ -22,10 +22,10 @@

    @@ -167,17 +167,17 @@
    201 #endif
    s2let_analysis_adjoint_wav2lm_real
    void s2let_analysis_adjoint_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    -
    s2let_analysis_adjoint_wav2px_real
    void s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_analysis_adjoint.c:576
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    s2let_analysis_adjoint_wav2px_real
    void s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_analysis_adjoint.c:530
    s2let_analysis_adjoint_lmn2lm
    void s2let_analysis_adjoint_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    s2let_analysis_adjoint_wav2px
    void s2let_analysis_adjoint_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    s2let_analysis_adjoint_wav2lm_manual
    void s2let_analysis_adjoint_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    s2let_analysis_adjoint_wav2lm
    void s2let_analysis_adjoint_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    s2let_analysis_adjoint_lmn2lm_real
    void s2let_analysis_adjoint_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__axisym__denoising__demo_8c.html b/docs/c/s2let__axisym__denoising__demo_8c.html index c5035428..c8daa351 100644 --- a/docs/c/s2let__axisym__denoising__demo_8c.html +++ b/docs/c/s2let__axisym__denoising__demo_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_axisym_denoising_demo.c File Reference +s2let: src/main/c/s2let_axisym_denoising_demo.c File Reference @@ -22,10 +22,10 @@ @@ -74,21 +74,57 @@
    s2let_axisym_denoising_demo.c File Reference
    -
    #include "s2let.h"
    -#include <assert.h>
    -#include <ssht/ssht.h>
    +
    #include <assert.h>
    #include <complex.h>
    +#include <math.h>
    +#include <ssht/ssht.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    -#include <math.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_axisym_denoising_demo.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    - + @@ -125,8 +161,6 @@

    PROGRAM : s2let_axisym_denoising_demo COMMAND : bin/s2let_axisym_denoising_demo ARGUMENTS : none

    -

    Definition at line 45 of file s2let_axisym_denoising_demo.c.

    - @@ -157,8 +191,6 @@

    Definition at line 32 of file s2let_axisym_denoising_demo.c.

    - @@ -201,14 +233,12 @@

    Definition at line 15 of file s2let_axisym_denoising_demo.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__axisym__denoising__demo_8c__incl.map b/docs/c/s2let__axisym__denoising__demo_8c__incl.map new file mode 100644 index 00000000..b750af78 --- /dev/null +++ b/docs/c/s2let__axisym__denoising__demo_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__axisym__denoising__demo_8c__incl.md5 b/docs/c/s2let__axisym__denoising__demo_8c__incl.md5 new file mode 100644 index 00000000..87b6576b --- /dev/null +++ b/docs/c/s2let__axisym__denoising__demo_8c__incl.md5 @@ -0,0 +1 @@ +28560459735034fd64a1bf3449e1c3f5 \ No newline at end of file diff --git a/docs/c/s2let__axisym__denoising__demo_8c_source.html b/docs/c/s2let__axisym__denoising__demo_8c_source.html deleted file mode 100644 index 497e880a..00000000 --- a/docs/c/s2let__axisym__denoising__demo_8c_source.html +++ /dev/null @@ -1,276 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_axisym_denoising_demo.c Source File - - - - - - - - - -
    -
    -

    Functions

    void s2let_lm_random_flm_real_sigma (complex double *flm, int L, int seed, double sigmanoise)
    void s2let_lm_random_flm_real_sigma (complex double *flm, int L, int seed, double sigmanoise)
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ More...
     
    double needletpower (double *wav_lm, int L)
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_axisym_denoising_demo.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <assert.h>
    -
    7 #include <ssht/ssht.h>
    -
    8 #include <complex.h>
    -
    9 #include <stdio.h>
    -
    10 #include <stdlib.h>
    -
    11 #include <string.h>
    -
    12 #include <math.h>
    -
    13 #include <time.h>
    -
    14 
    -
    15 void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise) {
    -
    16  int el, m, msign, i, i_op;
    -
    17  for (el=0; el<L; el++) {
    -
    18  m = 0;
    -
    19  i = el*el + el + m ;
    -
    20  flm[i] = (2.0*ran2_dp(seed) - 1.0);
    -
    21  for (m=1; m<=el; m++) {
    -
    22  i = el*el + el + m ;
    -
    23  flm[i] = sigmanoise * (2.0*ran2_dp(seed) - 1.0) + I * sigmanoise *(2.0*ran2_dp(seed) - 1.0);
    -
    24  i_op = el*el + el - m ;
    -
    25  msign = m & 1;
    -
    26  msign = 1 - msign - msign; // (-1)^m
    -
    27  flm[i_op] = msign * conj(flm[i]);
    -
    28  }
    -
    29  }
    -
    30 }
    -
    31 
    -
    32 double needletpower(double *wav_lm, int L){
    -
    33  int i;
    -
    34  double totalpower = 0;
    -
    35  for(i = 0; i < L; i++)
    -
    36  totalpower += pow(wav_lm[i], 2.0);
    -
    37  return totalpower;
    -
    38 }
    -
    39 
    -
    45 int main(int argc, char *argv[])
    -
    46 {
    -
    47  s2let_parameters_t parameters = {};
    -
    48 
    -
    49  const int seed = (int)(10000.0*(double)clock()/(double)CLOCKS_PER_SEC);
    -
    50  // PARAMETERS
    -
    51  const double SNR_in = 10.0; // Input SNR
    -
    52  const int nsigma = 3; // Number of sigmas for hard thresholding
    -
    53  const int multires = 1; // Multiresolution flag
    -
    54  const double B = 2; // Wavelet parameters
    -
    55  const int J_min = 0; // First wavelet scale to use
    -
    56 
    -
    57  char outfile[100];
    -
    58  double *f, *noise, *g, *g_wav, *g_scal, *wav_lm, *scal_lm, *f_denois, *remaining_noise;
    -
    59  complex double *noise_lm;
    -
    60 
    -
    61  parameters.B = B;
    -
    62  parameters.J_min = J_min;
    -
    63 
    -
    64  printf("--------------------------------------------------\n");
    -
    65  printf(" S2LET library : denoising example\n");
    -
    66  printf(" Earth tomography signal, MW sampling\n");
    -
    67  printf("--------------------------------------------------\n");
    -
    68 
    -
    69  char file[100] = "data/earth_tomo_mw_128.fits";
    -
    70  printf(" Reading file %s\n",file);
    -
    71  const int L = s2let_fits_mw_read_bandlimit(file);
    -
    72  parameters.L = L;
    -
    73  printf(" - Detected bandlimit L = %i\n",L);
    -
    74  int J = s2let_j_max(&parameters);
    -
    75  printf(" Parameters for wavelet denoising :\n");
    -
    76  s2let_switch_wavtype(1);
    -
    77  printf(" - Input SNR : %f\n",SNR_in);
    -
    78  printf(" - Sigma threshold : %i\n", nsigma);
    -
    79  printf(" - Multiresolution flag : %i\n", multires);
    -
    80  printf(" - Wavelet parameter : %f\n", B);
    -
    81  printf(" - Total number of wavelets : %i\n", J);
    -
    82  printf(" - First wavelet scale to be used : %i\n", J_min);
    -
    83 
    -
    84  s2let_allocate_mw_real(&f, L);
    -
    85  s2let_fits_mw_read_map(f, file, L); // Read MW map from file
    -
    86  printf(" File successfully read from file\n");
    -
    87 
    -
    88  // Compute noise standard deviation and generate noise
    -
    89  double sigmanoise = sqrt(pow(10.0, -SNR_in/10.0) * s2let_mw_power_real(f, L));
    -
    90  printf(" - Std dev of the noise (to match SNR) = %f\n", sigmanoise);
    -
    91  s2let_allocate_lm(&noise_lm, L);
    -
    92  s2let_lm_random_flm_real_sigma(noise_lm, L, seed, sigmanoise);
    -
    93  double SNR_actual = 10.0 * log10( s2let_mw_power_real(f, L) / s2let_lm_power(noise_lm, L));
    -
    94  printf(" - Actual (realised) SNR = %f\n", SNR_actual);
    -
    95 
    -
    96  // Add noise to the signal in real space
    -
    97  printf(" Contaminating the signal with this noise...");fflush(NULL);
    -
    98  s2let_allocate_mw_real(&noise, L);
    -
    99  s2let_mw_alm2map_real(noise, noise_lm, L);
    -
    100  s2let_allocate_mw_real(&g, L);
    -
    101  int i, j;
    -
    102  for(i = 0; i < L*(2*L-1); i++)
    -
    103  g[i] = f[i] + noise[i];
    -
    104  printf(" done\n");
    -
    105 
    -
    106  printf(" Performing wavelet decomposition...");fflush(NULL);
    -
    107  // Perform wavelet analysis from scratch with all signals given as MW maps
    -
    108  if(multires){
    -
    109  s2let_transform_axisym_allocate_mw_f_wav_multires_real(&g_wav, &g_scal, &parameters);
    -
    110  s2let_transform_axisym_wav_analysis_mw_multires_real(g_wav, g_scal, g, &parameters);
    -
    111  }else{
    -
    112  s2let_transform_axisym_allocate_mw_f_wav_real(&g_wav, &g_scal, &parameters);
    -
    113  s2let_transform_axisym_wav_analysis_mw_real(g_wav, g_scal, g, &parameters);
    -
    114  }
    -
    115  printf(" done\n");
    -
    116 
    -
    117  // Compute simple threshold for needlet coefficients based on noise model
    -
    118  printf(" Construct the threshold rule for the Gaussian noise\n");
    -
    119  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, &parameters);
    -
    120  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, &parameters);
    -
    121  double *treshold = (double*)calloc((J-J_min+1), sizeof(double));
    -
    122  for(j = J_min; j <= J; j++)
    -
    123  treshold[j-J_min] = sigmanoise * nsigma * sqrt(needletpower(wav_lm + j * L, L));
    -
    124 
    -
    125  printf(" Hard thresholding the wavelets...");fflush(NULL);
    -
    126  s2let_allocate_mw_real(&f_denois, L);
    -
    127  if(multires){
    -
    128  s2let_transform_axisym_wav_hardthreshold_multires_real(g_wav, treshold, &parameters);
    -
    129  s2let_transform_axisym_wav_synthesis_mw_multires_real(f_denois, g_wav, g_scal, &parameters);
    -
    130  }else{
    -
    131  s2let_transform_axisym_wav_hardthreshold_real(g_wav, treshold, &parameters);
    -
    132  s2let_transform_axisym_wav_synthesis_mw_real(f_denois, g_wav, g_scal, &parameters);
    -
    133  }
    -
    134  printf(" done\n");
    -
    135 
    -
    136  // Remaining noise
    -
    137  s2let_allocate_mw_real(&remaining_noise, L);
    -
    138  for(i = 0; i < L*(2*L-1); i++)
    -
    139  remaining_noise[i] = f_denois[i] - f[i];
    -
    140 
    -
    141  // SNR after denoising
    -
    142  double SNR_denoised = 10.0 * log10( s2let_mw_power_real(f, L) / s2let_mw_power_real(remaining_noise, L));
    -
    143  printf(" -> SNR before denoising = %f\n", SNR_actual);
    -
    144  printf(" -> SNR after denoising = %f\n", SNR_denoised);
    -
    145 
    -
    146  // Finally write the denoised signal
    -
    147  printf(" Write output files\n");
    -
    148  sprintf(outfile, "%s%s%s", "data/earth_tomo_mw_128", "_noisy" , ".fits");
    -
    149  printf(" Outfile = %s\n",outfile);
    -
    150  remove(outfile); // In case the file exists
    -
    151  s2let_fits_mw_write_map(outfile, g, L); // Now write the map to fits file
    -
    152  char params[100];
    -
    153  sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min);
    -
    154  sprintf(outfile, "%s%s%s", "data/earth_tomo_mw_128", "_denoised", ".fits");
    -
    155  printf(" Outfile = %s\n",outfile);
    -
    156  remove(outfile); // In case the file exists
    -
    157  s2let_fits_mw_write_map(outfile, f_denois, L); // Now write the map to fits file
    -
    158 
    -
    159  free(f);
    -
    160  free(noise);
    -
    161  free(g);
    -
    162  free(g_wav);
    -
    163  free(g_scal);
    -
    164  free(scal_lm);
    -
    165  free(f_denois);
    -
    166  free(remaining_noise);
    -
    167  free(noise_lm);
    -
    168 
    -
    169  printf("--------------------------------------------------\n");
    -
    170  return 0;
    -
    171 }
    -
    -
    s2let_transform_axisym_lm_wav
    void s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:98
    -
    s2let_transform_axisym_lm_allocate_wav
    void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:79
    -
    s2let_lm_power
    double s2let_lm_power(complex double *flm, int L)
    Definition: s2let_lm.c:16
    -
    s2let_transform_axisym_wav_analysis_mw_real
    void s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:660
    -
    s2let_transform_axisym_wav_synthesis_mw_real
    void s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:789
    -
    s2let_transform_axisym_wav_analysis_mw_multires_real
    void s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:918
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_transform_axisym_allocate_mw_f_wav_real
    void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:74
    - -
    s2let_transform_axisym_wav_hardthreshold_real
    void s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1184
    -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_transform_axisym_wav_synthesis_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1053
    -
    needletpower
    double needletpower(double *wav_lm, int L)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_axisym_denoising_demo.c:32
    -
    s2let_mw_power_real
    double s2let_mw_power_real(double *f, int L)
    Definition: s2let_mw.c:86
    -
    s2let_lm_random_flm_real_sigma
    void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_axisym_denoising_demo.c:15
    -
    s2let_allocate_mw_real
    void s2let_allocate_mw_real(double **f, int L)
    Definition: s2let_alloc.c:28
    -
    s2let_switch_wavtype
    void s2let_switch_wavtype(int typenum)
    Definition: s2let_tiling.c:23
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_axisym_denoising_demo.c:45
    -
    s2let_mw_alm2map_real
    void s2let_mw_alm2map_real(double *f, const complex double *flm, int L)
    Definition: s2let_mw.c:50
    -
    s2let_fits_mw_read_bandlimit
    int s2let_fits_mw_read_bandlimit(char *filename)
    Definition: s2let_fits.c:18
    -
    s2let_fits_mw_write_map
    void s2let_fits_mw_write_map(char *filename, double *f, int L)
    Definition: s2let_fits.c:98
    -
    s2let_transform_axisym_wav_hardthreshold_multires_real
    void s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1214
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_fits_mw_read_map
    void s2let_fits_mw_read_map(double *f, char *filename, int L)
    Definition: s2let_fits.c:207
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    ran2_dp
    double ran2_dp(int idum)
    Definition: s2let_math.c:104
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_transform_axisym_allocate_mw_f_wav_multires_real
    void s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:94
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__axisym__denoising__demo_8h.html b/docs/c/s2let__axisym__denoising__demo_8h.html index b4e46bb8..fb3cdc23 100644 --- a/docs/c/s2let__axisym__denoising__demo_8h.html +++ b/docs/c/s2let__axisym__denoising__demo_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_axisym_denoising_demo.h File Reference +s2let: include/s2let_axisym_denoising_demo.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,12 +75,21 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_axisym_denoising_demo.h:
    +
    +
    + + + + +

    Go to the source code of this file.

    - + @@ -116,8 +125,6 @@

    Definition at line 32 of file s2let_axisym_denoising_demo.c.

    - @@ -160,14 +167,12 @@

    Definition at line 15 of file s2let_axisym_denoising_demo.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__axisym__denoising__demo_8h__incl.map b/docs/c/s2let__axisym__denoising__demo_8h__incl.map new file mode 100644 index 00000000..cfb5a556 --- /dev/null +++ b/docs/c/s2let__axisym__denoising__demo_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__axisym__denoising__demo_8h__incl.md5 b/docs/c/s2let__axisym__denoising__demo_8h__incl.md5 new file mode 100644 index 00000000..00459bcf --- /dev/null +++ b/docs/c/s2let__axisym__denoising__demo_8h__incl.md5 @@ -0,0 +1 @@ +42d6c41f0c8c33aefa9160b3f1bf3533 \ No newline at end of file diff --git a/docs/c/s2let__axisym__denoising__demo_8h_source.html b/docs/c/s2let__axisym__denoising__demo_8h_source.html index 55fbfa99..c60b9c70 100644 --- a/docs/c/s2let__axisym__denoising__demo_8h_source.html +++ b/docs/c/s2let__axisym__denoising__demo_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_axisym_denoising_demo.h Source File +s2let: include/s2let_axisym_denoising_demo.h Source File @@ -22,10 +22,10 @@

    @@ -85,7 +85,7 @@
    11 #endif
    12 
    14 
    -
    15 void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise);
    +
    15 void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise);
    16 
    18 
    19 double needletpower(double *wav_lm, int L);
    @@ -96,11 +96,12 @@
    24 #endif
    25 #endif
    -
    needletpower
    double needletpower(double *wav_lm, int L)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_axisym_denoising_demo.c:32
    -
    s2let_lm_random_flm_real_sigma
    void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_axisym_denoising_demo.c:15
    +
    needletpower
    double needletpower(double *wav_lm, int L)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_axisym_denoising_demo.c:35
    +
    s2let_lm_random_flm_real_sigma
    void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_axisym_denoising_demo.c:16
    +
    seed
    const int seed
    Definition: test_adjoint.c:9
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__denoising__demo_8c.html b/docs/c/s2let__denoising__demo_8c.html index f72d21c4..81493f39 100644 --- a/docs/c/s2let__denoising__demo_8c.html +++ b/docs/c/s2let__denoising__demo_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_denoising_demo.c File Reference +s2let: src/main/c/s2let_denoising_demo.c File Reference @@ -22,10 +22,10 @@ @@ -74,21 +74,57 @@
    s2let_denoising_demo.c File Reference
    -
    #include "s2let.h"
    -#include <ssht/ssht.h>
    -#include <assert.h>
    +
    #include <assert.h>
    #include <complex.h>
    +#include <math.h>
    +#include <ssht/ssht.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    -#include <math.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_denoising_demo.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -

    Functions

    void s2let_lm_random_flm_real_sigma (complex double *flm, int L, int seed, double sigmanoise)
    void s2let_lm_random_flm_real_sigma (complex double *flm, int L, int seed, double sigmanoise)
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ More...
     
    double needletpower (double *wav_lm, int L)
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    - + @@ -135,8 +171,6 @@

    Definition at line 40 of file s2let_denoising_demo.c.

    - @@ -166,8 +200,6 @@

    PROGRAM : s2let_denoising_demo COMMAND : bin/s2let_denoising_demo ARGUMENTS : none

    -

    Definition at line 66 of file s2let_denoising_demo.c.

    - @@ -210,8 +242,6 @@

    Definition at line 15 of file s2let_denoising_demo.c.

    - @@ -242,14 +272,12 @@

    Definition at line 32 of file s2let_denoising_demo.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__denoising__demo_8c__incl.map b/docs/c/s2let__denoising__demo_8c__incl.map new file mode 100644 index 00000000..d9517fd9 --- /dev/null +++ b/docs/c/s2let__denoising__demo_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__denoising__demo_8c__incl.md5 b/docs/c/s2let__denoising__demo_8c__incl.md5 new file mode 100644 index 00000000..9779b009 --- /dev/null +++ b/docs/c/s2let__denoising__demo_8c__incl.md5 @@ -0,0 +1 @@ +5e3fae1296fffd461eb601ac65cb2a89 \ No newline at end of file diff --git a/docs/c/s2let__denoising__demo_8c_source.html b/docs/c/s2let__denoising__demo_8c_source.html deleted file mode 100644 index c55ae5a5..00000000 --- a/docs/c/s2let__denoising__demo_8c_source.html +++ /dev/null @@ -1,300 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_denoising_demo.c Source File - - - - - - - - - -
    -
    -

    Functions

    void s2let_lm_random_flm_real_sigma (complex double *flm, int L, int seed, double sigmanoise)
    void s2let_lm_random_flm_real_sigma (complex double *flm, int L, int seed, double sigmanoise)
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ More...
     
    double waveletpower (complex double *wav_lm, int L)
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_denoising_demo.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <ssht/ssht.h>
    -
    7 #include <assert.h>
    -
    8 #include <complex.h>
    -
    9 #include <stdio.h>
    -
    10 #include <stdlib.h>
    -
    11 #include <string.h>
    -
    12 #include <math.h>
    -
    13 #include <time.h>
    -
    14 
    -
    15 void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise) {
    -
    16  int el, m, msign, i, i_op;
    -
    17  for (el=0; el<L; el++) {
    -
    18  m = 0;
    -
    19  i = el*el + el + m ;
    -
    20  flm[i] = (2.0*ran2_dp(seed) - 1.0);
    -
    21  for (m=1; m<=el; m++) {
    -
    22  i = el*el + el + m ;
    -
    23  flm[i] = sigmanoise * (2.0*ran2_dp(seed) - 1.0) + I * sigmanoise *(2.0*ran2_dp(seed) - 1.0);
    -
    24  i_op = el*el + el - m ;
    -
    25  msign = m & 1;
    -
    26  msign = 1 - msign - msign; // (-1)^m
    -
    27  flm[i_op] = msign * conj(flm[i]);
    -
    28  }
    -
    29  }
    -
    30 }
    -
    31 
    -
    32 double waveletpower(complex double *wav_lm, int L){
    -
    33  int i;
    -
    34  double totalpower = 0;
    -
    35  for(i = 0; i < L*L; i++)
    -
    36  totalpower += wav_lm[i] * conj(wav_lm[i]);
    -
    37  return totalpower;
    -
    38 }
    -
    39 
    -
    40 void hard_threshold_real(
    -
    41  double *g_wav,
    -
    42  const double *threshold,
    -
    43  const s2let_parameters_t *parameters
    -
    44 ) {
    -
    45  int L = parameters->L;
    -
    46  int J_min = parameters->J_min;
    -
    47  int N = parameters->N;
    -
    48 
    -
    49  int J = s2let_j_max(parameters);
    -
    50  int i, j, offset = 0;
    -
    51  for(j = J_min; j <= J; j++){
    -
    52  int bl = parameters->upsample ? L : MIN(s2let_bandlimit(j, parameters), L);
    -
    53  for(i = 0; i < N*bl*(2*bl-1); i++){
    -
    54  if( cabs(g_wav[offset + i]) < threshold[j-J_min] )
    -
    55  g_wav[offset + i] = 0;
    -
    56  }
    -
    57  offset += N*bl*(2*bl-1);
    -
    58  }
    -
    59 }
    -
    60 
    -
    66 int main(int argc, char *argv[])
    -
    67 {
    -
    68  s2let_parameters_t parameters = {};
    -
    69 
    -
    70  const int seed = (int)(10000.0*(double)clock()/(double)CLOCKS_PER_SEC);
    -
    71  // PARAMETERS
    -
    72  const double SNR_in = 10.0; // Input SNR
    -
    73  const int nsigma = 3; // Number of sigmas for hard thresholding
    -
    74  const int upsample = 0; // Multiresolution flag
    -
    75  const double B = 2; // Wavelet parameters
    -
    76  const int N = 4; // Azimuthal band-limit
    -
    77  const int J_min = 0; // First wavelet scale to use
    -
    78 
    -
    79  char outfile[100];
    -
    80  int i, j;
    -
    81  double *f, *noise, *g, *g_wav, *g_scal, *scal_l, *f_denoised, *remaining_noise;
    -
    82  complex double *noise_lm, *wav_lm;
    -
    83 
    -
    84  parameters.B = B;
    -
    85  parameters.J_min = J_min;
    -
    86  parameters.N = N;
    -
    87  parameters.upsample = upsample;
    -
    88  parameters.reality = 1;
    -
    89 
    -
    90  printf("--------------------------------------------------\n");
    -
    91  printf(" S2LET library : denoising example\n");
    -
    92  printf(" Earth tomography signal, MW sampling\n");
    -
    93  printf("--------------------------------------------------\n");
    -
    94 
    -
    95  char file[100] = "data/earth_tomo_mw_128.fits";
    -
    96  printf(" Reading file %s\n",file);
    -
    97  const int L = s2let_fits_mw_read_bandlimit(file);
    -
    98  parameters.L = L;
    -
    99  printf(" - Detected bandlimit L = %i\n",L);
    -
    100  int J = s2let_j_max(&parameters);
    -
    101  printf(" Parameters for wavelet denoising :\n");
    -
    102  s2let_switch_wavtype(1);
    -
    103  printf(" - Input SNR : %f\n",SNR_in);
    -
    104  printf(" - Sigma threshold : %i\n", nsigma);
    -
    105  printf(" - upsample flag : %i\n", upsample);
    -
    106  printf(" - Wavelet parameter : %i\n", B);
    -
    107  printf(" - Total number of wavelets : %i\n", J);
    -
    108  printf(" - First wavelet scale to be used : %i\n", J_min);
    -
    109 
    -
    110  s2let_allocate_mw_real(&f, L);
    -
    111  s2let_fits_mw_read_map(f, file, L); // Read MW map from file
    -
    112  for(i = 0; i < L*(2*L-1); i++)
    -
    113  f[i] = f[i] * 1000;
    -
    114  printf(" File successfully read from file\n");
    -
    115 
    -
    116  // Compute noise standard deviation and generate noise
    -
    117  double sigmanoise = sqrt(pow(10.0, -SNR_in/10.0) * s2let_mw_power_real(f, L));
    -
    118  printf(" - Std dev of the noise (to match SNR) = %f\n", sigmanoise);
    -
    119  s2let_allocate_lm(&noise_lm, L);
    -
    120  s2let_lm_random_flm_real_sigma(noise_lm, L, seed, sigmanoise);
    -
    121  double SNR_actual = 10.0 * log10( s2let_mw_power_real(f, L) / s2let_lm_power(noise_lm, L));
    -
    122  printf(" - Actual (realised) SNR = %f\n", SNR_actual);
    -
    123 
    -
    124  // Add noise to the signal in real space
    -
    125  printf(" Contaminating the signal with this noise...");fflush(NULL);
    -
    126  s2let_allocate_mw_real(&noise, L);
    -
    127  s2let_mw_alm2map_real(noise, noise_lm, L);
    -
    128  s2let_allocate_mw_real(&g, L);
    -
    129  for(i = 0; i < L*(2*L-1); i++)
    -
    130  g[i] = f[i] + noise[i];
    -
    131  printf(" done\n");
    -
    132 
    -
    133  printf(" Performing wavelet decomposition...");fflush(NULL);
    -
    134  // Perform wavelet analysis from scratch with all signals given as MW maps
    -
    135  s2let_allocate_f_wav_real(&g_wav, &g_scal, &parameters);
    -
    136  s2let_analysis_px2wav_real(g_wav, g_scal, g, &parameters);
    -
    137  printf(" done\n");
    -
    138 
    -
    139  // Compute simple threshold for needlet coefficients based on noise model
    -
    140  printf(" Construct the threshold rule for the Gaussian noise\n");
    -
    141  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &parameters);
    -
    142  s2let_tiling_wavelet(wav_lm, scal_l, &parameters);
    -
    143  double *threshold = (double*)calloc((J-J_min+1), sizeof(double));
    -
    144  for(j = J_min; j <= J; j++)
    -
    145  threshold[j-J_min] = sigmanoise * nsigma * sqrt(waveletpower(wav_lm + j * L*L, L));
    -
    146 
    -
    147  printf(" Hard thresholding the wavelets...");fflush(NULL);
    -
    148  s2let_allocate_mw_real(&f_denoised, L);
    -
    149  hard_threshold_real(g_wav, threshold, &parameters);
    -
    150  s2let_synthesis_wav2px_real(f_denoised, g_wav, g_scal, &parameters);
    -
    151  printf(" done\n");
    -
    152 
    -
    153  // Remaining noise
    -
    154  s2let_allocate_mw_real(&remaining_noise, L);
    -
    155  for(i = 0; i < L*(2*L-1); i++)
    -
    156  remaining_noise[i] = f_denoised[i] - f[i];
    -
    157 
    -
    158  // SNR after denoising
    -
    159  double SNR_denoised = 10.0 * log10( s2let_mw_power_real(f, L) / s2let_mw_power_real(remaining_noise, L));
    -
    160  printf(" -> SNR before denoising = %f\n", SNR_actual);
    -
    161  printf(" -> SNR after denoising = %f\n", SNR_denoised);
    -
    162 
    -
    163  // Finally write the denoised signal
    -
    164  printf(" Write output files\n");
    -
    165  sprintf(outfile, "%s%s%s", "data/real_signal", "_U_input" , ".fits");
    -
    166  printf(" Outfile = %s\n",outfile);
    -
    167  remove(outfile); // In case the file exists
    -
    168  s2let_fits_mw_write_map(outfile, f, L); // Now write the map to fits file
    -
    169  sprintf(outfile, "%s%s%s", "data/real_signal", "_U_noise" , ".fits");
    -
    170  printf(" Outfile = %s\n",outfile);
    -
    171  remove(outfile); // In case the file exists
    -
    172  s2let_fits_mw_write_map(outfile, noise, L); // Now write the map to fits file
    -
    173  sprintf(outfile, "%s%s%s", "data/real_signal", "_U_input_noise" , ".fits");
    -
    174  printf(" Outfile = %s\n",outfile);
    -
    175  remove(outfile); // In case the file exists
    -
    176  s2let_fits_mw_write_map(outfile, g, L); // Now write the map to fits file
    -
    177  sprintf(outfile, "%s%s%s", "data/real_signal", "_U_denoised", ".fits");
    -
    178  printf(" Outfile = %s\n",outfile);
    -
    179  remove(outfile); // In case the file exists
    -
    180  s2let_fits_mw_write_map(outfile, f_denoised, L); // Now write the map to fits file
    -
    181 
    -
    182  free(f);
    -
    183  free(noise);
    -
    184  free(g);
    -
    185  free(g_wav);
    -
    186  free(g_scal);
    -
    187  free(scal_l);
    -
    188  free(f_denoised);
    -
    189  free(remaining_noise);
    -
    190  free(noise_lm);
    -
    191 
    -
    192  printf("--------------------------------------------------\n");
    -
    193  return 0;
    -
    194 }
    -
    -
    s2let_allocate_f_wav_real
    void s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:128
    -
    s2let_lm_power
    double s2let_lm_power(complex double *flm, int L)
    Definition: s2let_lm.c:16
    -
    s2let_synthesis_wav2px_real
    void s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:563
    -
    s2let_tiling_wavelet_allocate
    void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:339
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    hard_threshold_real
    void hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_denoising_demo.c:40
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_lm_random_flm_real_sigma
    void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_denoising_demo.c:15
    -
    s2let_mw_power_real
    double s2let_mw_power_real(double *f, int L)
    Definition: s2let_mw.c:86
    -
    s2let_allocate_mw_real
    void s2let_allocate_mw_real(double **f, int L)
    Definition: s2let_alloc.c:28
    -
    s2let_switch_wavtype
    void s2let_switch_wavtype(int typenum)
    Definition: s2let_tiling.c:23
    -
    waveletpower
    double waveletpower(complex double *wav_lm, int L)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_denoising_demo.c:32
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_denoising_demo.c:66
    -
    s2let_mw_alm2map_real
    void s2let_mw_alm2map_real(double *f, const complex double *flm, int L)
    Definition: s2let_mw.c:50
    -
    s2let_fits_mw_read_bandlimit
    int s2let_fits_mw_read_bandlimit(char *filename)
    Definition: s2let_fits.c:18
    -
    s2let_tiling_wavelet
    void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:388
    -
    s2let_parameters_t::reality
    int reality
    Definition: s2let_types.h:70
    -
    s2let_fits_mw_write_map
    void s2let_fits_mw_write_map(char *filename, double *f, int L)
    Definition: s2let_fits.c:98
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_fits_mw_read_map
    void s2let_fits_mw_read_map(double *f, char *filename, int L)
    Definition: s2let_fits.c:207
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_analysis_px2wav_real
    void s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:541
    -
    ran2_dp
    double ran2_dp(int idum)
    Definition: s2let_math.c:104
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__denoising__demo_8h.html b/docs/c/s2let__denoising__demo_8h.html index c96af0ec..cc7c3f18 100644 --- a/docs/c/s2let__denoising__demo_8h.html +++ b/docs/c/s2let__denoising__demo_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_denoising_demo.h File Reference +s2let: include/s2let_denoising_demo.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,12 +75,21 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_denoising_demo.h:
    +
    +
    + + + + +

    Go to the source code of this file.

    - + @@ -125,8 +134,6 @@

    Definition at line 40 of file s2let_denoising_demo.c.

    - @@ -169,8 +176,6 @@

    Definition at line 15 of file s2let_axisym_denoising_demo.c.

    - @@ -201,14 +206,12 @@

    Definition at line 32 of file s2let_denoising_demo.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__denoising__demo_8h__incl.map b/docs/c/s2let__denoising__demo_8h__incl.map new file mode 100644 index 00000000..e9bdead8 --- /dev/null +++ b/docs/c/s2let__denoising__demo_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__denoising__demo_8h__incl.md5 b/docs/c/s2let__denoising__demo_8h__incl.md5 new file mode 100644 index 00000000..5c2f2c8e --- /dev/null +++ b/docs/c/s2let__denoising__demo_8h__incl.md5 @@ -0,0 +1 @@ +b115925742d95ef17b309b1e0ab81c44 \ No newline at end of file diff --git a/docs/c/s2let__denoising__demo_8h_source.html b/docs/c/s2let__denoising__demo_8h_source.html index 46d460f9..0ff05b7b 100644 --- a/docs/c/s2let__denoising__demo_8h_source.html +++ b/docs/c/s2let__denoising__demo_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_denoising_demo.h Source File +s2let: include/s2let_denoising_demo.h Source File @@ -22,10 +22,10 @@

    @@ -85,7 +85,7 @@
    11 #endif
    12 
    14 
    -
    15 void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise);
    +
    15 void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise);
    16 
    18 
    19 double waveletpower(complex double *wav_lm, int L);
    @@ -98,13 +98,14 @@
    27 #endif
    28 #endif
    -
    hard_threshold_real
    void hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_denoising_demo.c:40
    -
    waveletpower
    double waveletpower(complex double *wav_lm, int L)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_denoising_demo.c:32
    -
    s2let_lm_random_flm_real_sigma
    void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_axisym_denoising_demo.c:15
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    hard_threshold_real
    void hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_denoising_demo.c:43
    +
    waveletpower
    double waveletpower(complex double *wav_lm, int L)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_denoising_demo.c:35
    +
    s2let_lm_random_flm_real_sigma
    void s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_axisym_denoising_demo.c:16
    +
    seed
    const int seed
    Definition: test_adjoint.c:9
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__error_8h.html b/docs/c/s2let__error_8h.html index 417057b4..2713ab23 100644 --- a/docs/c/s2let__error_8h.html +++ b/docs/c/s2let__error_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_error.h File Reference +s2let: include/s2let_error.h File Reference @@ -22,10 +22,10 @@ @@ -76,6 +76,57 @@
    #include <stdio.h>
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_error.h:
    +
    +
    + + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    Functions

    void s2let_lm_random_flm_real_sigma (complex double *flm, int L, int seed, double sigmanoise)
    void s2let_lm_random_flm_real_sigma (complex double *flm, int L, int seed, double sigmanoise)
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ More...
     
    double waveletpower (complex double *wav_lm, int L)
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -112,8 +163,6 @@

    exit(1); \
    }
    -

    Definition at line 13 of file s2let_error.h.

    - @@ -135,14 +184,12 @@

    S2LET_ERROR_GENERIC("Memory allocation failed") \
    }
    -

    Definition at line 24 of file s2let_error.h.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__error_8h__dep__incl.map b/docs/c/s2let__error_8h__dep__incl.map new file mode 100644 index 00000000..d083820b --- /dev/null +++ b/docs/c/s2let__error_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__error_8h__dep__incl.md5 b/docs/c/s2let__error_8h__dep__incl.md5 new file mode 100644 index 00000000..62028d80 --- /dev/null +++ b/docs/c/s2let__error_8h__dep__incl.md5 @@ -0,0 +1 @@ +79b7ed4a3a0760cffa0fcffaa4267d7b \ No newline at end of file diff --git a/docs/c/s2let__error_8h__incl.map b/docs/c/s2let__error_8h__incl.map new file mode 100644 index 00000000..d08f8108 --- /dev/null +++ b/docs/c/s2let__error_8h__incl.map @@ -0,0 +1,5 @@ + + + + + diff --git a/docs/c/s2let__error_8h__incl.md5 b/docs/c/s2let__error_8h__incl.md5 new file mode 100644 index 00000000..4bde79bc --- /dev/null +++ b/docs/c/s2let__error_8h__incl.md5 @@ -0,0 +1 @@ +e54eba39331bbe3520c7c0a2e234c0f2 \ No newline at end of file diff --git a/docs/c/s2let__error_8h_source.html b/docs/c/s2let__error_8h_source.html index d404347c..f2a020df 100644 --- a/docs/c/s2let__error_8h_source.html +++ b/docs/c/s2let__error_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_error.h Source File +s2let: include/s2let_error.h Source File @@ -22,10 +22,10 @@

    @@ -107,7 +107,7 @@
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__fits_8c.html b/docs/c/s2let__fits_8c.html index a39745b3..81ab1b7c 100644 --- a/docs/c/s2let__fits_8c.html +++ b/docs/c/s2let__fits_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_fits.c File Reference +s2let: src/main/c/s2let_fits.c File Reference @@ -22,10 +22,10 @@ @@ -76,9 +76,42 @@
    #include <fitsio.h>
    #include "s2let.h"
    +
    +Include dependency graph for s2let_fits.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    @@ -121,8 +154,6 @@

    -

    Definition at line 9 of file s2let_fits.c.

    - @@ -154,8 +185,6 @@

    Definition at line 59 of file s2let_fits.c.

    - @@ -187,8 +216,6 @@

    Definition at line 18 of file s2let_fits.c.

    - @@ -238,8 +265,6 @@

    Definition at line 207 of file s2let_fits.c.

    - @@ -295,8 +320,6 @@

    Definition at line 437 of file s2let_fits.c.

    - @@ -346,8 +369,6 @@

    Definition at line 98 of file s2let_fits.c.

    - @@ -403,8 +424,6 @@

    Definition at line 322 of file s2let_fits.c.

    - @@ -454,8 +473,6 @@

    Definition at line 260 of file s2let_fits.c.

    - @@ -511,8 +528,6 @@

    Definition at line 494 of file s2let_fits.c.

    - @@ -562,8 +577,6 @@

    Definition at line 149 of file s2let_fits.c.

    - @@ -619,14 +632,12 @@

    Definition at line 376 of file s2let_fits.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__fits_8c__incl.map b/docs/c/s2let__fits_8c__incl.map new file mode 100644 index 00000000..1b667668 --- /dev/null +++ b/docs/c/s2let__fits_8c__incl.map @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__fits_8c__incl.md5 b/docs/c/s2let__fits_8c__incl.md5 new file mode 100644 index 00000000..2c38bac7 --- /dev/null +++ b/docs/c/s2let__fits_8c__incl.md5 @@ -0,0 +1 @@ +3c50de52687912afb7e7ec7ac06ed31d \ No newline at end of file diff --git a/docs/c/s2let__fits_8c_source.html b/docs/c/s2let__fits_8c_source.html deleted file mode 100644 index bca4e7cd..00000000 --- a/docs/c/s2let__fits_8c_source.html +++ /dev/null @@ -1,772 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_fits.c Source File - - - - - - - - - -
    -
    -

    Functions

    void printerror (int status)
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_fits.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include <fitsio.h>
    -
    6 #include "s2let.h"
    -
    7 
    -
    8 
    -
    9 void printerror(int status)
    -
    10 {
    -
    11  if (status){
    -
    12  fits_report_error(stderr, status); /* print error report */
    -
    13  exit( status ); /* terminate the program, returning error status */
    -
    14  }
    -
    15  return;
    -
    16 }
    -
    17 
    -
    18 int s2let_fits_mw_read_bandlimit(char* filename)
    -
    19 {
    -
    20  long naxes, *naxis, Lread;
    -
    21  int status, hdutype, nfound;
    -
    22  char comment[FLEN_COMMENT];
    -
    23  fitsfile *fptr;
    -
    24  status = 0;
    -
    25 
    -
    26 
    -
    27  if ( fits_open_file(&fptr, filename, READONLY, &status) )
    -
    28  printerror( status );
    -
    29 
    -
    30  if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) )
    -
    31  printerror( status );
    -
    32 
    -
    33  if (hdutype != BINARY_TBL)
    -
    34  fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__);
    -
    35 
    -
    36  if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) )
    -
    37  printerror( status );
    -
    38 
    -
    39  naxis = (long *)malloc(((size_t)naxes)*sizeof(long));
    -
    40  if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status)
    -
    41  || nfound != naxes )
    -
    42  printerror( status );
    -
    43 
    -
    44  if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) )
    -
    45  {
    -
    46  Lread = -1;
    -
    47  status = 0;
    -
    48  }
    -
    49 
    -
    50 
    -
    51  if ( fits_close_file(fptr, &status) )
    -
    52  printerror( status );
    -
    53 
    -
    54  return Lread;
    -
    55 
    -
    56 }
    -
    57 
    -
    58 
    -
    59 int s2let_fits_hpx_read_nside(char* filename)
    -
    60 {
    -
    61  long naxes, *naxis, nsideread;
    -
    62  int status, hdutype, nfound;
    -
    63  char comment[FLEN_COMMENT];
    -
    64  fitsfile *fptr;
    -
    65  status = 0;
    -
    66 
    -
    67 
    -
    68  if ( fits_open_file(&fptr, filename, READONLY, &status) )
    -
    69  printerror( status );
    -
    70 
    -
    71  if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) )
    -
    72  printerror( status );
    -
    73 
    -
    74  if (hdutype != BINARY_TBL)
    -
    75  fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__);
    -
    76 
    -
    77  if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) )
    -
    78  printerror( status );
    -
    79 
    -
    80  naxis = (long *)malloc(((size_t)naxes)*sizeof(long));
    -
    81  if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status)
    -
    82  || nfound != naxes )
    -
    83  printerror( status );
    -
    84 
    -
    85  if ( fits_read_key_lng(fptr, "NSIDE", &nsideread, comment, &status) )
    -
    86  {
    -
    87  nsideread = -1;
    -
    88  status = 0;
    -
    89  }
    -
    90 
    -
    91  if ( fits_close_file(fptr, &status) )
    -
    92  printerror( status );
    -
    93 
    -
    94  return nsideread;
    -
    95 
    -
    96 }
    -
    97 
    -
    98 void s2let_fits_mw_write_map(char* filename, double* f, int L)
    -
    99 {
    -
    100  fitsfile *fptr;
    -
    101  int status, hdutype;
    -
    102  long firstrow, firstelem;
    -
    103  int bitpix = SHORT_IMG;
    -
    104  long naxis = 0;
    -
    105  long naxes[] = {0,0};
    -
    106  int tfields = 1;
    -
    107  char extname[] = "BINTABLE";
    -
    108  char *ttype[] = { "SIGNAL" };
    -
    109  char *tform[] = { "1D" };
    -
    110  char *tunit[] = { " " };
    -
    111 
    -
    112  long npix = L * (2*L-1);
    -
    113  status = 0;
    -
    114 
    -
    115  if (fits_create_file(&fptr, filename, &status))
    -
    116  fprintf(stderr, "%s (%d): Could not create new fits file.\n",
    -
    117  __FILE__, __LINE__);
    -
    118 
    -
    119  if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) )
    -
    120  fprintf(stderr, "%s (%d): Could not create new image file.\n",
    -
    121  __FILE__, __LINE__);
    -
    122 
    -
    123  if ( fits_movabs_hdu(fptr, 1, &hdutype, &status) )
    -
    124  fprintf(stderr, "%s (%d): Could not move to first HDU.\n",
    -
    125  __FILE__, __LINE__);
    -
    126 
    -
    127  if ( fits_create_tbl( fptr, BINARY_TBL, npix, tfields, ttype, tform,
    -
    128  tunit, extname, &status) )
    -
    129  fprintf(stderr, "%s (%d): Could not create new binary table.\n",
    -
    130  __FILE__, __LINE__);
    -
    131 
    -
    132  if (fits_write_key(fptr, TINT, "L", &L,
    -
    133  "Resolution parameter", &status))
    -
    134  fprintf(stderr, "%s (%d): Could not write L keyword.\n",
    -
    135  __FILE__, __LINE__);
    -
    136 
    -
    137  firstrow = 1;
    -
    138  firstelem = 1;
    -
    139 
    -
    140  if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, npix, f, &status))
    -
    141  fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
    -
    142 
    -
    143  if ( fits_close_file(fptr, &status) ) /* close the FITS file */
    -
    144  fprintf(stderr, "%s (%d): Could not close file.\n",
    -
    145  __FILE__, __LINE__);
    -
    146 
    -
    147 }
    -
    148 
    -
    149 void s2let_fits_mwss_write_map(char* filename, double* f, int L)
    -
    150 {
    -
    151  fitsfile *fptr;
    -
    152  int status, hdutype;
    -
    153  long firstrow, firstelem;
    -
    154  int bitpix = SHORT_IMG;
    -
    155  long naxis = 0;
    -
    156  long naxes[] = {0,0};
    -
    157  int tfields = 1;
    -
    158  char extname[] = "BINTABLE";
    -
    159  char *ttype[] = { "SIGNAL" };
    -
    160  char *tform[] = { "1D" };
    -
    161  char *tunit[] = { " " };
    -
    162 
    -
    163  long npix = (L+1) * 2*L;
    -
    164  status = 0;
    -
    165 
    -
    166  if (fits_create_file(&fptr, filename, &status))
    -
    167  fprintf(stderr, "%s (%d): Could not create new fits file.\n",
    -
    168  __FILE__, __LINE__);
    -
    169 
    -
    170  if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) )
    -
    171  fprintf(stderr, "%s (%d): Could not create new image file.\n",
    -
    172  __FILE__, __LINE__);
    -
    173 
    -
    174  if ( fits_movabs_hdu(fptr, 1, &hdutype, &status) )
    -
    175  fprintf(stderr, "%s (%d): Could not move to first HDU.\n",
    -
    176  __FILE__, __LINE__);
    -
    177 
    -
    178  if ( fits_create_tbl( fptr, BINARY_TBL, npix, tfields, ttype, tform,
    -
    179  tunit, extname, &status) )
    -
    180  fprintf(stderr, "%s (%d): Could not create new binary table.\n",
    -
    181  __FILE__, __LINE__);
    -
    182 
    -
    183  if (fits_write_key(fptr, TINT, "L", &L,
    -
    184  "Resolution parameter", &status))
    -
    185  fprintf(stderr, "%s (%d): Could not write L keyword.\n",
    -
    186  __FILE__, __LINE__);
    -
    187 
    -
    188  int mwss = 1;
    -
    189  if (fits_write_key(fptr, TINT, "MWSS", &mwss,
    -
    190  "Sampling scheme parameter", &status))
    -
    191  fprintf(stderr, "%s (%d): Could not write MWSS keyword.\n",
    -
    192  __FILE__, __LINE__);
    -
    193 
    -
    194  firstrow = 1;
    -
    195  firstelem = 1;
    -
    196 
    -
    197  if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, npix, f, &status))
    -
    198  fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
    -
    199 
    -
    200  if ( fits_close_file(fptr, &status) ) /* close the FITS file */
    -
    201  fprintf(stderr, "%s (%d): Could not close file.\n",
    -
    202  __FILE__, __LINE__);
    -
    203 
    -
    204 }
    -
    205 
    -
    206 
    -
    207 void s2let_fits_mw_read_map(double* f, char* filename, int L)
    -
    208 {
    -
    209  long naxes, *naxis, npix, npercol, irow, Lread;
    -
    210  int status, hdutype, nfound, anynul;
    -
    211  float nulval;
    -
    212  char comment[FLEN_COMMENT];
    -
    213  fitsfile *fptr;
    -
    214  status = 0;
    -
    215 
    -
    216  if ( fits_open_file(&fptr, filename, READONLY, &status) )
    -
    217  printerror( status );
    -
    218 
    -
    219  if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) )
    -
    220  printerror( status );
    -
    221 
    -
    222 
    -
    223  if (hdutype != BINARY_TBL)
    -
    224  fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__);
    -
    225 
    -
    226  if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) )
    -
    227  printerror( status );
    -
    228 
    -
    229  naxis = (long *)malloc(((size_t)naxes)*sizeof(long));
    -
    230  if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status)
    -
    231  || nfound != naxes )
    -
    232  printerror( status );
    -
    233 
    -
    234  if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) )
    -
    235  printerror(status);
    -
    236 
    -
    237  if( Lread != L )
    -
    238  printf("Attention : read L = %li but you specified L = %i\n",Lread,L);
    -
    239 
    -
    240  npix = L * (2*L-1);
    -
    241 
    -
    242  if ( (npix%naxis[1]) != 0 )
    -
    243  fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__);
    -
    244 
    -
    245  npercol = npix/naxis[1];
    -
    246  nulval = -1.6375e30;
    -
    247  for (irow = 0; irow < naxis[1]; irow++) {
    -
    248 
    -
    249  if ( fits_read_col(fptr, TDOUBLE, 1, irow+1, 1, npercol, &nulval,
    -
    250  &(f[irow*npercol]), &anynul, &status) ) {
    -
    251  printerror(status);
    -
    252  }
    -
    253  }
    -
    254 
    -
    255  if ( fits_close_file(fptr, &status) )
    -
    256  printerror( status );
    -
    257 
    -
    258 }
    -
    259 
    -
    260 void s2let_fits_mwss_read_map(double* f, char* filename, int L)
    -
    261 {
    -
    262  long naxes, *naxis, npix, npercol, irow, Lread;
    -
    263  int status, hdutype, nfound, anynul;
    -
    264  float nulval;
    -
    265  char comment[FLEN_COMMENT];
    -
    266  fitsfile *fptr;
    -
    267  status = 0;
    -
    268 
    -
    269  if ( fits_open_file(&fptr, filename, READONLY, &status) )
    -
    270  printerror( status );
    -
    271 
    -
    272  if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) )
    -
    273  printerror( status );
    -
    274 
    -
    275 
    -
    276  if (hdutype != BINARY_TBL)
    -
    277  fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__);
    -
    278 
    -
    279  if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) )
    -
    280  printerror( status );
    -
    281 
    -
    282  naxis = (long *)malloc(((size_t)naxes)*sizeof(long));
    -
    283  if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status)
    -
    284  || nfound != naxes )
    -
    285  printerror( status );
    -
    286 
    -
    287  if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) )
    -
    288  printerror(status);
    -
    289 
    -
    290  if( Lread != L )
    -
    291  printf("Attention : read L = %li but you specified L = %i\n",Lread,L);
    -
    292 
    -
    293 
    -
    294  long mwss_read;
    -
    295  if ( fits_read_key_lng(fptr, "MWSS", &mwss_read, comment, &status) )
    -
    296  printerror(status);
    -
    297 
    -
    298  if( mwss_read != 1 )
    -
    299  printf("Attention : the file is not stored with MWSS sampling.\n");
    -
    300 
    -
    301  npix = (L+1) * 2*L;
    -
    302 
    -
    303  if ( (npix%naxis[1]) != 0 )
    -
    304  fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__);
    -
    305 
    -
    306  npercol = npix/naxis[1];
    -
    307  nulval = -1.6375e30;
    -
    308  for (irow = 0; irow < naxis[1]; irow++) {
    -
    309 
    -
    310  if ( fits_read_col(fptr, TDOUBLE, 1, irow+1, 1, npercol, &nulval,
    -
    311  &(f[irow*npercol]), &anynul, &status) ) {
    -
    312  printerror(status);
    -
    313  }
    -
    314  }
    -
    315 
    -
    316  if ( fits_close_file(fptr, &status) )
    -
    317  printerror( status );
    -
    318 
    -
    319 }
    -
    320 
    -
    321 
    -
    322 void s2let_fits_mw_write_spin_maps(char* filename, double* fQ, double*fU, int L)
    -
    323 {
    -
    324  fitsfile *fptr;
    -
    325  int status, hdutype;
    -
    326  long firstrow, firstelem;
    -
    327  int bitpix = SHORT_IMG;
    -
    328  long naxis = 0;
    -
    329  long naxes[] = {0,0};
    -
    330  int tfields = 2;
    -
    331  char extname[] = "BINTABLE";
    -
    332  char *ttype[] = { "Q_POLARISATION", "U_POLARISATION" };
    -
    333  char *tform[] = { "1D", "1D" };
    -
    334  char *tunit[] = { " ", " " };
    -
    335 
    -
    336  long npix = L * (2*L-1);
    -
    337  status = 0;
    -
    338 
    -
    339  if (fits_create_file(&fptr, filename, &status))
    -
    340  fprintf(stderr, "%s (%d): Could not create new fits file.\n",
    -
    341  __FILE__, __LINE__);
    -
    342 
    -
    343  if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) )
    -
    344  fprintf(stderr, "%s (%d): Could not create new image file.\n",
    -
    345  __FILE__, __LINE__);
    -
    346 
    -
    347  if ( fits_movabs_hdu(fptr, 1, &hdutype, &status) )
    -
    348  fprintf(stderr, "%s (%d): Could not move to first HDU.\n",
    -
    349  __FILE__, __LINE__);
    -
    350 
    -
    351  if ( fits_create_tbl( fptr, BINARY_TBL, npix, tfields, ttype, tform,
    -
    352  tunit, extname, &status) )
    -
    353  fprintf(stderr, "%s (%d): Could not create new binary table.\n",
    -
    354  __FILE__, __LINE__);
    -
    355 
    -
    356  if (fits_write_key(fptr, TINT, "L", &L,
    -
    357  "Resolution parameter", &status))
    -
    358  fprintf(stderr, "%s (%d): Could not write L keyword.\n",
    -
    359  __FILE__, __LINE__);
    -
    360 
    -
    361  firstrow = 1;
    -
    362  firstelem = 1;
    -
    363 
    -
    364  if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, npix, fQ, &status))
    -
    365  fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
    -
    366 
    -
    367  if (fits_write_col(fptr, TDOUBLE, 2, firstrow, firstelem, npix, fU, &status))
    -
    368  fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
    -
    369 
    -
    370  if ( fits_close_file(fptr, &status) ) /* close the FITS file */
    -
    371  fprintf(stderr, "%s (%d): Could not close file.\n",
    -
    372  __FILE__, __LINE__);
    -
    373 
    -
    374 }
    -
    375 
    -
    376 void s2let_fits_mwss_write_spin_maps(char* filename, double* fQ, double*fU, int L)
    -
    377 {
    -
    378  fitsfile *fptr;
    -
    379  int status, hdutype;
    -
    380  long firstrow, firstelem;
    -
    381  int bitpix = SHORT_IMG;
    -
    382  long naxis = 0;
    -
    383  long naxes[] = {0,0};
    -
    384  int tfields = 2;
    -
    385  char extname[] = "BINTABLE";
    -
    386  char *ttype[] = { "Q_POLARISATION", "U_POLARISATION" };
    -
    387  char *tform[] = { "1D", "1D" };
    -
    388  char *tunit[] = { " ", " " };
    -
    389 
    -
    390  long npix = (L+1) * 2*L;
    -
    391  status = 0;
    -
    392 
    -
    393  if (fits_create_file(&fptr, filename, &status))
    -
    394  fprintf(stderr, "%s (%d): Could not create new fits file.\n",
    -
    395  __FILE__, __LINE__);
    -
    396 
    -
    397  if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) )
    -
    398  fprintf(stderr, "%s (%d): Could not create new image file.\n",
    -
    399  __FILE__, __LINE__);
    -
    400 
    -
    401  if ( fits_movabs_hdu(fptr, 1, &hdutype, &status) )
    -
    402  fprintf(stderr, "%s (%d): Could not move to first HDU.\n",
    -
    403  __FILE__, __LINE__);
    -
    404 
    -
    405  if ( fits_create_tbl( fptr, BINARY_TBL, npix, tfields, ttype, tform,
    -
    406  tunit, extname, &status) )
    -
    407  fprintf(stderr, "%s (%d): Could not create new binary table.\n",
    -
    408  __FILE__, __LINE__);
    -
    409 
    -
    410  if (fits_write_key(fptr, TINT, "L", &L,
    -
    411  "Resolution parameter", &status))
    -
    412  fprintf(stderr, "%s (%d): Could not write L keyword.\n",
    -
    413  __FILE__, __LINE__);
    -
    414 
    -
    415  int mwss = 1;
    -
    416  if (fits_write_key(fptr, TINT, "MWSS", &mwss,
    -
    417  "Sampling scheme parameter", &status))
    -
    418  fprintf(stderr, "%s (%d): Could not write MWSS keyword.\n",
    -
    419  __FILE__, __LINE__);
    -
    420 
    -
    421  firstrow = 1;
    -
    422  firstelem = 1;
    -
    423 
    -
    424  if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, npix, fQ, &status))
    -
    425  fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
    -
    426 
    -
    427  if (fits_write_col(fptr, TDOUBLE, 2, firstrow, firstelem, npix, fU, &status))
    -
    428  fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
    -
    429 
    -
    430  if ( fits_close_file(fptr, &status) ) /* close the FITS file */
    -
    431  fprintf(stderr, "%s (%d): Could not close file.\n",
    -
    432  __FILE__, __LINE__);
    -
    433 
    -
    434 }
    -
    435 
    -
    436 
    -
    437 void s2let_fits_mw_read_spin_maps(double* fQ, double* fU, char* filename, int L)
    -
    438 {
    -
    439  long naxes, *naxis, npix, npercol, irow, Lread;
    -
    440  int status, hdutype, nfound, anynul;
    -
    441  float nulval;
    -
    442  char comment[FLEN_COMMENT];
    -
    443  fitsfile *fptr;
    -
    444  status = 0;
    -
    445 
    -
    446  if ( fits_open_file(&fptr, filename, READONLY, &status) )
    -
    447  printerror( status );
    -
    448 
    -
    449  if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) )
    -
    450  printerror( status );
    -
    451 
    -
    452  if (hdutype != BINARY_TBL)
    -
    453  fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__);
    -
    454 
    -
    455  if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) )
    -
    456  printerror( status );
    -
    457 
    -
    458  naxis = (long *)malloc(((size_t)naxes)*sizeof(long));
    -
    459  if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status)
    -
    460  || nfound != naxes )
    -
    461  printerror( status );
    -
    462 
    -
    463  if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) )
    -
    464  printerror(status);
    -
    465 
    -
    466  if( Lread != L )
    -
    467  printf("Attention : read L = %li but you specified L = %i\n",Lread,L);
    -
    468 
    -
    469  npix = L * (2*L-1);
    -
    470  printf("naxis[0] = %li\n",naxis[0]);
    -
    471  printf("naxis[1] = %li\n",naxis[1]);
    -
    472 
    -
    473  if ( (npix%naxis[1]) != 0 )
    -
    474  fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__);
    -
    475 
    -
    476  npercol = npix/naxis[1];
    -
    477  nulval = -1.6375e30;
    -
    478  for (irow = 0; irow < naxis[1]; irow++) {
    -
    479  if ( fits_read_col(fptr, TDOUBLE, 1, irow+1, 1, npercol, &nulval,
    -
    480  &(fQ[irow*npercol]), &anynul, &status) ) {
    -
    481  printerror(status);
    -
    482  }
    -
    483  }
    -
    484  for (irow = 0; irow < naxis[1]; irow++) {
    -
    485  if ( fits_read_col(fptr, TDOUBLE, 2, irow+1, 1, npercol, &nulval,
    -
    486  &(fU[irow*npercol]), &anynul, &status) ) {
    -
    487  printerror(status);
    -
    488  }
    -
    489  }
    -
    490  if ( fits_close_file(fptr, &status) )
    -
    491  printerror( status );
    -
    492 
    -
    493 }
    -
    494 void s2let_fits_mwss_read_spin_maps(double* fQ, double* fU, char* filename, int L)
    -
    495 {
    -
    496  long naxes, *naxis, npix, npercol, irow, Lread;
    -
    497  int status, hdutype, nfound, anynul;
    -
    498  float nulval;
    -
    499  char comment[FLEN_COMMENT];
    -
    500  fitsfile *fptr;
    -
    501  status = 0;
    -
    502 
    -
    503  if ( fits_open_file(&fptr, filename, READONLY, &status) )
    -
    504  printerror( status );
    -
    505 
    -
    506  if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) )
    -
    507  printerror( status );
    -
    508 
    -
    509  if (hdutype != BINARY_TBL)
    -
    510  fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__);
    -
    511 
    -
    512  if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) )
    -
    513  printerror( status );
    -
    514 
    -
    515  naxis = (long *)malloc(((size_t)naxes)*sizeof(long));
    -
    516  if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status)
    -
    517  || nfound != naxes )
    -
    518  printerror( status );
    -
    519 
    -
    520  if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) )
    -
    521  printerror(status);
    -
    522 
    -
    523  if( Lread != L )
    -
    524  printf("Attention : read L = %li but you specified L = %i\n",Lread,L);
    -
    525 
    -
    526  long mwss_read;
    -
    527  if ( fits_read_key_lng(fptr, "MWSS", &mwss_read, comment, &status) )
    -
    528  printerror(status);
    -
    529 
    -
    530  if( mwss_read != 1 )
    -
    531  printf("Attention : the file is not stored with MWSS sampling.\n");
    -
    532 
    -
    533  npix = (L+1) * 2*L;
    -
    534  printf("naxis[0] = %li\n",naxis[0]);
    -
    535  printf("naxis[1] = %li\n",naxis[1]);
    -
    536 
    -
    537  if ( (npix%naxis[1]) != 0 )
    -
    538  fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__);
    -
    539 
    -
    540  npercol = npix/naxis[1];
    -
    541  nulval = -1.6375e30;
    -
    542  for (irow = 0; irow < naxis[1]; irow++) {
    -
    543  if ( fits_read_col(fptr, TDOUBLE, 1, irow+1, 1, npercol, &nulval,
    -
    544  &(fQ[irow*npercol]), &anynul, &status) ) {
    -
    545  printerror(status);
    -
    546  }
    -
    547  }
    -
    548  for (irow = 0; irow < naxis[1]; irow++) {
    -
    549  if ( fits_read_col(fptr, TDOUBLE, 2, irow+1, 1, npercol, &nulval,
    -
    550  &(fU[irow*npercol]), &anynul, &status) ) {
    -
    551  printerror(status);
    -
    552  }
    -
    553  }
    -
    554  if ( fits_close_file(fptr, &status) )
    -
    555  printerror( status );
    -
    556 
    -
    557 }
    -
    558 
    -
    559 /*
    -
    560 void s2let_fits_mw_write_wav_maps(char* filename, complex double *f_wav,
    -
    561  complex double *f_scal, int nmaps,
    -
    562  int L, int N, int B, int J_min, int J, int multires) // TODO: ADD PARAMETERS STRUCT
    -
    563 {
    -
    564  fitsfile *fptr;
    -
    565  int i, status, hdutype;
    -
    566  long firstrow, firstelem;
    -
    567  int bitpix = SHORT_IMG;
    -
    568  long naxis = 0;
    -
    569  long naxes[] = {0,0};
    -
    570  int tfields = 1;
    -
    571  char extname[] = "BINTABLE";
    -
    572  char *ttype[] = { "SIGNAL" };
    -
    573  char *tform[] = { "1D" }; COMPLEX
    -
    574  char *tunit[] = { " " };
    -
    575 
    -
    576  long npix = L * (2*L-1);
    -
    577  status = 0;
    -
    578 
    -
    579  if (fits_create_file(&fptr, filename, &status))
    -
    580  fprintf(stderr, "%s (%d): Could not create new fits file.\n",
    -
    581  __FILE__, __LINE__);
    -
    582 
    -
    583  if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) )
    -
    584  fprintf(stderr, "%s (%d): Could not create new image file.\n",
    -
    585  __FILE__, __LINE__);
    -
    586 
    -
    587  if ( fits_movabs_hdu(fptr, 1, &hdutype, &status) )
    -
    588  fprintf(stderr, "%s (%d): Could not move to first HDU.\n",
    -
    589  __FILE__, __LINE__);
    -
    590 
    -
    591 
    -
    592  for(i=0; i<nmaps; ++i){
    -
    593 
    -
    594  int bl = L;
    -
    595 
    -
    596  if ( fits_create_tbl( fptr, BINARY_TBL, npix, tfields, ttype, tform,
    -
    597  tunit, extname, &status) )
    -
    598  fprintf(stderr, "%s (%d): Could not create new binary table.\n",
    -
    599  __FILE__, __LINE__);
    -
    600 
    -
    601  if (fits_write_key(fptr, TINT, "L", &bl,
    -
    602  "Resolution parameter", &status))
    -
    603  fprintf(stderr, "%s (%d): Could not write L keyword.\n",
    -
    604  __FILE__, __LINE__);
    -
    605 
    -
    606  firstrow = 1;
    -
    607  firstelem = 1;
    -
    608  npix = bl * (2*bl-1);
    -
    609  if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, npix, fwav[, &status))
    -
    610  fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
    -
    611 
    -
    612  }
    -
    613 
    -
    614  if ( fits_close_file(fptr, &status) )
    -
    615  fprintf(stderr, "%s (%d): Could not close file.\n",
    -
    616  __FILE__, __LINE__);
    -
    617 
    -
    618 }
    -
    619 
    -
    620 
    -
    621 void s2let_fits_mw_read_wav_maps(complex double *f_wav,
    -
    622  complex double *f_scal, char* filename, int nmaps,
    -
    623  int L, int N, int B, int J_min, int J, int multires) // TODO: ADD PARAMETERS STRUCT
    -
    624 {
    -
    625  long naxes, *naxis, npix, npercol, irow, Lread;
    -
    626  int status, hdutype, nfound, anynul;
    -
    627  float nulval;
    -
    628  char comment[FLEN_COMMENT];
    -
    629  fitsfile *fptr;
    -
    630  status = 0;
    -
    631 
    -
    632  if ( fits_open_file(&fptr, filename, READONLY, &status) )
    -
    633  printerror( status );
    -
    634 
    -
    635  if ( fits_movabs_hdu(fptr, 2, &hdutype, &status) )
    -
    636  printerror( status );
    -
    637 
    -
    638  if (hdutype != BINARY_TBL)
    -
    639  fprintf(stderr, "%s (%d): Extension is not binary!\n", __FILE__, __LINE__);
    -
    640 
    -
    641  if ( fits_read_key_lng(fptr, "NAXIS", &naxes, comment, &status) )
    -
    642  printerror( status );
    -
    643 
    -
    644  naxis = (long *)malloc(((size_t)naxes)*sizeof(long));
    -
    645  if ( fits_read_keys_lng(fptr, "NAXIS", 1, naxes, naxis, &nfound, &status)
    -
    646  || nfound != naxes )
    -
    647  printerror( status );
    -
    648 
    -
    649  if ( fits_read_key_lng(fptr, "L", &Lread, comment, &status) )
    -
    650  printerror(status);
    -
    651 
    -
    652  if( Lread != L )
    -
    653  printf("Attention : read L = %li but you specified L = %i\n",Lread,L);
    -
    654 
    -
    655  npix = L * (2*L-1);
    -
    656  printf("naxis[0] = %i\n",naxis[0]);
    -
    657  printf("naxis[1] = %i\n",naxis[1]);
    -
    658 
    -
    659  if ( (npix%naxis[1]) != 0 )
    -
    660  fprintf(stderr, "%s (%d): Problem with npix.\n", __FILE__, __LINE__);
    -
    661 
    -
    662  npercol = npix/naxis[1];
    -
    663  nulval = -1.6375e30;
    -
    664  for (irow = 0; irow < naxis[1]; irow++) {
    -
    665  if ( fits_read_col(fptr, TDOUBLE, 1, irow+1, 1, npercol, &nulval,
    -
    666  &(fQ[irow*npercol]), &anynul, &status) ) {
    -
    667  printerror(status);
    -
    668  }
    -
    669  }
    -
    670  for (irow = 0; irow < naxis[1]; irow++) {
    -
    671  if ( fits_read_col(fptr, TDOUBLE, 2, irow+1, 1, npercol, &nulval,
    -
    672  &(fU[irow*npercol]), &anynul, &status) ) {
    -
    673  printerror(status);
    -
    674  }
    -
    675  }
    -
    676  if ( fits_close_file(fptr, &status) )
    -
    677  printerror( status );
    -
    678 
    -
    679 }*/
    -
    -
    s2let_fits_mw_write_spin_maps
    void s2let_fits_mw_write_spin_maps(char *filename, double *fQ, double *fU, int L)
    Definition: s2let_fits.c:322
    -
    s2let_fits_mw_read_spin_maps
    void s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *filename, int L)
    Definition: s2let_fits.c:437
    -
    s2let_fits_mwss_read_map
    void s2let_fits_mwss_read_map(double *f, char *filename, int L)
    Definition: s2let_fits.c:260
    - -
    s2let_fits_hpx_read_nside
    int s2let_fits_hpx_read_nside(char *filename)
    Definition: s2let_fits.c:59
    -
    s2let_fits_mwss_read_spin_maps
    void s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *filename, int L)
    Definition: s2let_fits.c:494
    -
    printerror
    void printerror(int status)
    Definition: s2let_fits.c:9
    -
    s2let_fits_mwss_write_map
    void s2let_fits_mwss_write_map(char *filename, double *f, int L)
    Definition: s2let_fits.c:149
    -
    s2let_fits_mw_read_bandlimit
    int s2let_fits_mw_read_bandlimit(char *filename)
    Definition: s2let_fits.c:18
    -
    s2let_fits_mw_write_map
    void s2let_fits_mw_write_map(char *filename, double *f, int L)
    Definition: s2let_fits.c:98
    -
    s2let_fits_mw_read_map
    void s2let_fits_mw_read_map(double *f, char *filename, int L)
    Definition: s2let_fits.c:207
    -
    s2let_fits_mwss_write_spin_maps
    void s2let_fits_mwss_write_spin_maps(char *filename, double *fQ, double *fU, int L)
    Definition: s2let_fits.c:376
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__fits_8h.html b/docs/c/s2let__fits_8h.html index 9662c294..3d257a1c 100644 --- a/docs/c/s2let__fits_8h.html +++ b/docs/c/s2let__fits_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_fits.h File Reference +s2let: include/s2let_fits.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,7 +74,48 @@
    s2let_fits.h File Reference
    - +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +

    Go to the source code of this file.

    @@ -108,19 +108,19 @@
    110 #endif
    111 #endif
    -
    s2let_fits_mw_write_spin_maps
    void s2let_fits_mw_write_spin_maps(char *file, double *fQ, double *fU, int L)
    Definition: s2let_fits.c:322
    -
    s2let_fits_mwss_write_map
    void s2let_fits_mwss_write_map(char *file, double *f, int L)
    Definition: s2let_fits.c:149
    -
    s2let_fits_mwss_read_map
    void s2let_fits_mwss_read_map(double *f, char *file, int L)
    Definition: s2let_fits.c:260
    -
    s2let_fits_mw_read_spin_maps
    void s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *file, int L)
    Definition: s2let_fits.c:437
    -
    s2let_fits_mwss_read_spin_maps
    void s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *file, int L)
    Definition: s2let_fits.c:494
    -
    s2let_fits_mwss_write_spin_maps
    void s2let_fits_mwss_write_spin_maps(char *file, double *fQ, double *fU, int L)
    Definition: s2let_fits.c:376
    -
    s2let_fits_mw_write_map
    void s2let_fits_mw_write_map(char *file, double *f, int L)
    Definition: s2let_fits.c:98
    -
    s2let_fits_hpx_read_nside
    int s2let_fits_hpx_read_nside(char *filename)
    Definition: s2let_fits.c:59
    -
    s2let_fits_mw_read_bandlimit
    int s2let_fits_mw_read_bandlimit(char *filename)
    Definition: s2let_fits.c:18
    -
    s2let_fits_mw_read_map
    void s2let_fits_mw_read_map(double *f, char *file, int L)
    Definition: s2let_fits.c:207
    +
    s2let_fits_mw_write_spin_maps
    void s2let_fits_mw_write_spin_maps(char *file, double *fQ, double *fU, int L)
    Definition: s2let_fits.c:302
    +
    s2let_fits_mwss_write_map
    void s2let_fits_mwss_write_map(char *file, double *f, int L)
    Definition: s2let_fits.c:130
    +
    s2let_fits_mwss_read_map
    void s2let_fits_mwss_read_map(double *f, char *file, int L)
    Definition: s2let_fits.c:236
    +
    s2let_fits_mw_read_spin_maps
    void s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *file, int L)
    Definition: s2let_fits.c:398
    +
    s2let_fits_mwss_read_spin_maps
    void s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *file, int L)
    Definition: s2let_fits.c:471
    +
    s2let_fits_mwss_write_spin_maps
    void s2let_fits_mwss_write_spin_maps(char *file, double *fQ, double *fU, int L)
    Definition: s2let_fits.c:348
    +
    s2let_fits_mw_write_map
    void s2let_fits_mw_write_map(char *file, double *f, int L)
    Definition: s2let_fits.c:87
    +
    s2let_fits_hpx_read_nside
    int s2let_fits_hpx_read_nside(char *filename)
    Definition: s2let_fits.c:52
    +
    s2let_fits_mw_read_bandlimit
    int s2let_fits_mw_read_bandlimit(char *filename)
    Definition: s2let_fits.c:17
    +
    s2let_fits_mw_read_map
    void s2let_fits_mw_read_map(double *f, char *file, int L)
    Definition: s2let_fits.c:177
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__helper_8c.html b/docs/c/s2let__helper_8c.html index 8030f2d7..723ee311 100644 --- a/docs/c/s2let__helper_8c.html +++ b/docs/c/s2let__helper_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_helper.c File Reference +s2let: src/main/c/s2let_helper.c File Reference @@ -22,10 +22,10 @@ @@ -74,11 +74,43 @@
    s2let_helper.c File Reference
    -
    #include "s2let.h"
    -#include <ssht/ssht.h>
    +
    #include <ssht/ssht.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_helper.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -

    @@ -130,8 +171,6 @@

    Definition at line 59 of file s2let_fits.c.

    - @@ -163,8 +202,6 @@

    Definition at line 18 of file s2let_fits.c.

    - @@ -214,8 +251,6 @@

    Definition at line 207 of file s2let_fits.c.

    - @@ -271,8 +306,6 @@

    Definition at line 437 of file s2let_fits.c.

    - @@ -322,8 +355,6 @@

    Definition at line 98 of file s2let_fits.c.

    - @@ -379,8 +410,6 @@

    Definition at line 322 of file s2let_fits.c.

    - @@ -430,8 +459,6 @@

    Definition at line 260 of file s2let_fits.c.

    - @@ -487,8 +514,6 @@

    Definition at line 494 of file s2let_fits.c.

    - @@ -538,8 +563,6 @@

    Definition at line 149 of file s2let_fits.c.

    - @@ -595,14 +618,12 @@

    Definition at line 376 of file s2let_fits.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__fits_8h__dep__incl.map b/docs/c/s2let__fits_8h__dep__incl.map new file mode 100644 index 00000000..d83d559f --- /dev/null +++ b/docs/c/s2let__fits_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__fits_8h__dep__incl.md5 b/docs/c/s2let__fits_8h__dep__incl.md5 new file mode 100644 index 00000000..cb2e83a8 --- /dev/null +++ b/docs/c/s2let__fits_8h__dep__incl.md5 @@ -0,0 +1 @@ +ffcb0c90c75016840d846495f994cffb \ No newline at end of file diff --git a/docs/c/s2let__fits_8h_source.html b/docs/c/s2let__fits_8h_source.html index 9e1b87d4..17e43ccb 100644 --- a/docs/c/s2let__fits_8h_source.html +++ b/docs/c/s2let__fits_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_fits.h Source File +s2let: include/s2let_fits.h Source File @@ -22,10 +22,10 @@

    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    @@ -119,8 +151,6 @@

    -

    Definition at line 66 of file s2let_helper.c.

    - @@ -139,8 +169,6 @@

    -

    Definition at line 25 of file s2let_helper.c.

    - @@ -159,8 +187,6 @@

    -

    Definition at line 31 of file s2let_helper.c.

    - @@ -179,8 +205,6 @@

    -

    Definition at line 42 of file s2let_helper.c.

    - @@ -199,8 +223,6 @@

    -

    Definition at line 4 of file s2let_helper.c.

    - @@ -219,8 +241,6 @@

    -

    Definition at line 20 of file s2let_helper.c.

    - @@ -239,8 +259,6 @@

    -

    Definition at line 74 of file s2let_helper.c.

    - @@ -259,8 +277,6 @@

    -

    Definition at line 12 of file s2let_helper.c.

    - @@ -279,8 +295,6 @@

    -

    Definition at line 88 of file s2let_helper.c.

    - @@ -309,14 +323,12 @@

    -

    Definition at line 110 of file s2let_helper.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__helper_8c__incl.map b/docs/c/s2let__helper_8c__incl.map new file mode 100644 index 00000000..6981bb94 --- /dev/null +++ b/docs/c/s2let__helper_8c__incl.map @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__helper_8c__incl.md5 b/docs/c/s2let__helper_8c__incl.md5 new file mode 100644 index 00000000..b678c934 --- /dev/null +++ b/docs/c/s2let__helper_8c__incl.md5 @@ -0,0 +1 @@ +35793edbe09857904d79626ded69d8ec \ No newline at end of file diff --git a/docs/c/s2let__helper_8c_source.html b/docs/c/s2let__helper_8c_source.html deleted file mode 100644 index cfff0772..00000000 --- a/docs/c/s2let__helper_8c_source.html +++ /dev/null @@ -1,224 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_helper.c Source File - - - - - - - - - -
    -
    -

    Functions

    int s2let_n_phi (const s2let_parameters_t *parameters)
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_helper.c
    -
    -
    -Go to the documentation of this file.
    1 #include "s2let.h"
    -
    2 #include <ssht/ssht.h>
    -
    3 
    -
    4 int s2let_n_phi(const s2let_parameters_t *parameters)
    -
    5 {
    -
    6  if (parameters->sampling_scheme == S2LET_SAMPLING_MW_SS)
    -
    7  return ssht_sampling_mw_ss_nphi(parameters->L);
    -
    8  else
    -
    9  return ssht_sampling_mw_nphi(parameters->L);
    -
    10 }
    -
    11 
    -
    12 int s2let_n_theta(const s2let_parameters_t *parameters)
    -
    13 {
    -
    14  if (parameters->sampling_scheme == S2LET_SAMPLING_MW_SS)
    -
    15  return ssht_sampling_mw_ss_ntheta(parameters->L);
    -
    16  else
    -
    17  return ssht_sampling_mw_ntheta(parameters->L);
    -
    18 }
    -
    19 
    -
    20 int s2let_n_px(const s2let_parameters_t *parameters)
    -
    21 {
    -
    22  return s2let_n_phi(parameters) * s2let_n_theta(parameters);
    -
    23 }
    -
    24 
    -
    25 int s2let_n_lm(const s2let_parameters_t *parameters)
    -
    26 {
    -
    27  int L = parameters->L;
    -
    28  return L*L;
    -
    29 }
    -
    30 
    -
    31 int s2let_n_lm_scal(const s2let_parameters_t *parameters)
    -
    32 {
    -
    33  int L = parameters->L;
    -
    34  int J_min = parameters->J_min;
    -
    35  int bandlimit = (parameters->upsample)
    -
    36  ? L
    -
    37  : MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    38 
    -
    39  return bandlimit * bandlimit;
    -
    40 }
    -
    41 
    -
    42 int s2let_n_lmn_wav(const s2let_parameters_t *parameters)
    -
    43 {
    -
    44  so3_parameters_t so3_parameters = {};
    -
    45  fill_so3_parameters(&so3_parameters, parameters);
    -
    46 
    -
    47  int L = parameters->L;
    -
    48  int N = parameters->N;
    -
    49  int J_min = parameters->J_min;
    -
    50  int J = s2let_j_max(parameters);
    -
    51  int bandlimit = L;
    -
    52  int j, total = 0;
    -
    53  for (j = J_min; j <= J; ++j)
    -
    54  {
    -
    55  if (!parameters->upsample)
    -
    56  {
    -
    57  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    58  so3_parameters.L = bandlimit;
    -
    59  so3_parameters.N = MIN(N, bandlimit);
    -
    60  }
    -
    61  total += so3_sampling_flmn_size(&so3_parameters);
    -
    62  }
    -
    63  return total;
    -
    64 }
    -
    65 
    -
    66 int s2let_n_gamma(const s2let_parameters_t *parameters)
    -
    67 {
    -
    68  so3_parameters_t so3_parameters = {};
    -
    69  fill_so3_parameters(&so3_parameters, parameters);
    -
    70 
    -
    71  return so3_sampling_ngamma(&so3_parameters);
    -
    72 }
    -
    73 
    -
    74 int s2let_n_scal(const s2let_parameters_t *parameters)
    -
    75 {
    -
    76  int J_min = parameters->J_min;
    -
    77  int L = parameters->L;
    -
    78  int bandlimit = (parameters->upsample)
    -
    79  ? parameters->L
    -
    80  : MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    81 
    -
    82  s2let_parameters_t bl_parameters = *parameters;
    -
    83  bl_parameters.L = bandlimit;
    -
    84 
    -
    85  return s2let_n_phi(&bl_parameters) * s2let_n_theta(&bl_parameters);
    -
    86 }
    -
    87 
    -
    88 int s2let_n_wav(const s2let_parameters_t *parameters)
    -
    89 {
    -
    90  so3_parameters_t so3_parameters = {};
    -
    91  fill_so3_parameters(&so3_parameters, parameters);
    -
    92 
    -
    93  int L = parameters->L;
    -
    94  int J_min = parameters->J_min;
    -
    95  int J = s2let_j_max(parameters);
    -
    96  int bandlimit = L;
    -
    97  int j, total = 0;
    -
    98  for (j = J_min; j <= J; ++j)
    -
    99  {
    -
    100  if (!parameters->upsample)
    -
    101  {
    -
    102  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    103  so3_parameters.L = bandlimit;
    -
    104  }
    -
    105  total += so3_sampling_f_size(&so3_parameters);
    -
    106  }
    -
    107  return total;
    -
    108 }
    -
    109 
    -
    110 int s2let_n_wav_j(int j, const s2let_parameters_t *parameters)
    -
    111 {
    -
    112  so3_parameters_t so3_parameters = {};
    -
    113  fill_so3_parameters(&so3_parameters, parameters);
    -
    114 
    -
    115  if (!parameters->upsample)
    -
    116  {
    -
    117  int L = parameters->L;
    -
    118  so3_parameters.L = MIN(s2let_bandlimit(j, parameters), L);
    -
    119  }
    -
    120 
    -
    121  return so3_sampling_f_size(&so3_parameters);
    -
    122 }
    -
    -
    s2let_n_gamma
    int s2let_n_gamma(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:66
    -
    s2let_n_lm_scal
    int s2let_n_lm_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:31
    -
    s2let_n_theta
    int s2let_n_theta(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:12
    -
    s2let_n_wav
    int s2let_n_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:88
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_n_wav_j
    int s2let_n_wav_j(int j, const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:110
    -
    s2let_n_px
    int s2let_n_px(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:20
    -
    s2let_n_phi
    int s2let_n_phi(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:4
    -
    s2let_n_lm
    int s2let_n_lm(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:25
    -
    S2LET_SAMPLING_MW_SS
    @ S2LET_SAMPLING_MW_SS
    Definition: s2let_types.h:32
    -
    s2let_n_scal
    int s2let_n_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:74
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_n_lmn_wav
    int s2let_n_lmn_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:42
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__helper_8h.html b/docs/c/s2let__helper_8h.html index 7830d846..12b5b38d 100644 --- a/docs/c/s2let__helper_8h.html +++ b/docs/c/s2let__helper_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_helper.h File Reference +s2let: include/s2let_helper.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_helper.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -118,8 +168,6 @@

    -

    Definition at line 66 of file s2let_helper.c.

    - @@ -138,8 +186,6 @@

    -

    Definition at line 25 of file s2let_helper.c.

    - @@ -158,8 +204,6 @@

    -

    Definition at line 31 of file s2let_helper.c.

    - @@ -178,8 +222,6 @@

    -

    Definition at line 42 of file s2let_helper.c.

    - @@ -198,8 +240,6 @@

    -

    Definition at line 4 of file s2let_helper.c.

    - @@ -218,8 +258,6 @@

    -

    Definition at line 20 of file s2let_helper.c.

    - @@ -238,8 +276,6 @@

    -

    Definition at line 74 of file s2let_helper.c.

    - @@ -258,8 +294,6 @@

    -

    Definition at line 12 of file s2let_helper.c.

    - @@ -278,8 +312,6 @@

    -

    Definition at line 88 of file s2let_helper.c.

    - @@ -308,14 +340,12 @@

    -

    Definition at line 110 of file s2let_helper.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__helper_8h__dep__incl.map b/docs/c/s2let__helper_8h__dep__incl.map new file mode 100644 index 00000000..aeb8a797 --- /dev/null +++ b/docs/c/s2let__helper_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__helper_8h__dep__incl.md5 b/docs/c/s2let__helper_8h__dep__incl.md5 new file mode 100644 index 00000000..afb7ada0 --- /dev/null +++ b/docs/c/s2let__helper_8h__dep__incl.md5 @@ -0,0 +1 @@ +2b3cf0a74b948914f7211a431026938c \ No newline at end of file diff --git a/docs/c/s2let__helper_8h__incl.map b/docs/c/s2let__helper_8h__incl.map new file mode 100644 index 00000000..ef51d8b3 --- /dev/null +++ b/docs/c/s2let__helper_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__helper_8h__incl.md5 b/docs/c/s2let__helper_8h__incl.md5 new file mode 100644 index 00000000..70fce594 --- /dev/null +++ b/docs/c/s2let__helper_8h__incl.md5 @@ -0,0 +1 @@ +cc34a0150c99f7c4d6d61e857f99ef21 \ No newline at end of file diff --git a/docs/c/s2let__helper_8h_source.html b/docs/c/s2let__helper_8h_source.html index 4f1ac7d0..c6f57edb 100644 --- a/docs/c/s2let__helper_8h_source.html +++ b/docs/c/s2let__helper_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_helper.h Source File +s2let: include/s2let_helper.h Source File @@ -22,10 +22,10 @@

    @@ -100,20 +100,20 @@
    26 #endif
    27 #endif
    -
    s2let_n_wav
    int s2let_n_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:88
    -
    s2let_n_lmn_wav
    int s2let_n_lmn_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:42
    -
    s2let_n_scal
    int s2let_n_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:74
    -
    s2let_n_phi
    int s2let_n_phi(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:4
    -
    s2let_n_gamma
    int s2let_n_gamma(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:66
    -
    s2let_n_lm_scal
    int s2let_n_lm_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:31
    -
    s2let_n_theta
    int s2let_n_theta(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:12
    -
    s2let_n_wav_j
    int s2let_n_wav_j(int j, const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:110
    -
    s2let_n_px
    int s2let_n_px(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:20
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_n_lm
    int s2let_n_lm(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:25
    +
    s2let_n_wav
    int s2let_n_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:78
    +
    s2let_n_lmn_wav
    int s2let_n_lmn_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:37
    +
    s2let_n_scal
    int s2let_n_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:65
    +
    s2let_n_phi
    int s2let_n_phi(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:5
    +
    s2let_n_gamma
    int s2let_n_gamma(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:58
    +
    s2let_n_lm_scal
    int s2let_n_lm_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:28
    +
    s2let_n_theta
    int s2let_n_theta(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:12
    +
    s2let_n_wav_j
    int s2let_n_wav_j(int j, const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:97
    +
    s2let_n_px
    int s2let_n_px(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:19
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_n_lm
    int s2let_n_lm(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:23
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__hpx_8c.html b/docs/c/s2let__hpx_8c.html index bb80ca99..ad0c98c8 100644 --- a/docs/c/s2let__hpx_8c.html +++ b/docs/c/s2let__hpx_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_hpx.c File Reference +s2let: src/main/c/s2let_hpx.c File Reference @@ -22,10 +22,10 @@ @@ -74,13 +74,46 @@
    s2let_hpx.c File Reference
    -
    #include "s2let.h"
    +
    #include <complex.h>
    #include <ssht/ssht.h>
    #include <stdlib.h>
    -#include <complex.h>
    -
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_hpx.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    @@ -257,8 +290,6 @@

    Definition at line 55 of file s2let_hpx.c.

    - @@ -299,8 +330,6 @@

    -

    Definition at line 20 of file s2let_hpx.c.

    - @@ -359,8 +388,6 @@

    -

    Definition at line 30 of file s2let_hpx.c.

    - @@ -401,8 +428,6 @@

    -

    Definition at line 25 of file s2let_hpx.c.

    - @@ -461,8 +486,6 @@

    -

    Definition at line 35 of file s2let_hpx.c.

    - @@ -512,8 +535,6 @@

    Definition at line 45 of file s2let_hpx.c.

    - @@ -554,8 +575,6 @@

    -

    Definition at line 40 of file s2let_hpx.c.

    - @@ -605,8 +624,6 @@

    Definition at line 50 of file s2let_hpx.c.

    - @@ -629,7 +646,7 @@

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__hpx_8c__incl.map b/docs/c/s2let__hpx_8c__incl.map new file mode 100644 index 00000000..a34915c6 --- /dev/null +++ b/docs/c/s2let__hpx_8c__incl.map @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__hpx_8c__incl.md5 b/docs/c/s2let__hpx_8c__incl.md5 new file mode 100644 index 00000000..c08aca0f --- /dev/null +++ b/docs/c/s2let__hpx_8c__incl.md5 @@ -0,0 +1 @@ +426c0cb8d43a23048a4a83885f5601f6 \ No newline at end of file diff --git a/docs/c/s2let__hpx_8c_source.html b/docs/c/s2let__hpx_8c_source.html deleted file mode 100644 index c271816b..00000000 --- a/docs/c/s2let__hpx_8c_source.html +++ /dev/null @@ -1,155 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_hpx.c Source File - - - - - - - - - -
    -
    -

    Functions

    void healpix_inverse_real_ ()
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_hpx.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <ssht/ssht.h>
    -
    7 #include <stdlib.h>
    -
    8 #include <complex.h>
    -
    9 
    -
    10 // Fortran interfaces to Healpix F90 library ; see s2let_hpx.f90
    -
    11 extern void healpix_inverse_real_();
    -
    12 extern void healpix_forward_real_();
    -
    13 extern void healpix_inverse_spin_real_();
    -
    14 extern void healpix_forward_spin_real_();
    -
    15 extern void write_healpix_map_();
    -
    16 extern void read_healpix_map_();
    -
    17 extern void read_healpix_maps_();
    -
    18 extern void healpix_forward_real_();
    -
    19 
    -
    20 void s2let_hpx_alm2map_real(double* f, const complex double* flm, int nside, int L)
    -
    21 {
    -
    22  healpix_inverse_real_(f, flm, &nside, &L);
    -
    23 }
    -
    24 
    -
    25 void s2let_hpx_map2alm_real(complex double* flm, const double* f, int nside, int L)
    -
    26 {
    -
    27  healpix_forward_real_(flm, f, &nside, &L);
    -
    28 }
    -
    29 
    -
    30 void s2let_hpx_alm2map_spin_real(double* fQ, double* fU, const complex double* flmE, const complex double* flmB, int nside, int L, int spin)
    -
    31 {
    -
    32  healpix_inverse_spin_real_(fQ, fU, flmE, flmB, &nside, &L, &spin);
    -
    33 }
    -
    34 
    -
    35 void s2let_hpx_map2alm_spin_real(complex double* flmE, complex double* flmB, const double* fQ, const double* fU, int nside, int L, int spin)
    -
    36 {
    -
    37  healpix_forward_spin_real_(flmE, flmB, fQ, fU, &nside, &L, &spin);
    -
    38 }
    -
    39 
    -
    40 void s2let_hpx_read_maps(double* f, char* file, int nside, int nmaps)
    -
    41 {
    -
    42  read_healpix_maps_(f, file, &nside, &nmaps);
    -
    43 }
    -
    44 
    -
    45 void s2let_hpx_read_map(double* f, char* file, int nside)
    -
    46 {
    -
    47  read_healpix_map_(f, file, &nside);
    -
    48 }
    -
    49 
    -
    50 void s2let_hpx_write_map(char* file, const double* f, int nside)
    -
    51 {
    -
    52  write_healpix_map_(file, f, &nside);
    -
    53 }
    -
    54 
    -
    55 void s2let_hpx_allocate_real(double **f, int nside)
    -
    56 {
    -
    57  *f = calloc(12*nside*nside, sizeof **f);
    -
    58 }
    -
    -
    s2let_hpx_map2alm_real
    void s2let_hpx_map2alm_real(complex double *flm, const double *f, int nside, int L)
    Definition: s2let_hpx.c:25
    -
    write_healpix_map_
    void write_healpix_map_()
    -
    s2let_hpx_write_map
    void s2let_hpx_write_map(char *file, const double *f, int nside)
    Definition: s2let_hpx.c:50
    - -
    healpix_forward_real_
    void healpix_forward_real_()
    -
    s2let_hpx_alm2map_spin_real
    void s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const complex double *flmE, const complex double *flmB, int nside, int L, int spin)
    Definition: s2let_hpx.c:30
    -
    healpix_forward_spin_real_
    void healpix_forward_spin_real_()
    -
    s2let_hpx_allocate_real
    void s2let_hpx_allocate_real(double **f, int nside)
    Definition: s2let_hpx.c:55
    -
    s2let_hpx_read_maps
    void s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps)
    Definition: s2let_hpx.c:40
    -
    healpix_inverse_spin_real_
    void healpix_inverse_spin_real_()
    -
    s2let_hpx_read_map
    void s2let_hpx_read_map(double *f, char *file, int nside)
    Definition: s2let_hpx.c:45
    -
    s2let_hpx_alm2map_real
    void s2let_hpx_alm2map_real(double *f, const complex double *flm, int nside, int L)
    Definition: s2let_hpx.c:20
    -
    healpix_inverse_real_
    void healpix_inverse_real_()
    -
    s2let_hpx_map2alm_spin_real
    void s2let_hpx_map2alm_spin_real(complex double *flmE, complex double *flmB, const double *fQ, const double *fU, int nside, int L, int spin)
    Definition: s2let_hpx.c:35
    -
    read_healpix_maps_
    void read_healpix_maps_()
    -
    read_healpix_map_
    void read_healpix_map_()
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__hpx_8h.html b/docs/c/s2let__hpx_8h.html index 32d77bdf..b01d647b 100644 --- a/docs/c/s2let__hpx_8h.html +++ b/docs/c/s2let__hpx_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_hpx.h File Reference +s2let: include/s2let_hpx.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -76,6 +76,57 @@
    #include <complex.h>
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_hpx.h:
    +
    +
    + + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -139,8 +190,6 @@

    Definition at line 55 of file s2let_hpx.c.

    - @@ -450,8 +499,6 @@

    Definition at line 45 of file s2let_hpx.c.

    - @@ -492,8 +539,6 @@

    -

    Definition at line 40 of file s2let_hpx.c.

    - @@ -543,14 +588,12 @@

    Definition at line 50 of file s2let_hpx.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__hpx_8h__dep__incl.map b/docs/c/s2let__hpx_8h__dep__incl.map new file mode 100644 index 00000000..8ba87037 --- /dev/null +++ b/docs/c/s2let__hpx_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__hpx_8h__dep__incl.md5 b/docs/c/s2let__hpx_8h__dep__incl.md5 new file mode 100644 index 00000000..ab14d05b --- /dev/null +++ b/docs/c/s2let__hpx_8h__dep__incl.md5 @@ -0,0 +1 @@ +f7e9889fb45902b841fc5f59deb693bb \ No newline at end of file diff --git a/docs/c/s2let__hpx_8h__incl.map b/docs/c/s2let__hpx_8h__incl.map new file mode 100644 index 00000000..42be017d --- /dev/null +++ b/docs/c/s2let__hpx_8h__incl.map @@ -0,0 +1,5 @@ + + + + + diff --git a/docs/c/s2let__hpx_8h__incl.md5 b/docs/c/s2let__hpx_8h__incl.md5 new file mode 100644 index 00000000..7a9a8be9 --- /dev/null +++ b/docs/c/s2let__hpx_8h__incl.md5 @@ -0,0 +1 @@ +c041c75cbf051318e6d5fcceebd85759 \ No newline at end of file diff --git a/docs/c/s2let__hpx_8h_source.html b/docs/c/s2let__hpx_8h_source.html index 060dd240..02e0d6bf 100644 --- a/docs/c/s2let__hpx_8h_source.html +++ b/docs/c/s2let__hpx_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_hpx.h Source File +s2let: include/s2let_hpx.h Source File @@ -22,10 +22,10 @@

    @@ -114,15 +114,15 @@
    s2let_hpx_map2alm_real
    void s2let_hpx_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int nside, int L)
    s2let_hpx_map2alm_spin_real
    void s2let_hpx_map2alm_spin_real(S2LET_COMPLEX(double) *flmE, S2LET_COMPLEX(double) *flmB, const double *fQ, const double *fU, int nside, int L, int spin)
    s2let_hpx_alm2map_spin_real
    void s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const S2LET_COMPLEX(double) *flmE, const S2LET_COMPLEX(double) *flmB, int nside, int L, int spin)
    -
    s2let_hpx_read_map
    void s2let_hpx_read_map(double *f, char *file, int nside)
    Definition: s2let_hpx.c:45
    -
    s2let_hpx_allocate_real
    void s2let_hpx_allocate_real(double **f, int nside)
    Definition: s2let_hpx.c:55
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    -
    s2let_hpx_read_maps
    void s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps)
    Definition: s2let_hpx.c:40
    -
    s2let_hpx_write_map
    void s2let_hpx_write_map(char *file, const double *f, int nside)
    Definition: s2let_hpx.c:50
    +
    s2let_hpx_read_map
    void s2let_hpx_read_map(double *f, char *file, int nside)
    Definition: s2let_hpx.c:55
    +
    s2let_hpx_allocate_real
    void s2let_hpx_allocate_real(double **f, int nside)
    Definition: s2let_hpx.c:63
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    s2let_hpx_read_maps
    void s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps)
    Definition: s2let_hpx.c:51
    +
    s2let_hpx_write_map
    void s2let_hpx_write_map(char *file, const double *f, int nside)
    Definition: s2let_hpx.c:59
    s2let_hpx_alm2map_real
    void s2let_hpx_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int nside, int L)
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__hpx__demo_8c.html b/docs/c/s2let__hpx__demo_8c.html index 8f5a387c..70d7a606 100644 --- a/docs/c/s2let__hpx__demo_8c.html +++ b/docs/c/s2let__hpx__demo_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_hpx_demo.c File Reference +s2let: src/main/c/s2let_hpx_demo.c File Reference @@ -22,10 +22,10 @@ @@ -74,18 +74,54 @@
    s2let_hpx_demo.c File Reference
    -
    #include "s2let.h"
    -#include <ssht/ssht.h>
    -#include <assert.h>
    +
    #include <assert.h>
    #include <complex.h>
    +#include <math.h>
    +#include <ssht/ssht.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    -#include <math.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_hpx_demo.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    @@ -119,14 +155,12 @@

    PROGRAM : s2let_hpx_demo COMMAND : bin/s2let_hpx_demo ARGUMENTS : none

    -

    Definition at line 20 of file s2let_hpx_demo.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__hpx__demo_8c__incl.map b/docs/c/s2let__hpx__demo_8c__incl.map new file mode 100644 index 00000000..bace4aa2 --- /dev/null +++ b/docs/c/s2let__hpx__demo_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__hpx__demo_8c__incl.md5 b/docs/c/s2let__hpx__demo_8c__incl.md5 new file mode 100644 index 00000000..44be7849 --- /dev/null +++ b/docs/c/s2let__hpx__demo_8c__incl.md5 @@ -0,0 +1 @@ +99038d3bbcea717963450d07ef60f4c7 \ No newline at end of file diff --git a/docs/c/s2let__hpx__demo_8c_source.html b/docs/c/s2let__hpx__demo_8c_source.html deleted file mode 100644 index eaa86251..00000000 --- a/docs/c/s2let__hpx__demo_8c_source.html +++ /dev/null @@ -1,169 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_hpx_demo.c Source File - - - - - - - - - -
    -
    -

    Functions

    int main (int argc, char *argv[])
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_hpx_demo.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <ssht/ssht.h>
    -
    7 #include <assert.h>
    -
    8 #include <complex.h>
    -
    9 #include <stdio.h>
    -
    10 #include <stdlib.h>
    -
    11 #include <string.h>
    -
    12 #include <math.h>
    -
    13 #include <time.h>
    -
    14 
    -
    20 int main(int argc, char *argv[])
    -
    21 {
    -
    22  printf("--------------------------------------------------\n");
    -
    23  printf(" S2LET : Healpix wavelet transform \n");
    -
    24  printf("--------------------------------------------------\n");
    -
    25 
    -
    26  const int L = 256; // Harmonic band-limit
    -
    27  const double B = 4; // Wavelet parameters
    -
    28  const int J_min = 2; // First wavelet scale to use
    -
    29  s2let_parameters_t parameters = {};
    -
    30  parameters.B = B;
    -
    31  parameters.L = L;
    -
    32  parameters.J_min = J_min;
    -
    33 
    -
    34  // The input file is a random CMB simulation (healpix map with nside=128)
    -
    35  char file[100] = "data/somecmbsimu_hpx_128.fits";
    -
    36  const int nside = s2let_fits_hpx_read_nside(file);
    -
    37 
    -
    38  // Read Healpix map from file
    -
    39  double *f = (double*)calloc(12*nside*nside, sizeof(double));
    -
    40  s2let_hpx_read_map(f, file, nside);
    -
    41 
    -
    42  // Allocate space for wavelet maps (corresponding to the triplet B/L/J_min)
    -
    43  double *f_wav, *f_scal;
    -
    44  s2let_transform_axisym_allocate_hpx_f_wav_real(&f_wav, &f_scal, nside, &parameters);
    -
    45 
    -
    46  // Perform wavelet analysis from scratch with all signals given as Healpix maps
    -
    47  clock_t time_start = clock();
    -
    48  s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, nside, &parameters);
    -
    49  clock_t time_end = clock();
    -
    50  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    51  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    52 
    -
    53  // Output the wavelets to FITS files
    -
    54  char outfile[100];
    -
    55  char params[100];
    -
    56  sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min);
    -
    57  int j, J = s2let_j_max(&parameters); // Explicitly compute the maximum wavelet scale
    -
    58  int offset = 0; // Start with the first wavelet
    -
    59  for(j = J_min; j <= J; j++){
    -
    60  sprintf(outfile, "%s%s%s%s%d%s", "data/somecmbsimu_hpx_128", "_wav_", params, "_", j, ".fits");
    -
    61  printf(" Outfile_wav[j=%i] = %s\n",j,outfile);
    -
    62  remove(outfile); // In case the file exists
    -
    63  s2let_hpx_write_map(outfile, f_wav + offset, nside); // Now write the map to fits file
    -
    64  offset += 12 * nside * nside; // Go to the next wavelet
    -
    65  }
    -
    66  // Finally write the scaling function
    -
    67  sprintf(outfile, "%s%s%s%s", "data/somecmbsimu_hpx_128", "_scal_", params, ".fits");
    -
    68  printf(" Outfile_scal = %s\n",outfile);
    -
    69  remove(outfile); // In case the file exists
    -
    70  s2let_hpx_write_map(outfile, f_scal, nside); // Now write the map to fits file
    -
    71 
    -
    72  free(f_wav);
    -
    73  free(f_scal);
    -
    74  free(f);
    -
    75 
    -
    76  printf("--------------------------------------------------\n");
    -
    77 
    -
    78  return 0;
    -
    79 }
    -
    80 
    -
    81 
    -
    -
    s2let_transform_axisym_allocate_hpx_f_wav_real
    void s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:9
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_hpx_demo.c:20
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_hpx_write_map
    void s2let_hpx_write_map(char *file, const double *f, int nside)
    Definition: s2let_hpx.c:50
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_fits_hpx_read_nside
    int s2let_fits_hpx_read_nside(char *filename)
    Definition: s2let_fits.c:59
    -
    s2let_transform_axisym_wav_analysis_hpx_real
    void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:18
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_hpx_read_map
    void s2let_hpx_read_map(double *f, char *file, int nside)
    Definition: s2let_hpx.c:45
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__hpx__test_8c.html b/docs/c/s2let__hpx__test_8c.html index 0df58d40..d8a8154f 100644 --- a/docs/c/s2let__hpx__test_8c.html +++ b/docs/c/s2let__hpx__test_8c.html @@ -5,7 +5,7 @@ -S2LET: src/test/c/s2let_hpx_test.c File Reference +s2let: src/test/c/s2let_hpx_test.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -83,23 +83,60 @@ #include <math.h>
    #include <time.h>
    #include <fftw3.h>
    -#include <ssht.h>
    +#include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_hpx_test.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    - + - + - + - + - + - + @@ -131,8 +168,6 @@

    -

    Definition at line 368 of file s2let_hpx_test.c.

    - @@ -182,8 +217,6 @@

    Definition at line 208 of file s2let_hpx_test.c.

    - @@ -224,8 +257,6 @@

    -

    Definition at line 16 of file s2let_hpx_test.c.

    - @@ -268,8 +299,6 @@

    Definition at line 311 of file s2let_hpx_test.c.

    - @@ -312,8 +341,6 @@

    Definition at line 257 of file s2let_hpx_test.c.

    - @@ -375,8 +402,6 @@

    Definition at line 94 of file s2let_hpx_test.c.

    - @@ -450,14 +475,12 @@

    Definition at line 143 of file s2let_hpx_test.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__hpx__test_8c__incl.map b/docs/c/s2let__hpx__test_8c__incl.map new file mode 100644 index 00000000..63f31266 --- /dev/null +++ b/docs/c/s2let__hpx__test_8c__incl.map @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__hpx__test_8c__incl.md5 b/docs/c/s2let__hpx__test_8c__incl.md5 new file mode 100644 index 00000000..54004ff2 --- /dev/null +++ b/docs/c/s2let__hpx__test_8c__incl.md5 @@ -0,0 +1 @@ +6b912fa8295759e9f44b4ae3098386d3 \ No newline at end of file diff --git a/docs/c/s2let__hpx__test_8c_source.html b/docs/c/s2let__hpx__test_8c_source.html deleted file mode 100644 index 91e2dd53..00000000 --- a/docs/c/s2let__hpx__test_8c_source.html +++ /dev/null @@ -1,579 +0,0 @@ - - - - - - - -S2LET: src/test/c/s2let_hpx_test.c Source File - - - - - - - - - -
    -
    -

    Functions

    void s2let_hpx_spinalm_test (int nside, int spin, int L, int seed)
    void s2let_hpx_spinalm_test (int nside, int spin, int L, int seed)
     
    void s2let_transform_axisym_hpx_test (double *accuracy, double *timing, int nside, int L, int seed)
    void s2let_transform_axisym_hpx_test (double *accuracy, double *timing, int nside, int L, int seed)
     
    void s2let_transform_axisym_hpx_wav_test (double *accuracy, double *timing, int nside, int B, int L, int J_min, int seed)
    void s2let_transform_axisym_hpx_wav_test (double *accuracy, double *timing, int nside, int B, int L, int J_min, int seed)
     
    void s2let_hpx_io_test (int nside, int L, int seed)
    void s2let_hpx_io_test (int nside, int L, int seed)
     
    void s2let_mw_io_test (int L, int seed)
    void s2let_mw_io_test (int L, int seed)
     
    void s2let_mw_io_spin_test (int L, int seed)
    void s2let_mw_io_spin_test (int L, int seed)
     
    int main (int argc, char *argv[])
     
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_hpx_test.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <assert.h>
    -
    7 #include <complex.h>
    -
    8 #include <stdio.h>
    -
    9 #include <stdlib.h>
    -
    10 #include <string.h>
    -
    11 #include <math.h>
    -
    12 #include <time.h>
    -
    13 #include <fftw3.h>
    -
    14 #include <ssht.h>
    -
    15 
    -
    16 void s2let_hpx_spinalm_test(int nside, int spin, int L, int seed)
    -
    17 {
    -
    18  double *fQ, *fU, *fQ_rec, *fU_rec;
    -
    19  complex double *flmE, *flmE_rec, *flmU, *flmU_rec;
    -
    20  s2let_allocate_lm(&flmE, L);
    -
    21  s2let_allocate_lm(&flmU, L);
    -
    22  s2let_allocate_lm(&flmE_rec, L);
    -
    23  s2let_allocate_lm(&flmU_rec, L);
    -
    24  s2let_hpx_allocate_real(&fQ, nside);
    -
    25  s2let_hpx_allocate_real(&fU, nside);
    -
    26  s2let_hpx_allocate_real(&fQ_rec, nside);
    -
    27  s2let_hpx_allocate_real(&fU_rec, nside);
    -
    28 
    -
    29  s2let_lm_random_flm_real(flmE, L, seed);
    -
    30 
    -
    31  // Generate random harmonic coefficients
    -
    32  s2let_lm_random_flm_real(flmE, L, seed);
    -
    33  s2let_lm_random_flm_real(flmU, L, seed);
    -
    34  int el, em;
    -
    35  for(el = 0; el<abs(spin); el++){
    -
    36  for(em = -el; em<=el; em++){
    -
    37  flmE[el*el+el+em] = 0.0;
    -
    38  flmU[el*el+el+em] = 0.0;
    -
    39  }}
    -
    40 
    -
    41  // Construct the corresponding real signal on a healpix map
    -
    42  s2let_hpx_alm2map_spin_real(fQ, fU, flmE, flmU, nside, L, spin);
    -
    43 
    -
    44  s2let_hpx_map2alm_spin_real(flmE_rec, flmU_rec, fQ, fU, nside, L, spin);
    -
    45 
    -
    46  s2let_hpx_alm2map_spin_real(fQ_rec, fU_rec, flmE_rec, flmU_rec, nside, L, spin);
    -
    47 
    -
    48  s2let_hpx_map2alm_spin_real(flmE, flmU, fQ_rec, fU_rec, nside, L, spin);
    -
    49 
    -
    50  /*
    -
    51  int l, m;
    -
    52  for(l = 0; l<L; l++){
    -
    53  for(m = -l; m<=l; m++){
    -
    54  printf("flmE l=%i, m=%i, flmE=%f, flmErec=%f, diff=%f \n",l,m, creal(flmE[l*l+l+m]), creal(flmE_rec[l*l+l+m]), cabs(flmE_rec[l*l+l+m]-flmE[l*l+l+m]));
    -
    55  }}
    -
    56  for(l = 0; l<L; l++){
    -
    57  for(m = -l; m<=l; m++){
    -
    58  printf("flmU l=%i, m=%i, flmU=%f, flmUrec=%f, diff=%f \n",l,m, creal(flmU[l*l+l+m]), creal(flmU_rec[l*l+l+m]), cabs(flmU_rec[l*l+l+m]-flmU[l*l+l+m]));
    -
    59  }}
    -
    60  */
    -
    61 
    -
    62  // Compute the maximum absolute error on the harmonic coefficients
    -
    63  printf(" - Maximum abs error on Q alm : %6.5e\n",
    -
    64  maxerr_cplx(flmE, flmE_rec, L*L));
    -
    65  printf(" - Maximum abs error on U alm : %6.5e\n",
    -
    66  maxerr_cplx(flmU, flmU_rec, L*L));
    -
    67  /*
    -
    68  printf(" - Maximum abs error on Q map : %6.5e\n",
    -
    69  maxerr(fQ, fQ_rec, 12*nside*nside));
    -
    70  printf(" - Maximum abs error on U map : %6.5e\n",
    -
    71  maxerr(fU, fU_rec, 12*nside*nside));
    -
    72  */
    -
    73 
    -
    74  free(fQ);
    -
    75  free(fU);
    -
    76  free(fQ_rec);
    -
    77  free(fU_rec);
    -
    78  free(flmE);
    -
    79  free(flmU);
    -
    80  free(flmE_rec);
    -
    81  free(flmU_rec);
    -
    82 }
    -
    83 
    -
    84 
    -
    94 void s2let_transform_axisym_hpx_test(double *accuracy, double *timing, int nside, int L, int seed)
    -
    95 {
    -
    96  clock_t time_start, time_end;
    -
    97  double *f, *f_rec;
    -
    98  complex double *flm, *flm_rec;
    -
    99  s2let_allocate_lm(&flm, L);
    -
    100  s2let_allocate_lm(&flm_rec, L);
    -
    101  s2let_hpx_allocate_real(&f, nside);
    -
    102  s2let_hpx_allocate_real(&f_rec, nside);
    -
    103 
    -
    104  // Generate random harmonic coefficients
    -
    105  s2let_lm_random_flm_real(flm, L, seed);
    -
    106 
    -
    107  fflush(NULL);time_start = clock();
    -
    108  // Reconstruct the corresponding signal on the sphere on a healpix map
    -
    109  s2let_hpx_alm2map_real(f, flm, nside, L);
    -
    110  // Decompose it again to get the harmonic coefficients back
    -
    111  s2let_hpx_map2alm_real(flm_rec, f, nside, L);
    -
    112  time_end = clock();fflush(NULL);
    -
    113 
    -
    114  int l, m;
    -
    115  for(l = 0; l<L; l++){
    -
    116  for(m = 0; m<=l; m++){
    -
    117  //printf("l=%i, m=%i, val=%f \n",l,m,cabs(flm_rec[l*l+l+m]-flm[l*l+l+m]));
    -
    118  }}
    -
    119 
    -
    120 
    -
    121  *timing += (time_end - time_start) / 2 / (double)CLOCKS_PER_SEC ;
    -
    122  *accuracy = maxerr_cplx(flm, flm_rec, L*L);
    -
    123 
    -
    124  // Compute the maximum absolute error on the harmonic coefficients
    -
    125  //printf(" - Maximum abs error : %6.5e\n", accuracy);
    -
    126 
    -
    127  free(f);
    -
    128  free(f_rec);
    -
    129  free(flm);
    -
    130  free(flm_rec);
    -
    131 }
    -
    132 
    -
    133 
    -
    143 void s2let_transform_axisym_hpx_wav_test(double *accuracy, double *timing, int nside, int B, int L, int J_min, int seed)
    -
    144 {
    -
    145  s2let_parameters_t parameters = {};
    -
    146  parameters.B = B;
    -
    147  parameters.L = L;
    -
    148  parameters.J_min = J_min;
    -
    149 
    -
    150  clock_t time_start, time_end;
    -
    151 
    -
    152  double *f, *f_rec;
    -
    153  complex double *flm, *flm_rec;
    -
    154  s2let_allocate_lm(&flm, L);
    -
    155  s2let_allocate_lm(&flm_rec, L);
    -
    156  s2let_hpx_allocate_real(&f, nside);
    -
    157  s2let_hpx_allocate_real(&f_rec, nside);
    -
    158 
    -
    159  // Generate random harmonic coefficients
    -
    160  s2let_lm_random_flm_real(flm, L, seed);
    -
    161 
    -
    162  // Reconstruct the corresponding signal on the sphere on a healpix map
    -
    163  s2let_hpx_alm2map_real(f, flm, nside, L);
    -
    164 
    -
    165  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    166  double *f_wav, *f_scal;
    -
    167  s2let_transform_axisym_allocate_hpx_f_wav_real(&f_wav, &f_scal, nside, &parameters);
    -
    168 
    -
    169  // Perform wavelet analysis from scratch with all signals given on the sphere (Healpix sampling)
    -
    170  fflush(NULL);time_start = clock();
    -
    171  s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, nside, &parameters);
    -
    172  time_end = clock();fflush(NULL);
    -
    173  //printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    174  // (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    175  *timing = (time_end - time_start) / 2 / (double)CLOCKS_PER_SEC ;
    -
    176 
    -
    177  // Reconstruct the initial healpix map from the wavelet healpix maps
    -
    178  time_start = clock();
    -
    179  s2let_transform_axisym_wav_synthesis_hpx_real(f_rec, f_wav, f_scal, nside, &parameters);
    -
    180  time_end = clock();
    -
    181  //printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    182  // (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    183  *timing += (time_end - time_start) / 2 / (double)CLOCKS_PER_SEC ;
    -
    184 
    -
    185  // Get the harmonic coefficients back
    -
    186  s2let_hpx_map2alm_real(flm_rec, f_rec, nside, L);
    -
    187 
    -
    188  // Compute the maximum absolute error on the harmonic coefficients
    -
    189  // printf(" - Maximum abs error : %6.5e\n",
    -
    190  // maxerr_cplx(flm, flm_rec, L*L));
    -
    191 
    -
    192  *accuracy = maxerr_cplx(flm, flm_rec, L*L);
    -
    193 
    -
    194  free(f);
    -
    195  free(f_rec);
    -
    196  free(f_wav);
    -
    197  free(f_scal);
    -
    198 }
    -
    199 
    -
    208 void s2let_hpx_io_test(int nside, int L, int seed)
    -
    209 {
    -
    210  double *f, *f_rec;
    -
    211  complex double *flm, *flm_rec;
    -
    212  s2let_allocate_lm(&flm, L);
    -
    213  s2let_allocate_lm(&flm_rec, L);
    -
    214  s2let_hpx_allocate_real(&f, nside);
    -
    215  s2let_hpx_allocate_real(&f_rec, nside);
    -
    216 
    -
    217  // Generate random harmonic coefficients
    -
    218  s2let_lm_random_flm_real(flm, L, seed);
    -
    219 
    -
    220  // Construct the corresponding real signal on a healpix map
    -
    221  s2let_hpx_alm2map_real(f, flm, nside, L);
    -
    222 
    -
    223  char file[100] = "temp.fits";
    -
    224 
    -
    225  // Remove the file if it exists
    -
    226  remove(file);
    -
    227  // Write the signal to file
    -
    228  printf("Write the signal to file\n");
    -
    229  s2let_hpx_write_map(file, f, nside);
    -
    230 
    -
    231  // Read the signal from file
    -
    232  printf("Read the signal from file\n");
    -
    233  s2let_hpx_read_map(f_rec, file, nside);
    -
    234  // Clean
    -
    235  remove(file);
    -
    236 
    -
    237  // Get the harmonic coefficients back
    -
    238  s2let_hpx_map2alm_real(flm_rec, f, nside, L);
    -
    239 
    -
    240  // Compute the maximum absolute error on the harmonic coefficients
    -
    241  printf(" - Maximum abs error : %6.5e\n",
    -
    242  maxerr_cplx(flm, flm_rec, L*L));
    -
    243 
    -
    244  free(f);
    -
    245  free(f_rec);
    -
    246  free(flm);
    -
    247  free(flm_rec);
    -
    248 }
    -
    249 
    -
    257 void s2let_mw_io_test(int L, int seed)
    -
    258 {
    -
    259  int verbosity = 0;
    -
    260  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    261 
    -
    262  double *f, *f_rec;
    -
    263  complex double *flm, *flm_rec;
    -
    264  s2let_allocate_lm(&flm, L);
    -
    265  s2let_allocate_lm(&flm_rec, L);
    -
    266  s2let_allocate_mw_real(&f, L);
    -
    267  s2let_allocate_mw_real(&f_rec, L);
    -
    268 
    -
    269  // Generate random harmonic coefficients
    -
    270  s2let_lm_random_flm_real(flm, L, seed);
    -
    271 
    -
    272  // Construct the corresponding real signal, on MW sampling
    -
    273  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    274 
    -
    275  char file[100] = "temp.fits";
    -
    276 
    -
    277  // Remove the file if it exists
    -
    278  remove(file);
    -
    279  // Write the signal to file
    -
    280  printf("Write the signal to file\n");
    -
    281  s2let_fits_mw_write_map(file, f, L);
    -
    282 
    -
    283  // Read the band-limit from file
    -
    284  int Lread = s2let_fits_mw_read_bandlimit(file);
    -
    285 
    -
    286  // Read the signal from file
    -
    287  printf("Read the signal from file\n");
    -
    288  s2let_fits_mw_read_map(f_rec, file, Lread);
    -
    289  // Clean
    -
    290  remove(file);
    -
    291 
    -
    292  // Get the harmonic coefficients back
    -
    293  ssht_core_mw_forward_sov_conv_sym_real(flm_rec, f_rec, L, dl_method, verbosity);
    -
    294 
    -
    295  // Compute the maximum absolute error on the harmonic coefficients
    -
    296  printf(" - Maximum abs error : %6.5e\n",
    -
    297  maxerr_cplx(flm, flm_rec, L*L));
    -
    298 
    -
    299  free(f);
    -
    300  free(f_rec);
    -
    301  free(flm);
    -
    302  free(flm_rec);
    -
    303 }
    -
    311 void s2let_mw_io_spin_test(int L, int seed)
    -
    312 {
    -
    313  int verbosity = 0;
    -
    314  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    315 
    -
    316  complex double *flmQ, *flmU, *flm_recQ, *flm_recU;
    -
    317  double *fQ, *fU, *fQ_rec, *fU_rec;
    -
    318  s2let_allocate_lm(&flmQ, L);
    -
    319  s2let_allocate_lm(&flmU, L);
    -
    320  s2let_allocate_lm(&flm_recQ, L);
    -
    321  s2let_allocate_lm(&flm_recU, L);
    -
    322  s2let_allocate_mw_real(&fQ, L);
    -
    323  s2let_allocate_mw_real(&fU, L);
    -
    324  s2let_allocate_mw_real(&fQ_rec, L);
    -
    325  s2let_allocate_mw_real(&fU_rec, L);
    -
    326  // Generate random harmonic coefficients
    -
    327  s2let_lm_random_flm_real(flmQ, L, seed);
    -
    328  s2let_lm_random_flm_real(flmU, L, seed);
    -
    329  // Construct the corresponding real signal, on MW sampling
    -
    330  ssht_core_mw_inverse_sov_sym_real(fQ, flmQ, L, dl_method, verbosity);
    -
    331  // Construct the corresponding real signal, on MW sampling
    -
    332  ssht_core_mw_inverse_sov_sym_real(fU, flmU, L, dl_method, verbosity);
    -
    333 
    -
    334  char file[100] = "temp.fits";
    -
    335 
    -
    336  // Remove the file if it exists
    -
    337  remove(file);
    -
    338  // Write the signal to file
    -
    339  s2let_fits_mw_write_spin_maps(file, fQ, fU, L);
    -
    340 
    -
    341  // Read the band-limit from file
    -
    342  int Lread = s2let_fits_mw_read_bandlimit(file);
    -
    343 
    -
    344  // Read the signal from file
    -
    345  s2let_fits_mw_read_spin_maps(fQ_rec, fU_rec, file, L);
    -
    346  // Clean
    -
    347  //remove(file);
    -
    348 
    -
    349  ssht_core_mw_forward_sov_conv_sym_real(flm_recQ, fQ_rec, L, dl_method, verbosity);
    -
    350  ssht_core_mw_forward_sov_conv_sym_real(flm_recU, fU_rec, L, dl_method, verbosity);
    -
    351 
    -
    352  // Compute the maximum absolute error on the harmonic coefficients
    -
    353  printf(" - Maximum abs error : %6.5e\n",
    -
    354  maxerr_cplx(flmQ, flm_recQ, L*L));
    -
    355  printf(" - Maximum abs error : %6.5e\n",
    -
    356  maxerr_cplx(flmU, flm_recU, L*L));
    -
    357 
    -
    358  free(flmQ);
    -
    359  free(flmU);
    -
    360  free(flm_recQ);
    -
    361  free(flm_recU);
    -
    362  free(fQ);
    -
    363  free(fU);
    -
    364  free(fQ_rec);
    -
    365  free(fU_rec);
    -
    366 }
    -
    367 
    -
    368 int main(int argc, char *argv[])
    -
    369 {
    -
    370 
    -
    371  int L = 64, spin = 2;
    -
    372  const int B = 2;
    -
    373  const int J_min = 0;
    -
    374  s2let_parameters_t parameters = {};
    -
    375  parameters.B = B;
    -
    376  parameters.L = L;
    -
    377  parameters.J_min = J_min;
    -
    378  int J = s2let_j_max(&parameters);
    -
    379  int nside = 32;
    -
    380  int repeat, NREPEAT = 10;
    -
    381  double timing, accuracy, timing_tot, accuracy_tot;
    -
    382  const int seed = (int)(10000.0*(double)clock()/(double)CLOCKS_PER_SEC);
    -
    383 
    -
    384  printf("==========================================================\n");
    -
    385  printf("Testing S2LET facilities with the HEALPIX sampling \n");
    -
    386  printf("==========================================================\n");
    -
    387  printf("PARAMETERS: ");
    -
    388  printf(" L = %i B = %i nside = %i seed = %i\n", L, B, nside, seed);
    -
    389  printf("----------------------------------------------------------\n");
    -
    390  printf("> Testing IO functions for MW sampling...\n");
    -
    391  s2let_mw_io_test(L, seed);
    -
    392  printf("----------------------------------------------------------\n");
    -
    393  printf("> Testing spin IO functions for MW sampling...\n");
    -
    394  s2let_mw_io_spin_test(L, seed);
    -
    395  printf("----------------------------------------------------------\n");
    -
    396  printf("> Testing spin SHT functions for HEALPIX sampling...\n");
    -
    397  s2let_hpx_spinalm_test(nside, spin, L, seed);
    -
    398  printf("----------------------------------------------------------\n");
    -
    399  printf("> Testing IO functions for HEALPIX sampling...\n");
    -
    400  s2let_hpx_io_test(nside, L, seed);
    -
    401  printf("==========================================================\n");
    -
    402 
    -
    403 
    -
    404  printf("> Extensive test of accuracy for various Nside and lmax..\n");
    -
    405  const int i_nmin = 4;
    -
    406  const int i_nmax = 7;
    -
    407  int n, l, i_lmin, i_lmax;
    -
    408 
    -
    409  FILE *file1, *file2;
    -
    410  file1 = fopen("s2let_hpx_full_new.txt", "w");
    -
    411  if (file1 == NULL) {
    -
    412  printf("I couldn't open s2let_hpx.txt for writing.\n");
    -
    413  exit(0);
    -
    414  }
    -
    415 
    -
    416 
    -
    417  for (n=i_nmin; n<=i_nmax; n++){
    -
    418  for (l=-1; l<=2; l++){
    -
    419  nside = pow(2, n);
    -
    420  L = pow(2,n+l);
    -
    421  if (l == 2) L = 3*nside;
    -
    422  accuracy_tot = 0.0;
    -
    423  timing_tot = 0.0;
    -
    424  for (repeat=0; repeat<NREPEAT; repeat++){
    -
    425  s2let_transform_axisym_hpx_test(&accuracy, &timing, nside, L, seed);
    -
    426  accuracy_tot += accuracy;
    -
    427  timing_tot += timing;
    -
    428  }
    -
    429  accuracy_tot /= NREPEAT;
    -
    430  timing_tot /= NREPEAT;
    -
    431  printf("1-HPX: Nside = %i ; Lmax = %i : Accuracy : %6.3e in %6.3e sec \n",nside, L, accuracy_tot,timing_tot);
    -
    432  //fprintf(file1, " %i %i %6.3e %6.3e \n", nside, L, accuracy_tot,timing_tot);
    -
    433 
    -
    434  }
    -
    435  }
    -
    436  //close(file1);
    -
    437 
    -
    438 /*
    -
    439 
    -
    440  printf("==========================================================\n");
    -
    441 
    -
    442  const int i_nmin = 5;
    -
    443  const int i_nmax = 10;
    -
    444  int n, l, i_lmin, i_lmax;
    -
    445 
    -
    446  FILE *file1, *file2;
    -
    447  file1 = fopen("s2let_hpx.txt", "w");
    -
    448  if (file1 == NULL) {
    -
    449  printf("I couldn't open s2let_hpx.txt for writing.\n");
    -
    450  exit(0);
    -
    451  }
    -
    452  file2 = fopen("s2let_hpx_wav.txt", "w");
    -
    453  if (file2 == NULL) {
    -
    454  printf("I couldn't open s2let_hpx_wav.txt for writing.\n");
    -
    455  exit(0);
    -
    456  }
    -
    457 
    -
    458  printf("> Testing real axisymmetric wavelets in pixel space...\n");
    -
    459 
    -
    460  printf("NbrScale = %i\n",J);
    -
    461  for (n=i_nmin; n<=i_nmax; n++){
    -
    462 
    -
    463  if (n > 9) NREPEAT = 4;
    -
    464  nside = pow(2, n);
    -
    465  i_lmin = n-2;
    -
    466  i_lmax = n+1;
    -
    467  for (l=i_lmin; l<=i_lmax; l++){
    -
    468  L = pow(2,l);
    -
    469 
    -
    470  accuracy_tot = 0.0;
    -
    471  timing_tot = 0.0;
    -
    472  for (repeat=0; repeat<NREPEAT; repeat++){
    -
    473  s2let_transform_axisym_hpx_test(&accuracy, &timing, nside, L, seed);
    -
    474  accuracy_tot += accuracy;
    -
    475  timing_tot += timing;
    -
    476  }
    -
    477  accuracy_tot /= NREPEAT;
    -
    478  timing_tot /= NREPEAT;
    -
    479  printf("1-HPX: Nside = %i ; Lmax = %i : Accuracy : %6.3e in %6.3e sec \n",nside, L, accuracy_tot,timing_tot);
    -
    480  fprintf(file1, " %i %i %6.3e %6.3e \n", nside, L, accuracy_tot,timing_tot);
    -
    481 
    -
    482  accuracy_tot = 0.0;
    -
    483  timing_tot = 0.0;
    -
    484  for (repeat=0; repeat<NREPEAT; repeat++){
    -
    485  s2let_transform_axisym_hpx_wav_test(&accuracy, &timing, nside, B, L, J_min, seed);
    -
    486  accuracy_tot += accuracy;
    -
    487  timing_tot += timing;
    -
    488  }
    -
    489  accuracy_tot /= NREPEAT;
    -
    490  timing_tot /= NREPEAT;
    -
    491  printf("2-WAV: Nside = %i ; Lmax = %i : Accuracy : %6.3e in %6.3e sec \n",nside, L, accuracy_tot,timing_tot);
    -
    492  fprintf(file2, " %i %i %6.3e %6.3e \n", nside, L, accuracy_tot,timing_tot);
    -
    493 
    -
    494  }
    -
    495  }
    -
    496 
    -
    497  close(file1);
    -
    498  close(file2);
    -
    499 
    -
    500  */
    -
    501 
    -
    502 
    -
    503  printf("==========================================================\n");
    -
    504  return 0;
    -
    505 }
    -
    -
    s2let_transform_axisym_allocate_hpx_f_wav_real
    void s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:9
    -
    s2let_hpx_map2alm_real
    void s2let_hpx_map2alm_real(complex double *flm, const double *f, int nside, int L)
    Definition: s2let_hpx.c:25
    -
    s2let_fits_mw_write_spin_maps
    void s2let_fits_mw_write_spin_maps(char *filename, double *fQ, double *fU, int L)
    Definition: s2let_fits.c:322
    -
    s2let_fits_mw_read_spin_maps
    void s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *filename, int L)
    Definition: s2let_fits.c:437
    -
    s2let_transform_axisym_hpx_test
    void s2let_transform_axisym_hpx_test(double *accuracy, double *timing, int nside, int L, int seed)
    Definition: s2let_hpx_test.c:94
    -
    s2let_hpx_io_test
    void s2let_hpx_io_test(int nside, int L, int seed)
    Definition: s2let_hpx_test.c:208
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_hpx_write_map
    void s2let_hpx_write_map(char *file, const double *f, int nside)
    Definition: s2let_hpx.c:50
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_hpx_spinalm_test
    void s2let_hpx_spinalm_test(int nside, int spin, int L, int seed)
    Definition: s2let_hpx_test.c:16
    -
    s2let_hpx_alm2map_spin_real
    void s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const complex double *flmE, const complex double *flmB, int nside, int L, int spin)
    Definition: s2let_hpx.c:30
    -
    s2let_lm_random_flm_real
    void s2let_lm_random_flm_real(complex double *flm, int L, int seed)
    Definition: s2let_lm.c:52
    -
    s2let_transform_axisym_hpx_wav_test
    void s2let_transform_axisym_hpx_wav_test(double *accuracy, double *timing, int nside, int B, int L, int J_min, int seed)
    Definition: s2let_hpx_test.c:143
    -
    maxerr_cplx
    double maxerr_cplx(complex double *a, complex double *b, int size)
    Definition: s2let_math.c:141
    -
    s2let_hpx_allocate_real
    void s2let_hpx_allocate_real(double **f, int nside)
    Definition: s2let_hpx.c:55
    -
    s2let_allocate_mw_real
    void s2let_allocate_mw_real(double **f, int L)
    Definition: s2let_alloc.c:28
    -
    NREPEAT
    #define NREPEAT
    Definition: s2let_test_csv.c:47
    -
    s2let_transform_axisym_wav_synthesis_hpx_real
    void s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:55
    -
    s2let_transform_axisym_wav_analysis_hpx_real
    void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:18
    -
    s2let_fits_mw_read_bandlimit
    int s2let_fits_mw_read_bandlimit(char *filename)
    Definition: s2let_fits.c:18
    -
    s2let_fits_mw_write_map
    void s2let_fits_mw_write_map(char *filename, double *f, int L)
    Definition: s2let_fits.c:98
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_fits_mw_read_map
    void s2let_fits_mw_read_map(double *f, char *filename, int L)
    Definition: s2let_fits.c:207
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_mw_io_test
    void s2let_mw_io_test(int L, int seed)
    Definition: s2let_hpx_test.c:257
    -
    s2let_mw_io_spin_test
    void s2let_mw_io_spin_test(int L, int seed)
    Definition: s2let_hpx_test.c:311
    -
    s2let_hpx_read_map
    void s2let_hpx_read_map(double *f, char *file, int nside)
    Definition: s2let_hpx.c:45
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_hpx_test.c:368
    -
    s2let_hpx_alm2map_real
    void s2let_hpx_alm2map_real(double *f, const complex double *flm, int nside, int L)
    Definition: s2let_hpx.c:20
    -
    s2let_hpx_map2alm_spin_real
    void s2let_hpx_map2alm_spin_real(complex double *flmE, complex double *flmB, const double *fQ, const double *fU, int nside, int L, int spin)
    Definition: s2let_hpx.c:35
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__idl__hpx_8c.html b/docs/c/s2let__idl__hpx_8c.html index 79e9eedd..8bed4700 100644 --- a/docs/c/s2let__idl__hpx_8c.html +++ b/docs/c/s2let__idl__hpx_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_idl_hpx.c File Reference +s2let: src/main/c/s2let_idl_hpx.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -77,9 +77,41 @@
    #include "s2let.h"
    +
    +Include dependency graph for s2let_idl_hpx.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -122,8 +154,6 @@

    -

    Definition at line 14 of file s2let_idl_hpx.c.

    - @@ -138,8 +168,6 @@

    -

    Definition at line 19 of file s2let_idl_hpx.c.

    -

    Typedef Documentation

    @@ -155,8 +183,6 @@

    -

    Definition at line 21 of file s2let_idl_hpx.c.

    - @@ -171,8 +197,6 @@

    -

    Definition at line 27 of file s2let_idl_hpx.c.

    - @@ -187,8 +211,6 @@

    -

    Definition at line 22 of file s2let_idl_hpx.c.

    - @@ -203,8 +225,6 @@

    -

    Definition at line 28 of file s2let_idl_hpx.c.

    -

    Function Documentation

    @@ -234,8 +254,6 @@

    -

    Definition at line 33 of file s2let_idl_hpx.c.

    - @@ -264,8 +282,6 @@

    -

    Definition at line 58 of file s2let_idl_hpx.c.

    - @@ -295,8 +311,6 @@

    IDL interface to s2let_hpx_alm2map_real

    -

    Definition at line 96 of file s2let_idl_hpx.c.

    - @@ -326,14 +340,12 @@

    IDL interface to s2let_hpx_map2alm_real

    -

    Definition at line 83 of file s2let_idl_hpx.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__idl__hpx_8c__incl.map b/docs/c/s2let__idl__hpx_8c__incl.map new file mode 100644 index 00000000..a20f5ae6 --- /dev/null +++ b/docs/c/s2let__idl__hpx_8c__incl.map @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__idl__hpx_8c__incl.md5 b/docs/c/s2let__idl__hpx_8c__incl.md5 new file mode 100644 index 00000000..8f4d2330 --- /dev/null +++ b/docs/c/s2let__idl__hpx_8c__incl.md5 @@ -0,0 +1 @@ +ef80a1ec67dab8c939f84e817b13811c \ No newline at end of file diff --git a/docs/c/s2let__idl__hpx_8c_source.html b/docs/c/s2let__idl__hpx_8c_source.html deleted file mode 100644 index 0609f0af..00000000 --- a/docs/c/s2let__idl__hpx_8c_source.html +++ /dev/null @@ -1,206 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_idl_hpx.c Source File - - - - - - - - - -
    -
    -

    Macros

    #define IDL_SIZEOF_C_LONG   4
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_idl_hpx.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 
    -
    7 /*
    -
    8  * IDL integer types. For historical reasons, we use UCHAR for TYP_BYTE
    -
    9  * instead of defining an IDL_BYTE type.
    -
    10  */
    -
    11 #if defined(ALPHA_OSF) || defined(SUN_64) || defined(LINUX_X86_64) || defined(HPUX_64) || defined(IRIX_64) || defined(AIX_64)
    -
    12 #define IDL_SIZEOF_C_LONG 8
    -
    13 #else
    -
    14 #define IDL_SIZEOF_C_LONG 4
    -
    15 #endif
    -
    16 #if (IDL_SIZEOF_C_LONG == 8) || defined(MSWIN_64)
    -
    17 #define IDL_SIZEOF_C_PTR 8
    -
    18 #else
    -
    19 #define IDL_SIZEOF_C_PTR 4
    -
    20 #endif
    -
    21 typedef short IDL_INT;
    -
    22 typedef unsigned short IDL_UINT;
    -
    23 #if IDL_SIZEOF_C_LONG == 8
    -
    24 typedef int IDL_LONG;
    -
    25 typedef unsigned int IDL_ULONG;
    -
    26 #elif IDL_SIZEOF_C_LONG == 4
    -
    27 typedef long IDL_LONG;
    -
    28 typedef unsigned long IDL_ULONG;
    -
    29 #else
    -
    30 #error "IDL_LONG not defined --- unexpected value of IDL_SIZEOF_C_LONG"
    -
    31 #endif
    -
    32 
    -
    33 int s2let_idl_axisym_hpx_wav_analysis_real(int argc, void* argv[])
    -
    34 {
    -
    35  if(argc != 8) return 0;
    -
    36  double *f_wav = (double *) argv[0];
    -
    37  double *f_scal = (double *) argv[1];
    -
    38  double *f = (double *) argv[2];
    -
    39  IDL_INT *nside = (IDL_INT *) argv[3];
    -
    40  IDL_INT *B = (IDL_INT *) argv[4];
    -
    41  IDL_INT *L = (IDL_INT *) argv[5];
    -
    42  IDL_INT *J_min = (IDL_INT *) argv[6];
    -
    43 
    -
    44 
    -
    45  IDL_INT *wavtype = (IDL_INT *) argv[7];
    -
    46  s2let_switch_wavtype(*wavtype);
    -
    47 
    -
    48  s2let_parameters_t parameters = {};
    -
    49  parameters.B = *B;
    -
    50  parameters.L = *L;
    -
    51  parameters.J_min = *J_min;
    -
    52  s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, *nside, &parameters);
    -
    53  //s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, *nside, *B, *L, *J_min);
    -
    54 
    -
    55  return 1;
    -
    56 }
    -
    57 
    -
    58 int s2let_idl_axisym_hpx_wav_synthesis_real(int argc, void* argv[])
    -
    59 {
    -
    60  if(argc != 8) return 0;
    -
    61  double *f = (double *) argv[0];
    -
    62  double *f_wav = (double *) argv[1];
    -
    63  double *f_scal = (double *) argv[2];
    -
    64  IDL_INT *nside = (IDL_INT *) argv[3];
    -
    65  IDL_INT *B = (IDL_INT *) argv[4];
    -
    66  IDL_INT *L = (IDL_INT *) argv[5];
    -
    67  IDL_INT *J_min = (IDL_INT *) argv[6];
    -
    68 
    -
    69  IDL_INT *wavtype = (IDL_INT *) argv[7];
    -
    70  s2let_switch_wavtype(*wavtype);
    -
    71 
    -
    72  s2let_parameters_t parameters = {};
    -
    73  parameters.B = *B;
    -
    74  parameters.L = *L;
    -
    75  parameters.J_min = *J_min;
    -
    76  s2let_transform_axisym_wav_synthesis_hpx_real(f, f_wav, f_scal, *nside, &parameters);
    -
    77  //s2let_transform_axisym_wav_synthesis_hpx_real(f, f_wav, f_scal, *nside, *B, *L, *J_min);
    -
    78 
    -
    79  return 1;
    -
    80 }
    -
    81 
    -
    82 
    -
    83 int s2let_idl_hpx_map2alm_real(int argc, void* argv[])
    -
    84 {
    -
    85  if(argc != 4) return 0;
    -
    86  complex double *flm = (complex double *) argv[0];
    -
    87  double *f = (double *) argv[1];
    -
    88  IDL_INT *nside = (IDL_INT *) argv[2];
    -
    89  IDL_INT *L = (IDL_INT *) argv[3];
    -
    90 
    -
    91  s2let_hpx_map2alm_real(flm, f, *nside, *L);
    -
    92 
    -
    93  return 1;
    -
    94 }
    -
    95 
    -
    96 int s2let_idl_hpx_alm2map_real(int argc, void* argv[])
    -
    97 {
    -
    98  if(argc != 4) return 0;
    -
    99  double *f = (double *) argv[0];
    -
    100  complex double *flm = (complex double *) argv[1];
    -
    101  IDL_INT *nside = (IDL_INT *) argv[2];
    -
    102  IDL_INT *L = (IDL_INT *) argv[3];
    -
    103 
    -
    104  s2let_hpx_alm2map_real(f, flm, *nside, *L);
    -
    105 
    -
    106  return 1;
    -
    107 }
    -
    -
    IDL_ULONG
    unsigned long IDL_ULONG
    Definition: s2let_idl_hpx.c:28
    -
    s2let_hpx_map2alm_real
    void s2let_hpx_map2alm_real(complex double *flm, const double *f, int nside, int L)
    Definition: s2let_hpx.c:25
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    - -
    s2let_idl_hpx_alm2map_real
    int s2let_idl_hpx_alm2map_real(int argc, void *argv[])
    Definition: s2let_idl_hpx.c:96
    -
    IDL_UINT
    unsigned short IDL_UINT
    Definition: s2let_idl_hpx.c:22
    -
    s2let_switch_wavtype
    void s2let_switch_wavtype(int typenum)
    Definition: s2let_tiling.c:23
    -
    s2let_transform_axisym_wav_synthesis_hpx_real
    void s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:55
    -
    IDL_LONG
    long IDL_LONG
    Definition: s2let_idl_hpx.c:27
    -
    s2let_transform_axisym_wav_analysis_hpx_real
    void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:18
    -
    s2let_idl_axisym_hpx_wav_analysis_real
    int s2let_idl_axisym_hpx_wav_analysis_real(int argc, void *argv[])
    Definition: s2let_idl_hpx.c:33
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_idl_hpx_map2alm_real
    int s2let_idl_hpx_map2alm_real(int argc, void *argv[])
    Definition: s2let_idl_hpx.c:83
    -
    IDL_INT
    short IDL_INT
    Definition: s2let_idl_hpx.c:21
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_hpx_alm2map_real
    void s2let_hpx_alm2map_real(double *f, const complex double *flm, int nside, int L)
    Definition: s2let_hpx.c:20
    -
    s2let_idl_axisym_hpx_wav_synthesis_real
    int s2let_idl_axisym_hpx_wav_synthesis_real(int argc, void *argv[])
    Definition: s2let_idl_hpx.c:58
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__idl__hpx_8h.html b/docs/c/s2let__idl__hpx_8h.html index b68d3892..bb02f528 100644 --- a/docs/c/s2let__idl__hpx_8h.html +++ b/docs/c/s2let__idl__hpx_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_idl_hpx.h File Reference +s2let: include/s2let_idl_hpx.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_idl_hpx.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -117,8 +167,6 @@

    IDL interface to s2let_hpx_alm2map_real

    -

    Definition at line 96 of file s2let_idl_hpx.c.

    - @@ -206,14 +254,12 @@

    IDL interface to s2let_hpx_map2alm_real

    -

    Definition at line 83 of file s2let_idl_hpx.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__idl__hpx_8h__dep__incl.map b/docs/c/s2let__idl__hpx_8h__dep__incl.map new file mode 100644 index 00000000..ddb8464d --- /dev/null +++ b/docs/c/s2let__idl__hpx_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__idl__hpx_8h__dep__incl.md5 b/docs/c/s2let__idl__hpx_8h__dep__incl.md5 new file mode 100644 index 00000000..f45d1884 --- /dev/null +++ b/docs/c/s2let__idl__hpx_8h__dep__incl.md5 @@ -0,0 +1 @@ +648ff4eb159408b0ef9b62355795e3ba \ No newline at end of file diff --git a/docs/c/s2let__idl__hpx_8h__incl.map b/docs/c/s2let__idl__hpx_8h__incl.map new file mode 100644 index 00000000..56137109 --- /dev/null +++ b/docs/c/s2let__idl__hpx_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__idl__hpx_8h__incl.md5 b/docs/c/s2let__idl__hpx_8h__incl.md5 new file mode 100644 index 00000000..4c2f7a96 --- /dev/null +++ b/docs/c/s2let__idl__hpx_8h__incl.md5 @@ -0,0 +1 @@ +97c4155a2b3ae49c247190554343ca61 \ No newline at end of file diff --git a/docs/c/s2let__idl__hpx_8h_source.html b/docs/c/s2let__idl__hpx_8h_source.html index 64bb170d..c97bcbf3 100644 --- a/docs/c/s2let__idl__hpx_8h_source.html +++ b/docs/c/s2let__idl__hpx_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_idl_hpx.h Source File +s2let: include/s2let_idl_hpx.h Source File @@ -22,10 +22,10 @@

    @@ -100,11 +100,11 @@
    s2let_idl_hpx_axisym_wav_synthesis_real
    int s2let_idl_hpx_axisym_wav_synthesis_real(int argc, void *argv[])
    s2let_idl_hpx_axisym_wav_analysis_real
    int s2let_idl_hpx_axisym_wav_analysis_real(int argc, void *argv[])
    -
    s2let_idl_hpx_map2alm_real
    int s2let_idl_hpx_map2alm_real(int argc, void *argv[])
    Definition: s2let_idl_hpx.c:83
    -
    s2let_idl_hpx_alm2map_real
    int s2let_idl_hpx_alm2map_real(int argc, void *argv[])
    Definition: s2let_idl_hpx.c:96
    +
    s2let_idl_hpx_map2alm_real
    int s2let_idl_hpx_map2alm_real(int argc, void *argv[])
    Definition: s2let_idl_hpx.c:84
    +
    s2let_idl_hpx_alm2map_real
    int s2let_idl_hpx_alm2map_real(int argc, void *argv[])
    Definition: s2let_idl_hpx.c:97
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__idl__mw_8c.html b/docs/c/s2let__idl__mw_8c.html index e1163a39..aecd0adf 100644 --- a/docs/c/s2let__idl__mw_8c.html +++ b/docs/c/s2let__idl__mw_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_idl_mw.c File Reference +s2let: src/main/c/s2let_idl_mw.c File Reference @@ -22,10 +22,10 @@ @@ -77,9 +77,41 @@
    #include "s2let.h"
    -
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    +Include dependency graph for s2let_idl_mw.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    @@ -138,8 +170,6 @@

    -

    Definition at line 14 of file s2let_idl_mw.c.

    - @@ -154,8 +184,6 @@

    -

    Definition at line 19 of file s2let_idl_mw.c.

    -

    Typedef Documentation

    @@ -171,8 +199,6 @@

    -

    Definition at line 21 of file s2let_idl_mw.c.

    - @@ -187,8 +213,6 @@

    -

    Definition at line 27 of file s2let_idl_mw.c.

    - @@ -203,8 +227,6 @@

    -

    Definition at line 22 of file s2let_idl_mw.c.

    - @@ -219,8 +241,6 @@

    -

    Definition at line 28 of file s2let_idl_mw.c.

    -

    Function Documentation

    @@ -250,8 +270,6 @@

    -

    Definition at line 233 of file s2let_idl_mw.c.

    - @@ -280,8 +298,6 @@

    -

    Definition at line 258 of file s2let_idl_mw.c.

    - @@ -310,8 +326,6 @@

    -

    Definition at line 221 of file s2let_idl_mw.c.

    - @@ -340,8 +354,6 @@

    -

    Definition at line 246 of file s2let_idl_mw.c.

    - @@ -371,8 +383,6 @@

    IDL interface to s2let_mw_axisym_wav_analysis_mw

    -

    Definition at line 81 of file s2let_idl_mw.c.

    - @@ -402,8 +412,6 @@

    IDL interface to s2let_mw_axisym_wav_analysis_mw_multires

    -

    Definition at line 128 of file s2let_idl_mw.c.

    - @@ -433,8 +441,6 @@

    IDL interface to s2let_mw_axisym_wav_analysis_mw_multires_real

    -

    Definition at line 174 of file s2let_idl_mw.c.

    - @@ -464,8 +470,6 @@

    IDL interface to s2let_mw_axisym_wav_analysis_mw_real

    -

    Definition at line 34 of file s2let_idl_mw.c.

    - @@ -495,8 +499,6 @@

    IDL interface to s2let_mw_axisym_wav_synthesis_mw

    -

    Definition at line 104 of file s2let_idl_mw.c.

    - @@ -526,8 +528,6 @@

    IDL interface to s2let_mw_axisym_wav_synthesis_mw_multires

    -

    Definition at line 151 of file s2let_idl_mw.c.

    - @@ -557,8 +557,6 @@

    IDL interface to s2let_mw_axisym_wav_synthesis_mw_multires_real

    -

    Definition at line 197 of file s2let_idl_mw.c.

    - @@ -588,14 +586,12 @@

    IDL interface to s2let_mw_axisym_wav_synthesis_mw_real

    -

    Definition at line 57 of file s2let_idl_mw.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__idl__mw_8c__incl.map b/docs/c/s2let__idl__mw_8c__incl.map new file mode 100644 index 00000000..5d6cc9cf --- /dev/null +++ b/docs/c/s2let__idl__mw_8c__incl.map @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__idl__mw_8c__incl.md5 b/docs/c/s2let__idl__mw_8c__incl.md5 new file mode 100644 index 00000000..893c7eb6 --- /dev/null +++ b/docs/c/s2let__idl__mw_8c__incl.md5 @@ -0,0 +1 @@ +09ee76b6988c50afccbc8c801bb83e09 \ No newline at end of file diff --git a/docs/c/s2let__idl__mw_8c_source.html b/docs/c/s2let__idl__mw_8c_source.html deleted file mode 100644 index 4b4f70f8..00000000 --- a/docs/c/s2let__idl__mw_8c_source.html +++ /dev/null @@ -1,384 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_idl_mw.c Source File - - - - - - - - - -
    -
    -

    Macros

    #define IDL_SIZEOF_C_LONG   4
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_idl_mw.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 
    -
    7 /*
    -
    8  * IDL integer types. For historical reasons, we use UCHAR for TYP_BYTE
    -
    9  * instead of defining an IDL_BYTE type.
    -
    10  */
    -
    11 #if defined(ALPHA_OSF) || defined(SUN_64) || defined(LINUX_X86_64) || defined(HPUX_64) || defined(IRIX_64) || defined(AIX_64)
    -
    12 #define IDL_SIZEOF_C_LONG 8
    -
    13 #else
    -
    14 #define IDL_SIZEOF_C_LONG 4
    -
    15 #endif
    -
    16 #if (IDL_SIZEOF_C_LONG == 8) || defined(MSWIN_64)
    -
    17 #define IDL_SIZEOF_C_PTR 8
    -
    18 #else
    -
    19 #define IDL_SIZEOF_C_PTR 4
    -
    20 #endif
    -
    21 typedef short IDL_INT;
    -
    22 typedef unsigned short IDL_UINT;
    -
    23 #if IDL_SIZEOF_C_LONG == 8
    -
    24 typedef int IDL_LONG;
    -
    25 typedef unsigned int IDL_ULONG;
    -
    26 #elif IDL_SIZEOF_C_LONG == 4
    -
    27 typedef long IDL_LONG;
    -
    28 typedef unsigned long IDL_ULONG;
    -
    29 #else
    -
    30 #error "IDL_LONG not defined --- unexpected value of IDL_SIZEOF_C_LONG"
    -
    31 #endif
    -
    32 
    -
    33 
    -
    34 int s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void* argv[])
    -
    35 {
    -
    36  if(argc != 7) return 0;
    -
    37  double *f_wav = (double *) argv[0];
    -
    38  double *f_scal = (double *) argv[1];
    -
    39  double *f = (double *) argv[2];
    -
    40  IDL_INT *B = (IDL_INT *) argv[3];
    -
    41  IDL_INT *L = (IDL_INT *) argv[4];
    -
    42  IDL_INT *J_min = (IDL_INT *) argv[5];
    -
    43 
    -
    44  IDL_INT *wavtype = (IDL_INT *) argv[6];
    -
    45  s2let_switch_wavtype(*wavtype);
    -
    46 
    -
    47  s2let_parameters_t parameters = {};
    -
    48  parameters.B = *B;
    -
    49  parameters.L = *L;
    -
    50  parameters.J_min = *J_min;
    -
    51 
    -
    52  s2let_transform_axisym_wav_analysis_mw_real(f_wav, f_scal, f, &parameters);
    -
    53 
    -
    54  return 1;
    -
    55 }
    -
    56 
    -
    57 int s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void* argv[])
    -
    58 {
    -
    59  if(argc != 7) return 0;
    -
    60  double *f = (double *) argv[0];
    -
    61  double *f_wav = (double *) argv[1];
    -
    62  double *f_scal = (double *) argv[2];
    -
    63  IDL_INT *B = (IDL_INT *) argv[3];
    -
    64  IDL_INT *L = (IDL_INT *) argv[4];
    -
    65  IDL_INT *J_min = (IDL_INT *) argv[5];
    -
    66 
    -
    67  IDL_INT *wavtype = (IDL_INT *) argv[6];
    -
    68  s2let_switch_wavtype(*wavtype);
    -
    69 
    -
    70  s2let_parameters_t parameters = {};
    -
    71  parameters.B = *B;
    -
    72  parameters.L = *L;
    -
    73  parameters.J_min = *J_min;
    -
    74 
    -
    75  s2let_transform_axisym_wav_synthesis_mw_real(f, f_wav, f_scal, &parameters);
    -
    76 
    -
    77  return 1;
    -
    78 }
    -
    79 
    -
    80 
    -
    81 int s2let_idl_transform_axisym_wav_analysis_mw(int argc, void* argv[])
    -
    82 {
    -
    83  if(argc != 7) return 0;
    -
    84  complex double *f_wav = (complex double *) argv[0];
    -
    85  complex double *f_scal = (complex double *) argv[1];
    -
    86  complex double *f = (complex double *) argv[2];
    -
    87  IDL_INT *B = (IDL_INT *) argv[3];
    -
    88  IDL_INT *L = (IDL_INT *) argv[4];
    -
    89  IDL_INT *J_min = (IDL_INT *) argv[5];
    -
    90 
    -
    91  IDL_INT *wavtype = (IDL_INT *) argv[6];
    -
    92  s2let_switch_wavtype(*wavtype);
    -
    93 
    -
    94  s2let_parameters_t parameters = {};
    -
    95  parameters.B = *B;
    -
    96  parameters.L = *L;
    -
    97  parameters.J_min = *J_min;
    -
    98 
    -
    99  s2let_transform_axisym_wav_analysis_mw(f_wav, f_scal, f, &parameters);
    -
    100 
    -
    101  return 1;
    -
    102 }
    -
    103 
    -
    104 int s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void* argv[])
    -
    105 {
    -
    106  if(argc != 7) return 0;
    -
    107  complex double *f = (complex double *) argv[0];
    -
    108  complex double *f_wav = (complex double *) argv[1];
    -
    109  complex double *f_scal = (complex double *) argv[2];
    -
    110  IDL_INT *B = (IDL_INT *) argv[3];
    -
    111  IDL_INT *L = (IDL_INT *) argv[4];
    -
    112  IDL_INT *J_min = (IDL_INT *) argv[5];
    -
    113 
    -
    114  IDL_INT *wavtype = (IDL_INT *) argv[6];
    -
    115  s2let_switch_wavtype(*wavtype);
    -
    116 
    -
    117  s2let_parameters_t parameters = {};
    -
    118  parameters.B = *B;
    -
    119  parameters.L = *L;
    -
    120  parameters.J_min = *J_min;
    -
    121 
    -
    122  s2let_transform_axisym_wav_synthesis_mw(f, f_wav, f_scal, &parameters);
    -
    123 
    -
    124  return 1;
    -
    125 }
    -
    126 
    -
    127 
    -
    128 int s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void* argv[])
    -
    129 {
    -
    130  if(argc != 7) return 0;
    -
    131  complex double *f_wav = (complex double *) argv[0];
    -
    132  complex double *f_scal = (complex double *) argv[1];
    -
    133  complex double *f = (complex double *) argv[2];
    -
    134  IDL_INT *B = (IDL_INT *) argv[3];
    -
    135  IDL_INT *L = (IDL_INT *) argv[4];
    -
    136  IDL_INT *J_min = (IDL_INT *) argv[5];
    -
    137 
    -
    138  IDL_INT *wavtype = (IDL_INT *) argv[6];
    -
    139  s2let_switch_wavtype(*wavtype);
    -
    140 
    -
    141  s2let_parameters_t parameters = {};
    -
    142  parameters.B = *B;
    -
    143  parameters.L = *L;
    -
    144  parameters.J_min = *J_min;
    -
    145 
    -
    146  s2let_transform_axisym_wav_analysis_mw_multires(f_wav, f_scal, f, &parameters);
    -
    147 
    -
    148  return 1;
    -
    149 }
    -
    150 
    -
    151 int s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void* argv[])
    -
    152 {
    -
    153  if(argc != 7) return 0;
    -
    154  complex double *f = (complex double *) argv[0];
    -
    155  complex double *f_wav = (complex double *) argv[1];
    -
    156  complex double *f_scal = (complex double *) argv[2];
    -
    157  IDL_INT *B = (IDL_INT *) argv[3];
    -
    158  IDL_INT *L = (IDL_INT *) argv[4];
    -
    159  IDL_INT *J_min = (IDL_INT *) argv[5];
    -
    160 
    -
    161  IDL_INT *wavtype = (IDL_INT *) argv[6];
    -
    162  s2let_switch_wavtype(*wavtype);
    -
    163 
    -
    164  s2let_parameters_t parameters = {};
    -
    165  parameters.B = *B;
    -
    166  parameters.L = *L;
    -
    167  parameters.J_min = *J_min;
    -
    168 
    -
    169  s2let_transform_axisym_wav_synthesis_mw_multires(f, f_wav, f_scal, &parameters);
    -
    170 
    -
    171  return 1;
    -
    172 }
    -
    173 
    -
    174 int s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void* argv[])
    -
    175 {
    -
    176  if(argc != 7) return 0;
    -
    177  double *f_wav = (double *) argv[0];
    -
    178  double *f_scal = (double *) argv[1];
    -
    179  double *f = (double *) argv[2];
    -
    180  IDL_INT *B = (IDL_INT *) argv[3];
    -
    181  IDL_INT *L = (IDL_INT *) argv[4];
    -
    182  IDL_INT *J_min = (IDL_INT *) argv[5];
    -
    183 
    -
    184  IDL_INT *wavtype = (IDL_INT *) argv[6];
    -
    185  s2let_switch_wavtype(*wavtype);
    -
    186 
    -
    187  s2let_parameters_t parameters = {};
    -
    188  parameters.B = *B;
    -
    189  parameters.L = *L;
    -
    190  parameters.J_min = *J_min;
    -
    191 
    -
    192  s2let_transform_axisym_wav_analysis_mw_multires_real(f_wav, f_scal, f, &parameters);
    -
    193 
    -
    194  return 1;
    -
    195 }
    -
    196 
    -
    197 int s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void* argv[])
    -
    198 {
    -
    199  if(argc != 7) return 0;
    -
    200  double *f = (double *) argv[0];
    -
    201  double *f_wav = (double *) argv[1];
    -
    202  double *f_scal = (double *) argv[2];
    -
    203  IDL_INT *B = (IDL_INT *) argv[3];
    -
    204  IDL_INT *L = (IDL_INT *) argv[4];
    -
    205  IDL_INT *J_min = (IDL_INT *) argv[5];
    -
    206 
    -
    207  IDL_INT *wavtype = (IDL_INT *) argv[6];
    -
    208  s2let_switch_wavtype(*wavtype);
    -
    209 
    -
    210  s2let_parameters_t parameters = {};
    -
    211  parameters.B = *B;
    -
    212  parameters.L = *L;
    -
    213  parameters.J_min = *J_min;
    -
    214 
    -
    215  s2let_transform_axisym_wav_synthesis_mw_multires_real(f, f_wav, f_scal, &parameters);
    -
    216 
    -
    217  return 1;
    -
    218 }
    -
    219 
    -
    220 
    -
    221 int s2let_idl_mw_map2alm(int argc, void* argv[])
    -
    222 {
    -
    223  if(argc != 3) return 0;
    -
    224  complex double *flm = (complex double *) argv[0];
    -
    225  complex double *f = (complex double *) argv[1];
    -
    226  IDL_INT *L = (IDL_INT *) argv[2];
    -
    227 
    -
    228  s2let_mw_map2alm(flm, f, *L, 0);
    -
    229 
    -
    230  return 1;
    -
    231 }
    -
    232 
    -
    233 int s2let_idl_mw_alm2map(int argc, void* argv[])
    -
    234 {
    -
    235  if(argc != 3) return 0;
    -
    236  complex double *f = (complex double *) argv[0];
    -
    237  complex double *flm = (complex double *) argv[1];
    -
    238  IDL_INT *L = (IDL_INT *) argv[2];
    -
    239 
    -
    240  s2let_mw_alm2map(f, flm, *L, 0);
    -
    241 
    -
    242  return 1;
    -
    243 }
    -
    244 
    -
    245 
    -
    246 int s2let_idl_mw_map2alm_real(int argc, void* argv[])
    -
    247 {
    -
    248  if(argc != 3) return 0;
    -
    249  complex double *flm = (complex double *) argv[0];
    -
    250  double *f = (double *) argv[1];
    -
    251  IDL_INT *L = (IDL_INT *) argv[2];
    -
    252 
    -
    253  s2let_mw_map2alm_real(flm, f, *L);
    -
    254 
    -
    255  return 1;
    -
    256 }
    -
    257 
    -
    258 int s2let_idl_mw_alm2map_real(int argc, void* argv[])
    -
    259 {
    -
    260  if(argc != 3) return 0;
    -
    261  double *f = (double *) argv[0];
    -
    262  complex double *flm = (complex double *) argv[1];
    -
    263  IDL_INT *L = (IDL_INT *) argv[2];
    -
    264 
    -
    265  s2let_mw_alm2map_real(f, flm, *L);
    -
    266 
    -
    267  return 1;
    -
    268 }
    -
    -
    IDL_UINT
    unsigned short IDL_UINT
    Definition: s2let_idl_mw.c:22
    -
    IDL_ULONG
    unsigned long IDL_ULONG
    Definition: s2let_idl_mw.c:28
    -
    s2let_mw_map2alm
    void s2let_mw_map2alm(complex double *flm, const complex double *f, int L, int spin)
    Definition: s2let_mw.c:35
    -
    s2let_idl_mw_alm2map_real
    int s2let_idl_mw_alm2map_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:258
    -
    s2let_idl_transform_axisym_wav_analysis_mw_multires
    int s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[])
    Definition: s2let_idl_mw.c:128
    -
    s2let_transform_axisym_wav_analysis_mw_real
    void s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:660
    -
    s2let_transform_axisym_wav_synthesis_mw_real
    void s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:789
    -
    s2let_mw_alm2map
    void s2let_mw_alm2map(complex double *f, const complex double *flm, int L, int spin)
    Definition: s2let_mw.c:20
    -
    s2let_transform_axisym_wav_analysis_mw_multires_real
    void s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:918
    -
    s2let_idl_mw_map2alm
    int s2let_idl_mw_map2alm(int argc, void *argv[])
    Definition: s2let_idl_mw.c:221
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_idl_transform_axisym_wav_synthesis_mw_multires
    int s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[])
    Definition: s2let_idl_mw.c:151
    - -
    IDL_LONG
    long IDL_LONG
    Definition: s2let_idl_mw.c:27
    -
    s2let_transform_axisym_wav_synthesis_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1053
    -
    s2let_idl_transform_axisym_wav_analysis_mw_multires_real
    int s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:174
    -
    s2let_mw_map2alm_real
    void s2let_mw_map2alm_real(complex double *flm, const double *f, int L)
    Definition: s2let_mw.c:65
    -
    s2let_transform_axisym_wav_synthesis_mw_multires
    void s2let_transform_axisym_wav_synthesis_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:524
    -
    s2let_idl_transform_axisym_wav_synthesis_mw_multires_real
    int s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:197
    -
    s2let_transform_axisym_wav_analysis_mw_multires
    void s2let_transform_axisym_wav_analysis_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:389
    -
    s2let_transform_axisym_wav_analysis_mw
    void s2let_transform_axisym_wav_analysis_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:124
    -
    s2let_transform_axisym_wav_synthesis_mw
    void s2let_transform_axisym_wav_synthesis_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:255
    -
    s2let_switch_wavtype
    void s2let_switch_wavtype(int typenum)
    Definition: s2let_tiling.c:23
    -
    s2let_idl_transform_axisym_wav_synthesis_mw
    int s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[])
    Definition: s2let_idl_mw.c:104
    -
    IDL_INT
    short IDL_INT
    Definition: s2let_idl_mw.c:21
    -
    s2let_idl_transform_axisym_wav_analysis_mw_real
    int s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:34
    -
    s2let_idl_mw_alm2map
    int s2let_idl_mw_alm2map(int argc, void *argv[])
    Definition: s2let_idl_mw.c:233
    -
    s2let_idl_transform_axisym_wav_synthesis_mw_real
    int s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:57
    -
    s2let_mw_alm2map_real
    void s2let_mw_alm2map_real(double *f, const complex double *flm, int L)
    Definition: s2let_mw.c:50
    -
    s2let_idl_mw_map2alm_real
    int s2let_idl_mw_map2alm_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:246
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_idl_transform_axisym_wav_analysis_mw
    int s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[])
    Definition: s2let_idl_mw.c:81
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    IDL_INT
    short IDL_INT
    Definition: s2let_idl_hpx.c:21
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__idl__mw_8h.html b/docs/c/s2let__idl__mw_8h.html index 329ab4e2..33a74969 100644 --- a/docs/c/s2let__idl__mw_8h.html +++ b/docs/c/s2let__idl__mw_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_idl_mw.h File Reference +s2let: include/s2let_idl_mw.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,7 +74,48 @@
    s2let_idl_mw.h File Reference
    - +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +

    Go to the source code of this file.

    @@ -114,20 +114,20 @@
    76 #endif
    s2let_idl_transform_map2alm_real
    int s2let_idl_transform_map2alm_real(int argc, void *argv[])
    -
    s2let_idl_transform_axisym_wav_synthesis_mw_multires_real
    int s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:197
    -
    s2let_idl_transform_axisym_wav_analysis_mw_multires
    int s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[])
    Definition: s2let_idl_mw.c:128
    +
    s2let_idl_transform_axisym_wav_synthesis_mw_multires_real
    int s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:195
    +
    s2let_idl_transform_axisym_wav_analysis_mw_multires
    int s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[])
    Definition: s2let_idl_mw.c:126
    s2let_idl_transform_map2alm
    int s2let_idl_transform_map2alm(int argc, void *argv[])
    s2let_idl_transform_alm2map_real
    int s2let_idl_transform_alm2map_real(int argc, void *argv[])
    -
    s2let_idl_transform_axisym_wav_analysis_mw
    int s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[])
    Definition: s2let_idl_mw.c:81
    -
    s2let_idl_transform_axisym_wav_synthesis_mw_multires
    int s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[])
    Definition: s2let_idl_mw.c:151
    +
    s2let_idl_transform_axisym_wav_analysis_mw
    int s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[])
    Definition: s2let_idl_mw.c:80
    +
    s2let_idl_transform_axisym_wav_synthesis_mw_multires
    int s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[])
    Definition: s2let_idl_mw.c:149
    s2let_idl_transform_alm2map
    int s2let_idl_transform_alm2map(int argc, void *argv[])
    -
    s2let_idl_transform_axisym_wav_analysis_mw_real
    int s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:34
    -
    s2let_idl_transform_axisym_wav_synthesis_mw
    int s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[])
    Definition: s2let_idl_mw.c:104
    -
    s2let_idl_transform_axisym_wav_analysis_mw_multires_real
    int s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:174
    -
    s2let_idl_transform_axisym_wav_synthesis_mw_real
    int s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:57
    +
    s2let_idl_transform_axisym_wav_analysis_mw_real
    int s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:34
    +
    s2let_idl_transform_axisym_wav_synthesis_mw
    int s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[])
    Definition: s2let_idl_mw.c:103
    +
    s2let_idl_transform_axisym_wav_analysis_mw_multires_real
    int s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:172
    +
    s2let_idl_transform_axisym_wav_synthesis_mw_real
    int s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[])
    Definition: s2let_idl_mw.c:57
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__lm_8c.html b/docs/c/s2let__lm_8c.html index 5b7576b9..8586e85c 100644 --- a/docs/c/s2let__lm_8c.html +++ b/docs/c/s2let__lm_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_lm.c File Reference +s2let: src/main/c/s2let_lm.c File Reference @@ -22,10 +22,10 @@ @@ -74,23 +74,57 @@
    s2let_lm.c File Reference
    -
    #include "s2let.h"
    -#include <complex.h>
    -#include <ssht/ssht.h>
    +
    #include <complex.h>
    +#include <math.h>
    #include <so3/so3.h>
    +#include <ssht/ssht.h>
    #include <stdlib.h>
    -#include <math.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_lm.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -

    @@ -190,8 +231,6 @@

    IDL interface to s2let_mw_axisym_wav_analysis_mw

    -

    Definition at line 81 of file s2let_idl_mw.c.

    - @@ -221,8 +260,6 @@

    IDL interface to s2let_mw_axisym_wav_analysis_mw_multires

    -

    Definition at line 128 of file s2let_idl_mw.c.

    - @@ -252,8 +289,6 @@

    IDL interface to s2let_mw_axisym_wav_analysis_mw_multires_real

    -

    Definition at line 174 of file s2let_idl_mw.c.

    - @@ -283,8 +318,6 @@

    IDL interface to s2let_mw_axisym_wav_analysis_mw_real

    -

    Definition at line 34 of file s2let_idl_mw.c.

    - @@ -314,8 +347,6 @@

    IDL interface to s2let_mw_axisym_wav_synthesis_mw

    -

    Definition at line 104 of file s2let_idl_mw.c.

    - @@ -345,8 +376,6 @@

    IDL interface to s2let_mw_axisym_wav_synthesis_mw_multires

    -

    Definition at line 151 of file s2let_idl_mw.c.

    - @@ -376,8 +405,6 @@

    IDL interface to s2let_mw_axisym_wav_synthesis_mw_multires_real

    -

    Definition at line 197 of file s2let_idl_mw.c.

    - @@ -407,8 +434,6 @@

    IDL interface to s2let_mw_axisym_wav_synthesis_mw_real

    -

    Definition at line 57 of file s2let_idl_mw.c.

    - @@ -472,7 +497,7 @@

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__idl__mw_8h__dep__incl.map b/docs/c/s2let__idl__mw_8h__dep__incl.map new file mode 100644 index 00000000..e6fabe42 --- /dev/null +++ b/docs/c/s2let__idl__mw_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__idl__mw_8h__dep__incl.md5 b/docs/c/s2let__idl__mw_8h__dep__incl.md5 new file mode 100644 index 00000000..be4b95d0 --- /dev/null +++ b/docs/c/s2let__idl__mw_8h__dep__incl.md5 @@ -0,0 +1 @@ +7a402ced3ada020473e45b31bb16db12 \ No newline at end of file diff --git a/docs/c/s2let__idl__mw_8h_source.html b/docs/c/s2let__idl__mw_8h_source.html index 1d99b044..b482c251 100644 --- a/docs/c/s2let__idl__mw_8h_source.html +++ b/docs/c/s2let__idl__mw_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_idl_mw.h Source File +s2let: include/s2let_idl_mw.h Source File @@ -22,10 +22,10 @@

    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    - + - +

    Functions

    double s2let_lm_power (complex double *flm, int L)
     
    void s2let_lm_random_flm (complex double *flm, int L, int spin, int seed)
    void s2let_lm_random_flm (complex double *flm, int L, int spin, int seed)
     
    void s2let_lm_random_flm_real (complex double *flm, int L, int seed)
    void s2let_lm_random_flm_real (complex double *flm, int L, int seed)
     

    Function Documentation

    @@ -121,8 +155,6 @@

    Compute power for a signal in harmonic space.

    -

    Definition at line 16 of file s2let_lm.c.

    -

    @@ -178,8 +210,6 @@

    Definition at line 34 of file s2let_lm.c.

    - @@ -229,14 +259,12 @@

    Definition at line 52 of file s2let_lm.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__lm_8c__incl.map b/docs/c/s2let__lm_8c__incl.map new file mode 100644 index 00000000..463bc232 --- /dev/null +++ b/docs/c/s2let__lm_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__lm_8c__incl.md5 b/docs/c/s2let__lm_8c__incl.md5 new file mode 100644 index 00000000..69aaaedc --- /dev/null +++ b/docs/c/s2let__lm_8c__incl.md5 @@ -0,0 +1 @@ +a95daecd2205e4652ecb3167e2d17c42 \ No newline at end of file diff --git a/docs/c/s2let__lm_8c_source.html b/docs/c/s2let__lm_8c_source.html deleted file mode 100644 index 61c5a0c9..00000000 --- a/docs/c/s2let__lm_8c_source.html +++ /dev/null @@ -1,133 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_lm.c Source File - - - - - - - - - -
    -
    - - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_lm.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <complex.h>
    -
    7 #include <ssht/ssht.h>
    -
    8 #include <so3/so3.h>
    -
    9 #include <stdlib.h>
    -
    10 #include <math.h>
    -
    11 #include <time.h>
    -
    12 
    -
    16 double s2let_lm_power(complex double *flm, int L){
    -
    17  int i;
    -
    18  double totalpower = 0.0;
    -
    19  for(i = 0; i < L*L; ++i)
    -
    20  totalpower += pow(cabs(flm[i]), 2.0);
    -
    21  totalpower = totalpower / (L * L);
    -
    22  return totalpower;
    -
    23 }
    -
    24 
    -
    34 void s2let_lm_random_flm(complex double *flm, int L, int spin, int seed)
    -
    35 {
    -
    36  int i, i_min;
    -
    37  srand( time(NULL) );
    -
    38  // el < |s| are zero, so start with el = |s|, m = -el.
    -
    39  i_min = spin*spin;
    -
    40  for (i=i_min; i<L*L; ++i)
    -
    41  flm[i] = (2.0*ran2_dp(seed) - 1.0) + I * (2.0*ran2_dp(seed) - 1.0);
    -
    42 }
    -
    43 
    -
    52 void s2let_lm_random_flm_real(complex double *flm, int L, int seed) {
    -
    53  int el, m, msign, i, i_op;
    -
    54  for (el = 0; el < L; ++el) {
    -
    55  m = 0;
    -
    56  i = el*el + el + m;
    -
    57  flm[i] = (2.0*ran2_dp(seed) - 1.0);
    -
    58  for (m = 1; m <= el; ++m) {
    -
    59  i = el*el + el + m;
    -
    60  flm[i] = (2.0*ran2_dp(seed) - 1.0) + I * (2.0*ran2_dp(seed) - 1.0);
    -
    61  i_op = el*el + el - m;
    -
    62  msign = m & 1;
    -
    63  msign = 1 - msign - msign; // (-1)^m
    -
    64  flm[i_op] = msign * conj(flm[i]);
    -
    65  }
    -
    66  }
    -
    67 }
    -
    -
    s2let_lm_power
    double s2let_lm_power(complex double *flm, int L)
    Definition: s2let_lm.c:16
    - -
    s2let_lm_random_flm_real
    void s2let_lm_random_flm_real(complex double *flm, int L, int seed)
    Definition: s2let_lm.c:52
    -
    ran2_dp
    double ran2_dp(int idum)
    Definition: s2let_math.c:104
    -
    s2let_lm_random_flm
    void s2let_lm_random_flm(complex double *flm, int L, int spin, int seed)
    Definition: s2let_lm.c:34
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__lm_8h.html b/docs/c/s2let__lm_8h.html index 5f48f90d..8196e49a 100644 --- a/docs/c/s2let__lm_8h.html +++ b/docs/c/s2let__lm_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_lm.h File Reference +s2let: include/s2let_lm.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_lm.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -82,9 +132,9 @@ Functions - + - +
    double s2let_lm_power (S2LET_COMPLEX(double) *flm, int L)
     
    void s2let_lm_random_flm (S2LET_COMPLEX(double) *flm, int L, int spin, int seed)
    void s2let_lm_random_flm (S2LET_COMPLEX(double) *flm, int L, int spin, int seed)
     
    void s2let_lm_random_flm_real (S2LET_COMPLEX(double) *flm, int L, int seed)
    void s2let_lm_random_flm_real (S2LET_COMPLEX(double) *flm, int L, int seed)
     

    Function Documentation

    @@ -193,7 +243,7 @@

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__lm_8h__dep__incl.map b/docs/c/s2let__lm_8h__dep__incl.map new file mode 100644 index 00000000..ce5cecea --- /dev/null +++ b/docs/c/s2let__lm_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__lm_8h__dep__incl.md5 b/docs/c/s2let__lm_8h__dep__incl.md5 new file mode 100644 index 00000000..ce9041ff --- /dev/null +++ b/docs/c/s2let__lm_8h__dep__incl.md5 @@ -0,0 +1 @@ +51061e150c64346d41058cd75f6366f7 \ No newline at end of file diff --git a/docs/c/s2let__lm_8h__incl.map b/docs/c/s2let__lm_8h__incl.map new file mode 100644 index 00000000..21d6daba --- /dev/null +++ b/docs/c/s2let__lm_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__lm_8h__incl.md5 b/docs/c/s2let__lm_8h__incl.md5 new file mode 100644 index 00000000..375fe424 --- /dev/null +++ b/docs/c/s2let__lm_8h__incl.md5 @@ -0,0 +1 @@ +10215579db71ff27246960351b12a9f7 \ No newline at end of file diff --git a/docs/c/s2let__lm_8h_source.html b/docs/c/s2let__lm_8h_source.html index 9e9c2612..70b89c96 100644 --- a/docs/c/s2let__lm_8h_source.html +++ b/docs/c/s2let__lm_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_lm.h Source File +s2let: include/s2let_lm.h Source File @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -87,8 +87,8 @@
    13 
    14 double s2let_lm_power(S2LET_COMPLEX(double) *flm, int L);
    15 
    -
    16 void s2let_lm_random_flm(S2LET_COMPLEX(double) *flm, int L, int spin, int seed);
    -
    17 void s2let_lm_random_flm_real(S2LET_COMPLEX(double) *flm, int L, int seed);
    +
    16 void s2let_lm_random_flm(S2LET_COMPLEX(double) *flm, int L, int spin, int seed);
    +
    17 void s2let_lm_random_flm_real(S2LET_COMPLEX(double) *flm, int L, int seed);
    18 
    19 #ifdef __cplusplus
    20 }
    @@ -98,10 +98,11 @@
    s2let_lm_random_flm
    void s2let_lm_random_flm(S2LET_COMPLEX(double) *flm, int L, int spin, int seed)
    s2let_lm_power
    double s2let_lm_power(S2LET_COMPLEX(double) *flm, int L)
    s2let_lm_random_flm_real
    void s2let_lm_random_flm_real(S2LET_COMPLEX(double) *flm, int L, int seed)
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    seed
    const int seed
    Definition: test_adjoint.c:9
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__math_8c.html b/docs/c/s2let__math_8c.html index 20ba9404..e455b4a4 100644 --- a/docs/c/s2let__math_8c.html +++ b/docs/c/s2let__math_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_math.c File Reference +s2let: src/main/c/s2let_math.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,14 +74,48 @@
    s2let_math.c File Reference
    -
    #include "s2let.h"
    -#include <stdlib.h>
    +
    #include <math.h>
    #include <stdio.h>
    -#include <math.h>
    +#include <stdlib.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_math.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -123,8 +157,6 @@

    Computes cubis B-spline function

    -

    Definition at line 32 of file s2let_math.c.

    - @@ -174,8 +206,6 @@

    Definition at line 248 of file s2let_math.c.

    - @@ -195,8 +225,6 @@

    Tiling function for needlets

    -

    Definition at line 23 of file s2let_math.c.

    - @@ -226,8 +254,6 @@

    Tiling function for S2DW wavelets

    -

    Definition at line 14 of file s2let_math.c.

    - @@ -263,8 +289,6 @@

    Max absolute error between two real arrays

    -

    Definition at line 156 of file s2let_math.c.

    - @@ -300,8 +324,6 @@

    Max absolute error between two complex arrays

    -

    Definition at line 141 of file s2let_math.c.

    - @@ -321,8 +343,6 @@

    Random number from seed (Numerical Recipes).

    -

    Definition at line 104 of file s2let_math.c.

    - @@ -358,8 +378,6 @@

    Computes smooth "Schwartz" functions for needlets

    -

    Definition at line 80 of file s2let_math.c.

    - @@ -401,8 +419,6 @@

    Computes smooth "Schwartz" functions for scale-discretised wavelets

    -

    Definition at line 57 of file s2let_math.c.

    - @@ -432,14 +448,12 @@

    Computes spline scaling function

    -

    Definition at line 49 of file s2let_math.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__math_8c__incl.map b/docs/c/s2let__math_8c__incl.map new file mode 100644 index 00000000..e5ac5e60 --- /dev/null +++ b/docs/c/s2let__math_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__math_8c__incl.md5 b/docs/c/s2let__math_8c__incl.md5 new file mode 100644 index 00000000..daa4254c --- /dev/null +++ b/docs/c/s2let__math_8c__incl.md5 @@ -0,0 +1 @@ +a943e11100b1904de70c747dbed747d2 \ No newline at end of file diff --git a/docs/c/s2let__math_8c_source.html b/docs/c/s2let__math_8c_source.html deleted file mode 100644 index b478bb5f..00000000 --- a/docs/c/s2let__math_8c_source.html +++ /dev/null @@ -1,330 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_math.c Source File - - - - - - - - - -
    -
    -

    Functions

    double f_s2dw (double k, double B)
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_math.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <stdlib.h>
    -
    7 #include <stdio.h>
    -
    8 #include <math.h>
    -
    9 #include <time.h>
    -
    10 
    -
    14 double f_s2dw(double k, double B)
    -
    15 {
    -
    16  double t = (k - (1 / B)) * (2.0 * B / (B-1)) - 1;
    -
    17  return exp(-2.0 / (1.0 - pow(t, 2.0))) / k;
    -
    18 }
    -
    19 
    -
    23 double f_needlet(double t)
    -
    24 {
    -
    25  return exp(-1.0 / (1.0 - pow(t, 2.0))) ;
    -
    26 }
    -
    27 
    -
    28 
    -
    32 double b3_spline (double x)
    -
    33 {
    -
    34  if ( ABS(x) < 1e-16 ) return 0;
    -
    35  double A1,A2,A3,A4,A5,Val;
    -
    36  A1 = ABS ((x - 2) * (x - 2) * (x - 2));
    -
    37  A2 = ABS ((x - 1) * (x - 1) * (x - 1));
    -
    38  A3 = ABS (x * x * x);
    -
    39  A4 = ABS ((x + 1) * (x + 1) * (x + 1));
    -
    40  A5 = ABS ((x + 2) * (x + 2) * (x + 2));
    -
    41  Val = 1./12. * (A1 - 4. * A2 + 6. * A3 - 4. * A4 + A5);
    -
    42  fflush(NULL);
    -
    43  return Val;
    -
    44 }
    -
    45 
    -
    49 double s2let_math_spline_scalingfct(double x, double y){
    -
    50  double res = 1.5 * b3_spline(2.0 * x / y);
    -
    51  return res;
    -
    52 }
    -
    53 
    -
    57 double s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B)
    -
    58 {
    -
    59  double sum = 0;
    -
    60  double f1, f2;
    -
    61  int i;
    -
    62  double h = (b - a) / n;
    -
    63 
    -
    64  if( a == b ){
    -
    65  return 0;
    -
    66  }else{
    -
    67  for (i = 0; i < n; i++){
    -
    68  f1 = f_s2dw(a + i * h, B);
    -
    69  f2 = f_s2dw(a + (i + 1) * h, B);
    -
    70  if(!isnan(f1) && !isinf(f1) && !isnan(f2) && !isinf(f2))
    -
    71  sum += ((f1 + f2) * h) / 2;
    -
    72  }
    -
    73  }
    -
    74  return sum;
    -
    75 }
    -
    76 
    -
    80 double s2let_math_kappa0_quadtrap_needlet(double a, double b, int n)
    -
    81 {
    -
    82  double sum = 0;
    -
    83  double f1, f2;
    -
    84  int i;
    -
    85  double h = (b - a) / n;
    -
    86 
    -
    87  if( a == b ){
    -
    88  return 0;
    -
    89  }else{
    -
    90  for (i = 0; i < n; i++){
    -
    91  f1 = f_needlet(a + i * h);
    -
    92  f2 = f_needlet(a + (i + 1) * h);
    -
    93  if(!isnan(f1) && !isinf(f1) && !isnan(f2) && !isinf(f2))
    -
    94  sum += ((f1 + f2) * h) / 2;
    -
    95  }
    -
    96  }
    -
    97  return sum;
    -
    98 }
    -
    99 
    -
    100 
    -
    104 double ran2_dp(int idum) {
    -
    105  int IM1=2147483563,IM2=2147483399,IMM1=IM1-1,
    -
    106  IA1=40014,IA2=40692,IQ1=53668,IQ2=52774,IR1=12211,IR2=3791,
    -
    107  NTAB=32,NDIV=1+IMM1/NTAB;
    -
    108 
    -
    109  double AM=1./IM1,EPS=1.2e-7,RNMX=1.-EPS;
    -
    110  int j,k;
    -
    111  static int iv[32],iy,idum2 = 123456789;
    -
    112  // N.B. in C static variables are initialised to 0 by default.
    -
    113 
    -
    114  if (idum <= 0) {
    -
    115  idum= (-idum>1 ? -idum : 1); // max(-idum,1);
    -
    116  idum2=idum;
    -
    117  for(j=NTAB+8;j>=1;j--) {
    -
    118  k=idum/IQ1;
    -
    119  idum=IA1*(idum-k*IQ1)-k*IR1;
    -
    120  if (idum < 0) idum=idum+IM1;
    -
    121  if (j < NTAB) iv[j-1]=idum;
    -
    122  }
    -
    123  iy=iv[0];
    -
    124  }
    -
    125  k=idum/IQ1;
    -
    126  idum=IA1*(idum-k*IQ1)-k*IR1;
    -
    127  if (idum < 0) idum=idum+IM1;
    -
    128  k=idum2/IQ2;
    -
    129  idum2=IA2*(idum2-k*IQ2)-k*IR2;
    -
    130  if (idum2 < 0) idum2=idum2+IM2;
    -
    131  j=1+iy/NDIV;
    -
    132  iy=iv[j-1]-idum2;
    -
    133  iv[j-1]=idum;
    -
    134  if(iy < 1)iy=iy+IMM1;
    -
    135  return (AM*iy < RNMX ? AM*iy : RNMX); // min(AM*iy,RNMX);
    -
    136 }
    -
    137 
    -
    141 double maxerr_cplx(complex double *a, complex double *b, int size)
    -
    142 {
    -
    143  double value = 0;
    -
    144  int i;
    -
    145  for(i = 0; i<size; i++){
    -
    146  //if( cabs( a[i]-b[i] ) > 0.001 )
    -
    147  // printf("%f+i%f %f+i%f %f\n",creal(a[i]), cimag(a[i]), creal(b[i]), cimag(b[i]), cabs( a[i]-b[i] ));
    -
    148  value = MAX( cabs( a[i]-b[i] ), value );
    -
    149  }
    -
    150  return value;
    -
    151 }
    -
    152 
    -
    156 double maxerr(double *a, double *b, int size)
    -
    157 {
    -
    158  double value = 0;
    -
    159  int i;
    -
    160  for(i = 0; i<size; i++){
    -
    161  //printf("%f %f - ", a[i],b[i]);
    -
    162  value = MAX( abs( a[i]-b[i] ), value );
    -
    163  }
    -
    164  return value;
    -
    165 }
    -
    166 
    -
    167 
    -
    168 
    -
    173 static double logfact(int n)
    -
    174 {/*
    -
    175  double y, temp, sum, c[6], loggamma, x;
    -
    176  int nn;
    -
    177 
    -
    178  // The engine of this function actually calculates the gamma function,
    -
    179  // for which the real argument is x = n + 1.
    -
    180 
    -
    181  x = (double) (n) + 1.0;
    -
    182 
    -
    183  // Table of fitting constants.
    -
    184 
    -
    185  c[0] = 76.18009172947146;
    -
    186  c[1] = - 86.50532032941677;
    -
    187  c[2] = 24.01409824083091;
    -
    188  c[3] = - 1.231739572450155;
    -
    189  c[4] = 0.1208650973866179e-2;
    -
    190  c[5] = - 0.5395239384953e-5;
    -
    191 
    -
    192  // Add up fit.
    -
    193 
    -
    194  temp = x + 5.5 - (x + 0.5) * log(x + 5.5);
    -
    195  sum = 1.000000000190015;
    -
    196  y = x;
    -
    197 
    -
    198  for (nn=0; nn<=5; nn++) {
    -
    199  y = y + 1.0;
    -
    200  sum = sum + c[nn] / y;
    -
    201  }
    -
    202 
    -
    203  loggamma = - temp + log(2.5066282746310005 * sum / x);
    -
    204 
    -
    205  // Finally make explicit the conversion back to log of the factorial.
    -
    206  return loggamma;
    -
    207  */
    -
    208  double x, y, temp, sum;
    -
    209  int i;
    -
    210 
    -
    211  // Table of fitting constants
    -
    212  const double c[6] = {
    -
    213  76.18009172947146,
    -
    214  -86.50532032941677,
    -
    215  24.01409824083091,
    -
    216  -1.231739572450155,
    -
    217  0.1208650973866179e-2,
    -
    218  -0.5395239384953e-5
    -
    219  };
    -
    220 
    -
    221  // This actually calculates the gamma function,
    -
    222  // for which the real argument is x = n + 1.
    -
    223  x = n + 1.0;
    -
    224 
    -
    225  // Add up fit
    -
    226 
    -
    227  temp = x + 5.5 - (x + 0.5) * log(x + 5.5);
    -
    228  sum = 1.000000000190015;
    -
    229  y = x;
    -
    230 
    -
    231  for (i = 0; i < 6; ++i)
    -
    232  {
    -
    233  ++y;
    -
    234  sum = sum + c[i] / y;
    -
    235  }
    -
    236 
    -
    237  return -temp + log(2.5066282746310005 * sum / x);
    -
    238 }
    -
    239 
    -
    248 unsigned long binomial_coefficient(int n, int k, int exact)
    -
    249 {
    -
    250  if (!exact)
    -
    251  return floor(0.5 + exp(logfact(n) - logfact(k) - logfact(n - k)));
    -
    252 
    -
    255  unsigned long result = 1;
    -
    256  unsigned long i;
    -
    257 
    -
    258  // Avoid lengthy loops for large k, using the
    -
    259  // fact that (n,k) == (n,n-k).
    -
    260  if (k > n/2)
    -
    261  k = n - k;
    -
    262 
    -
    263  for (i = 1; i <= k; ++i)
    -
    264  {
    -
    265  // By interleaving the division and multiplication, we
    -
    266  // avoid intermediate results getting bigger than necessary.
    -
    267 
    -
    268  // We can do this without risking problems due to integer
    -
    269  // division: before dividing by i we will have multiplied
    -
    270  // by i consecutive integers, one of which has to be
    -
    271  // divisible by i.
    -
    272  result *= n - i + 1UL;
    -
    273  result /= i;
    -
    274  }
    -
    275 
    -
    276  return result;
    -
    277 }
    -
    -
    maxerr
    double maxerr(double *a, double *b, int size)
    Definition: s2let_math.c:156
    -
    s2let_math_kappa0_quadtrap_s2dw
    double s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B)
    Definition: s2let_math.c:57
    - -
    ABS
    #define ABS(a)
    Definition: s2let_math.h:13
    -
    s2let_math_kappa0_quadtrap_needlet
    double s2let_math_kappa0_quadtrap_needlet(double a, double b, int n)
    Definition: s2let_math.c:80
    -
    f_needlet
    double f_needlet(double t)
    Definition: s2let_math.c:23
    -
    maxerr_cplx
    double maxerr_cplx(complex double *a, complex double *b, int size)
    Definition: s2let_math.c:141
    -
    binomial_coefficient
    unsigned long binomial_coefficient(int n, int k, int exact)
    Definition: s2let_math.c:248
    -
    b3_spline
    double b3_spline(double x)
    Definition: s2let_math.c:32
    -
    ran2_dp
    double ran2_dp(int idum)
    Definition: s2let_math.c:104
    -
    MAX
    #define MAX(a, b)
    Definition: s2let_math.h:12
    -
    s2let_math_spline_scalingfct
    double s2let_math_spline_scalingfct(double x, double y)
    Definition: s2let_math.c:49
    -
    f_s2dw
    double f_s2dw(double k, double B)
    Definition: s2let_math.c:14
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__math_8h.html b/docs/c/s2let__math_8h.html index 509f0b91..f7a34036 100644 --- a/docs/c/s2let__math_8h.html +++ b/docs/c/s2let__math_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_math.h File Reference +s2let: include/s2let_math.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -76,6 +76,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_math.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -124,8 +174,6 @@

    -

    Definition at line 13 of file s2let_math.h.

    - @@ -154,8 +202,6 @@

    -

    Definition at line 12 of file s2let_math.h.

    - @@ -184,8 +230,6 @@

    -

    Definition at line 11 of file s2let_math.h.

    - @@ -200,8 +244,6 @@

    -

    Definition at line 9 of file s2let_math.h.

    -

    Function Documentation

    @@ -252,8 +294,6 @@

    Definition at line 248 of file s2let_math.c.

    - @@ -289,8 +329,6 @@

    Max absolute error between two real arrays

    -

    Definition at line 156 of file s2let_math.c.

    - @@ -344,8 +382,6 @@

    Random number from seed (Numerical Recipes).

    -

    Definition at line 104 of file s2let_math.c.

    - @@ -381,8 +417,6 @@

    Computes smooth "Schwartz" functions for needlets

    -

    Definition at line 80 of file s2let_math.c.

    - @@ -424,8 +458,6 @@

    Computes smooth "Schwartz" functions for scale-discretised wavelets

    -

    Definition at line 57 of file s2let_math.c.

    - @@ -455,14 +487,12 @@

    Computes spline scaling function

    -

    Definition at line 49 of file s2let_math.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__math_8h__dep__incl.map b/docs/c/s2let__math_8h__dep__incl.map new file mode 100644 index 00000000..28560dda --- /dev/null +++ b/docs/c/s2let__math_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__math_8h__dep__incl.md5 b/docs/c/s2let__math_8h__dep__incl.md5 new file mode 100644 index 00000000..58b29df9 --- /dev/null +++ b/docs/c/s2let__math_8h__dep__incl.md5 @@ -0,0 +1 @@ +0bbd0bd4b023eeb8a3ae41734f47ffd8 \ No newline at end of file diff --git a/docs/c/s2let__math_8h__incl.map b/docs/c/s2let__math_8h__incl.map new file mode 100644 index 00000000..14e0465f --- /dev/null +++ b/docs/c/s2let__math_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__math_8h__incl.md5 b/docs/c/s2let__math_8h__incl.md5 new file mode 100644 index 00000000..6c07d748 --- /dev/null +++ b/docs/c/s2let__math_8h__incl.md5 @@ -0,0 +1 @@ +9aab85b3baaf799e7c4454200cd53217 \ No newline at end of file diff --git a/docs/c/s2let__math_8h_source.html b/docs/c/s2let__math_8h_source.html index bab3fa6a..6b6b3c41 100644 --- a/docs/c/s2let__math_8h_source.html +++ b/docs/c/s2let__math_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_math.h Source File +s2let: include/s2let_math.h Source File @@ -22,10 +22,10 @@

    @@ -110,17 +110,17 @@
    36 
    37 #endif
    -
    s2let_math_spline_scalingfct
    double s2let_math_spline_scalingfct(double x, double y)
    Definition: s2let_math.c:49
    -
    s2let_math_kappa0_quadtrap_needlet
    double s2let_math_kappa0_quadtrap_needlet(double a, double b, int n)
    Definition: s2let_math.c:80
    -
    ran2_dp
    double ran2_dp(int idum)
    Definition: s2let_math.c:104
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    -
    s2let_math_kappa0_quadtrap_s2dw
    double s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B)
    Definition: s2let_math.c:57
    +
    s2let_math_spline_scalingfct
    double s2let_math_spline_scalingfct(double x, double y)
    Definition: s2let_math.c:45
    +
    s2let_math_kappa0_quadtrap_needlet
    double s2let_math_kappa0_quadtrap_needlet(double a, double b, int n)
    Definition: s2let_math.c:75
    +
    ran2_dp
    double ran2_dp(int idum)
    Definition: s2let_math.c:97
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    s2let_math_kappa0_quadtrap_s2dw
    double s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B)
    Definition: s2let_math.c:53
    maxerr_cplx
    double maxerr_cplx(S2LET_COMPLEX(double) *a, S2LET_COMPLEX(double) *b, int size)
    -
    binomial_coefficient
    unsigned long binomial_coefficient(int n, int k, int exact)
    Definition: s2let_math.c:248
    -
    maxerr
    double maxerr(double *a, double *b, int size)
    Definition: s2let_math.c:156
    +
    binomial_coefficient
    unsigned long binomial_coefficient(int n, int k, int exact)
    Definition: s2let_math.c:241
    +
    maxerr
    double maxerr(double *a, double *b, int size)
    Definition: s2let_math.c:154
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__mex_8h.html b/docs/c/s2let__mex_8h.html index 05cead5e..bdf7628a 100644 --- a/docs/c/s2let__mex_8h.html +++ b/docs/c/s2let__mex_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_mex.h File Reference +s2let: include/s2let_mex.h File Reference @@ -22,10 +22,10 @@ @@ -99,8 +99,6 @@

    -

    Definition at line 5 of file s2let_mex.h.

    - @@ -115,8 +113,6 @@

    -

    Definition at line 4 of file s2let_mex.h.

    - @@ -131,14 +127,12 @@

    -

    Definition at line 7 of file s2let_mex.h.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__mex_8h_source.html b/docs/c/s2let__mex_8h_source.html index 1ac85c5b..1b7b402d 100644 --- a/docs/c/s2let__mex_8h_source.html +++ b/docs/c/s2let__mex_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_mex.h Source File +s2let: include/s2let_mex.h Source File @@ -22,10 +22,10 @@

    @@ -85,7 +85,7 @@
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__mw_8c.html b/docs/c/s2let__mw_8c.html index a8e620ec..5a8e74af 100644 --- a/docs/c/s2let__mw_8c.html +++ b/docs/c/s2let__mw_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_mw.c File Reference +s2let: src/main/c/s2let_mw.c File Reference @@ -22,10 +22,10 @@ @@ -74,14 +74,48 @@
    s2let_mw.c File Reference
    -
    #include "s2let.h"
    -#include <complex.h>
    +
    #include <complex.h>
    +#include <math.h>
    #include <ssht/ssht.h>
    #include <stdlib.h>
    -#include <math.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_mw.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    @@ -151,8 +185,6 @@

    Definition at line 20 of file s2let_mw.c.

    - @@ -202,8 +234,6 @@

    Definition at line 50 of file s2let_mw.c.

    - @@ -259,8 +289,6 @@

    Definition at line 35 of file s2let_mw.c.

    - @@ -310,8 +338,6 @@

    Definition at line 65 of file s2let_mw.c.

    - @@ -341,8 +367,6 @@

    Computes power of a complex MW signal

    -

    Definition at line 74 of file s2let_mw.c.

    - @@ -372,14 +396,12 @@

    Computes power of a real MW signal

    -

    Definition at line 86 of file s2let_mw.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__mw_8c__incl.map b/docs/c/s2let__mw_8c__incl.map new file mode 100644 index 00000000..ce17ce0a --- /dev/null +++ b/docs/c/s2let__mw_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__mw_8c__incl.md5 b/docs/c/s2let__mw_8c__incl.md5 new file mode 100644 index 00000000..92857e17 --- /dev/null +++ b/docs/c/s2let__mw_8c__incl.md5 @@ -0,0 +1 @@ +87331512468610b826bed4794bed12fd \ No newline at end of file diff --git a/docs/c/s2let__mw_8c_source.html b/docs/c/s2let__mw_8c_source.html deleted file mode 100644 index 9495e08a..00000000 --- a/docs/c/s2let__mw_8c_source.html +++ /dev/null @@ -1,141 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_mw.c Source File - - - - - - - - - -
    -
    -

    Functions

    void s2let_mw_alm2map (complex double *f, const complex double *flm, int L, int spin)
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_mw.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <complex.h>
    -
    7 #include <ssht/ssht.h>
    -
    8 #include <stdlib.h>
    -
    9 #include <math.h>
    -
    10 
    -
    20 void s2let_mw_alm2map(complex double* f, const complex double* flm, int L, int spin) {
    -
    21  int verbosity = 0;
    -
    22  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    23  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    24 }
    -
    25 
    -
    35 void s2let_mw_map2alm(complex double* flm, const complex double* f, int L, int spin) {
    -
    36  int verbosity = 0;
    -
    37  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    38  ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity);
    -
    39 }
    -
    40 
    -
    50 void s2let_mw_alm2map_real(double* f, const complex double* flm, int L) {
    -
    51  int verbosity = 0;
    -
    52  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    53  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    54 }
    -
    55 
    -
    65 void s2let_mw_map2alm_real(complex double* flm, const double* f, int L) {
    -
    66  int verbosity = 0;
    -
    67  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    68  ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity);
    -
    69 }
    -
    70 
    -
    74 double s2let_mw_power(complex double *f, int L){
    -
    75  complex double *flm;
    -
    76  s2let_allocate_lm(&flm, L);
    -
    77  s2let_mw_map2alm(flm, f, L, 0);
    -
    78  double res = s2let_lm_power(flm, L);
    -
    79  free(flm);
    -
    80  return res;
    -
    81 }
    -
    82 
    -
    86 double s2let_mw_power_real(double *f, int L){
    -
    87  complex double *flm;
    -
    88  s2let_allocate_lm(&flm, L);
    -
    89  s2let_mw_map2alm_real(flm, f, L);
    -
    90  double res = s2let_lm_power(flm, L);
    -
    91  free(flm);
    -
    92  return res;
    -
    93 }
    -
    -
    s2let_mw_map2alm
    void s2let_mw_map2alm(complex double *flm, const complex double *f, int L, int spin)
    Definition: s2let_mw.c:35
    -
    s2let_lm_power
    double s2let_lm_power(complex double *flm, int L)
    Definition: s2let_lm.c:16
    -
    s2let_mw_alm2map
    void s2let_mw_alm2map(complex double *f, const complex double *flm, int L, int spin)
    Definition: s2let_mw.c:20
    - -
    s2let_mw_map2alm_real
    void s2let_mw_map2alm_real(complex double *flm, const double *f, int L)
    Definition: s2let_mw.c:65
    -
    s2let_mw_power_real
    double s2let_mw_power_real(double *f, int L)
    Definition: s2let_mw.c:86
    -
    s2let_mw_alm2map_real
    void s2let_mw_alm2map_real(double *f, const complex double *flm, int L)
    Definition: s2let_mw.c:50
    -
    s2let_mw_power
    double s2let_mw_power(complex double *f, int L)
    Definition: s2let_mw.c:74
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__mw_8h.html b/docs/c/s2let__mw_8h.html index 63def1a1..354ae12d 100644 --- a/docs/c/s2let__mw_8h.html +++ b/docs/c/s2let__mw_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_mw.h File Reference +s2let: include/s2let_mw.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_mw.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -299,14 +349,12 @@

    Computes power of a real MW signal

    -

    Definition at line 86 of file s2let_mw.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__mw_8h__dep__incl.map b/docs/c/s2let__mw_8h__dep__incl.map new file mode 100644 index 00000000..cebcb3b5 --- /dev/null +++ b/docs/c/s2let__mw_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__mw_8h__dep__incl.md5 b/docs/c/s2let__mw_8h__dep__incl.md5 new file mode 100644 index 00000000..29d7bc9f --- /dev/null +++ b/docs/c/s2let__mw_8h__dep__incl.md5 @@ -0,0 +1 @@ +76a720e867393e17573c7c5d5f3bbd97 \ No newline at end of file diff --git a/docs/c/s2let__mw_8h__incl.map b/docs/c/s2let__mw_8h__incl.map new file mode 100644 index 00000000..7e1102c7 --- /dev/null +++ b/docs/c/s2let__mw_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__mw_8h__incl.md5 b/docs/c/s2let__mw_8h__incl.md5 new file mode 100644 index 00000000..05e7f901 --- /dev/null +++ b/docs/c/s2let__mw_8h__incl.md5 @@ -0,0 +1 @@ +c2c0ec031971d651c6e7658ce7d30fd7 \ No newline at end of file diff --git a/docs/c/s2let__mw_8h_source.html b/docs/c/s2let__mw_8h_source.html index 1f8c8892..29eeae29 100644 --- a/docs/c/s2let__mw_8h_source.html +++ b/docs/c/s2let__mw_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_mw.h Source File +s2let: include/s2let_mw.h Source File @@ -22,10 +22,10 @@

    @@ -98,16 +98,16 @@
    26 #endif
    27 #endif
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    s2let_mw_alm2map
    void s2let_mw_alm2map(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *flm, int L, int spin)
    -
    s2let_mw_power_real
    double s2let_mw_power_real(double *flm, int L)
    Definition: s2let_mw.c:86
    +
    s2let_mw_power_real
    double s2let_mw_power_real(double *flm, int L)
    Definition: s2let_mw.c:87
    s2let_mw_map2alm_real
    void s2let_mw_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int L)
    s2let_mw_power
    double s2let_mw_power(S2LET_COMPLEX(double) *flm, int L)
    s2let_mw_map2alm
    void s2let_mw_map2alm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f, int L, int spin)
    s2let_mw_alm2map_real
    void s2let_mw_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int L)
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__so3_8h.html b/docs/c/s2let__so3_8h.html index 3ffe4a1d..97527d2f 100644 --- a/docs/c/s2let__so3_8h.html +++ b/docs/c/s2let__so3_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_so3.h File Reference +s2let: include/s2let_so3.h File Reference @@ -22,10 +22,10 @@ @@ -76,6 +76,57 @@
    #include <so3/so3.h>
    #include <time.h>
    +
    +Include dependency graph for s2let_so3.h:
    +
    +
    + + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -99,8 +150,6 @@

    -

    Definition at line 13 of file s2let_so3.h.

    - @@ -115,14 +164,12 @@

    -

    Definition at line 14 of file s2let_so3.h.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__so3_8h__dep__incl.map b/docs/c/s2let__so3_8h__dep__incl.map new file mode 100644 index 00000000..61bc4f45 --- /dev/null +++ b/docs/c/s2let__so3_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__so3_8h__dep__incl.md5 b/docs/c/s2let__so3_8h__dep__incl.md5 new file mode 100644 index 00000000..b93d5a52 --- /dev/null +++ b/docs/c/s2let__so3_8h__dep__incl.md5 @@ -0,0 +1 @@ +1e8564989b3b598ebde9a94026b7e256 \ No newline at end of file diff --git a/docs/c/s2let__so3_8h__incl.map b/docs/c/s2let__so3_8h__incl.map new file mode 100644 index 00000000..1e53ddb8 --- /dev/null +++ b/docs/c/s2let__so3_8h__incl.map @@ -0,0 +1,5 @@ + + + + + diff --git a/docs/c/s2let__so3_8h__incl.md5 b/docs/c/s2let__so3_8h__incl.md5 new file mode 100644 index 00000000..3fbf1f19 --- /dev/null +++ b/docs/c/s2let__so3_8h__incl.md5 @@ -0,0 +1 @@ +5baa4e0700a415df1bb66a83b3ab15db \ No newline at end of file diff --git a/docs/c/s2let__so3_8h_source.html b/docs/c/s2let__so3_8h_source.html index 20cf4d52..4ab3921e 100644 --- a/docs/c/s2let__so3_8h_source.html +++ b/docs/c/s2let__so3_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_so3.h Source File +s2let: include/s2let_so3.h Source File @@ -22,10 +22,10 @@

    @@ -137,18 +137,18 @@
    67 #endif
    68 #endif
    -
    s2let_parameters_t::verbosity
    int verbosity
    Definition: s2let_types.h:61
    -
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    -
    S2LET_SO3_N_ORDER
    #define S2LET_SO3_N_ORDER
    Definition: s2let_so3.h:13
    -
    s2let_parameters_t::reality
    int reality
    Definition: s2let_types.h:70
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    S2LET_SO3_STORAGE
    #define S2LET_SO3_STORAGE
    Definition: s2let_so3.h:14
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    +
    s2let_parameters_t::verbosity
    int verbosity
    Definition: s2let_types.h:61
    +
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    +
    S2LET_SO3_N_ORDER
    #define S2LET_SO3_N_ORDER
    Definition: s2let_so3.h:13
    +
    s2let_parameters_t::reality
    int reality
    Definition: s2let_types.h:70
    +
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    +
    S2LET_SO3_STORAGE
    #define S2LET_SO3_STORAGE
    Definition: s2let_so3.h:14
    +
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__spin__denoising__demo_8c.html b/docs/c/s2let__spin__denoising__demo_8c.html index 05926772..e10dc47c 100644 --- a/docs/c/s2let__spin__denoising__demo_8c.html +++ b/docs/c/s2let__spin__denoising__demo_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_spin_denoising_demo.c File Reference +s2let: src/main/c/s2let_spin_denoising_demo.c File Reference @@ -22,10 +22,10 @@ @@ -74,20 +74,56 @@
    s2let_spin_denoising_demo.c File Reference
    -
    #include "s2let.h"
    -#include <assert.h>
    +
    #include <assert.h>
    #include <complex.h>
    +#include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    -#include <math.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_spin_denoising_demo.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    - + @@ -130,8 +166,6 @@

    -

    Definition at line 29 of file s2let_spin_denoising_demo.c.

    - @@ -161,8 +195,6 @@

    PROGRAM : s2let_spin_denoising_demo COMMAND : bin/s2let_spin_denoising_demo ARGUMENTS : none

    -

    Definition at line 55 of file s2let_spin_denoising_demo.c.

    - @@ -209,8 +241,6 @@

    -

    Definition at line 14 of file s2let_spin_denoising_demo.c.

    - @@ -241,14 +271,12 @@

    Definition at line 21 of file s2let_spin_denoising_demo.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__spin__denoising__demo_8c__incl.map b/docs/c/s2let__spin__denoising__demo_8c__incl.map new file mode 100644 index 00000000..287f787f --- /dev/null +++ b/docs/c/s2let__spin__denoising__demo_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__spin__denoising__demo_8c__incl.md5 b/docs/c/s2let__spin__denoising__demo_8c__incl.md5 new file mode 100644 index 00000000..3df45b64 --- /dev/null +++ b/docs/c/s2let__spin__denoising__demo_8c__incl.md5 @@ -0,0 +1 @@ +502bf8beec9dbc0663816d15fd7f24f8 \ No newline at end of file diff --git a/docs/c/s2let__spin__denoising__demo_8c_source.html b/docs/c/s2let__spin__denoising__demo_8c_source.html deleted file mode 100644 index 8eefbd29..00000000 --- a/docs/c/s2let__spin__denoising__demo_8c_source.html +++ /dev/null @@ -1,378 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_spin_denoising_demo.c Source File - - - - - - - - - -
    -
    -

    Functions

    void s2let_lm_random_flm_sigma (complex double *flm, int L, int spin, int seed, double sigmanoise)
    void s2let_lm_random_flm_sigma (complex double *flm, int L, int spin, int seed, double sigmanoise)
     
    double waveletpower (complex double *wav_lm, int L)
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ More...
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -

    -
    -
    -
    s2let_spin_denoising_demo.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <assert.h>
    -
    7 #include <complex.h>
    -
    8 #include <stdio.h>
    -
    9 #include <stdlib.h>
    -
    10 #include <string.h>
    -
    11 #include <math.h>
    -
    12 #include <time.h>
    -
    13 
    -
    14 void s2let_lm_random_flm_sigma(complex double *flm, int L, int spin, int seed, double sigmanoise) {
    -
    15  int i;
    -
    16  int i_min = spin*spin;
    -
    17  for (i=i_min; i<L*L; ++i)
    -
    18  flm[i] = sigmanoise * (2.0*ran2_dp(seed) - 1.0) + I * sigmanoise * (2.0*ran2_dp(seed) - 1.0);
    -
    19 }
    -
    20 
    -
    21 double waveletpower(complex double *wav_lm, int L){
    -
    22  int i;
    -
    23  double totalpower = 0;
    -
    24  for(i = 0; i < L*L; i++)
    -
    25  totalpower += wav_lm[i] * conj(wav_lm[i]);
    -
    26  return totalpower;
    -
    27 }
    -
    28 
    -
    29 void hard_threshold(
    -
    30  complex double *g_wav,
    -
    31  const double *threshold,
    -
    32  const s2let_parameters_t *parameters
    -
    33 ) {
    -
    34  int L = parameters->L;
    -
    35  int J_min = parameters->J_min;
    -
    36  int N = parameters->N;
    -
    37 
    -
    38  int J = s2let_j_max(parameters);
    -
    39  int i, j, offset = 0;
    -
    40  for(j = J_min; j <= J; j++){
    -
    41  int bl = parameters->upsample ? L : MIN(s2let_bandlimit(j, parameters), L);
    -
    42  for(i = 0; i < N*bl*(2*bl-1); i++){
    -
    43  if( cabs(g_wav[offset + i]) < threshold[j-J_min] )
    -
    44  g_wav[offset + i] = 0;
    -
    45  }
    -
    46  offset += N*bl*(2*bl-1);
    -
    47  }
    -
    48 }
    -
    49 
    -
    55 int main(int argc, char *argv[])
    -
    56 {
    -
    57  int i, j;
    -
    58  s2let_parameters_t parameters = {};
    -
    59 
    -
    60  const int seed = (int)(10000.0*(double)clock()/(double)CLOCKS_PER_SEC);
    -
    61  // PARAMETERS
    -
    62  const double SNR_in = 10.0; // Input SNR
    -
    63  const int nsigma = 3; // Number of sigmas for hard thresholding
    -
    64  const int upsample = 0; // Multiresolution flag
    -
    65  const double B = 2; // Wavelet parameters
    -
    66  const int N = 4; // Azimuthal band-limit
    -
    67  const int J_min = 0; // First wavelet scale to use
    -
    68  const int spin = 2; // Spin number
    -
    69 
    -
    70  char outfile[100];
    -
    71  complex double *flm, *f, *noise, *g, *g_wav, *g_scal, *f_denoised, *remaining_noise;
    -
    72  double *f_hpx_r, *f_hpx_i,
    -
    73  *f_r, *f_i,
    -
    74  *noise_r, *noise_i,
    -
    75  *f_denoised_r, *f_denoised_i,
    -
    76  *g_r, *g_i,
    -
    77  *scal_l;
    -
    78  complex double *noise_lm, *wav_lm;
    -
    79 
    -
    80  parameters.B = B;
    -
    81  parameters.J_min = J_min;
    -
    82  parameters.N = N;
    -
    83  parameters.spin = spin;
    -
    84  parameters.upsample = upsample;
    -
    85 
    -
    86  printf("--------------------------------------------------\n");
    -
    87  printf(" S2LET library : denoising example\n");
    -
    88  printf(" Earth tomography signal, MW sampling\n");
    -
    89  printf("--------------------------------------------------\n");
    -
    90 
    -
    91  // Commented out code uses a real map and converts it to
    -
    92  // a spin map
    -
    93 
    -
    94  //char file[100] = "data/earth_tomo_mw_128_rot.fits";
    -
    95  char fileQ[100] = "data/wmap_mcmc_fs_k_synch_stk_q_9yr_v5_rot_mw.fits";
    -
    96  char fileU[100] = "data/wmap_mcmc_fs_k_synch_stk_u_9yr_v5_rot_mw.fits";
    -
    97  //printf(" Reading file %s\n", file);
    -
    98  printf(" Reading file %s\n", fileQ);
    -
    99  printf(" Reading file %s\n", fileU);
    -
    100  const int L = s2let_fits_mw_read_bandlimit(fileQ);
    -
    101  //const int nside = s2let_fits_hpx_read_nside(fileQ);
    -
    102  //int L = MIN(192,3*nside);
    -
    103  parameters.L = L;
    -
    104  printf(" - Detected bandlimit L = %i\n",L);
    -
    105  int J = s2let_j_max(&parameters);
    -
    106  printf(" Parameters for wavelet denoising :\n");
    -
    107  s2let_switch_wavtype(1);
    -
    108  printf(" - Input SNR : %f\n",SNR_in);
    -
    109  printf(" - Sigma threshold : %i\n", nsigma);
    -
    110  printf(" - upsample flag : %i\n", upsample);
    -
    111  printf(" - Wavelet parameter : %i\n", B);
    -
    112  printf(" - Total number of wavelets : %i\n", J);
    -
    113  printf(" - First wavelet scale to be used : %i\n", J_min);
    -
    114 
    -
    115  //s2let_allocate_mw_real(&f_r, L);
    -
    116  //s2let_fits_mw_read_map(f_r, file, L); // Read MW map from file
    -
    117  //s2let_hpx_allocate_real(&f_hpx_r, nside);
    -
    118  //s2let_hpx_allocate_real(&f_hpx_i, nside);
    -
    119  //s2let_hpx_read_map(f_hpx_r, fileQ, nside);
    -
    120  //s2let_hpx_read_map(f_hpx_i, fileU, nside);
    -
    121  //printf(" Map successfully read from file\n");
    -
    122 
    -
    123  // Force into spin signal
    -
    124  // s2let_allocate_lm(&flm, L);
    -
    125  // s2let_mw_map2alm_real(flm, f_r, L);
    -
    126  // for (i = 0; i < spin*spin; ++i)
    -
    127  // flm[i] = 0;
    -
    128  // s2let_allocate_mw(&f, L);
    -
    129  // int verbosity = 0;
    -
    130  // ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    131  // ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    132 
    -
    133  // Convert to MW sampling
    -
    134  s2let_allocate_mw_real(&f_r, L);
    -
    135  s2let_allocate_mw_real(&f_i, L);
    -
    136  s2let_fits_mw_read_map(f_r, fileQ, L);
    -
    137  s2let_fits_mw_read_map(f_i, fileU, L);
    -
    138  //s2let_allocate_lm(&flm, L);
    -
    139  //s2let_hpx_map2alm_real(flm, f_hpx_r, nside, L);
    -
    140  //s2let_mw_alm2map_real(f_r, flm, L);
    -
    141  //s2let_hpx_map2alm_real(flm, f_hpx_i, nside, L);
    -
    142  //s2let_mw_alm2map_real(f_i, flm, L);
    -
    143 
    -
    144  s2let_allocate_mw(&f, L);
    -
    145  for (i = 0; i < L*(2*L-1); ++i)
    -
    146  f[i] = f_r[i] + I*f_i[i];
    -
    147  //free(flm);
    -
    148  //free(f_hpx_r);
    -
    149  //free(f_hpx_i);
    -
    150 
    -
    151  // Compute noise standard deviation and generate noise
    -
    152  double sigmanoise = sqrt(pow(10.0, -SNR_in/10.0) * s2let_mw_power(f, L));
    -
    153  printf(" - Std dev of the noise (to match SNR) = %f\n", sigmanoise);
    -
    154  s2let_allocate_lm(&noise_lm, L);
    -
    155  s2let_lm_random_flm_sigma(noise_lm, L, spin, seed, sigmanoise);
    -
    156  double SNR_actual = 10.0 * log10( s2let_mw_power(f, L) / s2let_lm_power(noise_lm, L));
    -
    157  printf(" - Actual (realised) SNR = %f\n", SNR_actual);
    -
    158 
    -
    159  // Add noise to the signal in real space
    -
    160  printf(" Contaminating the signal with this noise...");fflush(NULL);
    -
    161  s2let_allocate_mw(&noise, L);
    -
    162  s2let_mw_alm2map(noise, noise_lm, L, 0);
    -
    163  s2let_allocate_mw(&g, L);
    -
    164  for (i = 0; i < L*(2*L-1); i++)
    -
    165  g[i] = f[i] + noise[i];
    -
    166  printf(" done\n");
    -
    167 
    -
    168  printf(" Performing wavelet decomposition...");fflush(NULL);
    -
    169  // Perform wavelet analysis from scratch with all signals given as MW maps
    -
    170  s2let_allocate_f_wav(&g_wav, &g_scal, &parameters);
    -
    171  s2let_analysis_px2wav(g_wav, g_scal, g, &parameters);
    -
    172  printf(" done\n");
    -
    173 
    -
    174  // Compute simple threshold for needlet coefficients based on noise model
    -
    175  printf(" Construct the threshold rule for the Gaussian noise\n");
    -
    176  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &parameters);
    -
    177  s2let_tiling_wavelet(wav_lm, scal_l, &parameters);
    -
    178  double *threshold = (double*)calloc((J-J_min+1), sizeof(double));
    -
    179  for(j = J_min; j <= J; j++)
    -
    180  threshold[j-J_min] = sigmanoise * nsigma * sqrt(waveletpower(wav_lm + j * L*L, L));
    -
    181 
    -
    182  printf(" Hard thresholding the wavelets...");fflush(NULL);
    -
    183  s2let_allocate_mw(&f_denoised, L);
    -
    184  hard_threshold(g_wav, threshold, &parameters);
    -
    185  s2let_synthesis_wav2px(f_denoised, g_wav, g_scal, &parameters);
    -
    186  printf(" done\n");
    -
    187 
    -
    188  // Remaining noise
    -
    189  s2let_allocate_mw(&remaining_noise, L);
    -
    190  for(i = 0; i < L*(2*L-1); i++)
    -
    191  remaining_noise[i] = f_denoised[i] - f[i];
    -
    192 
    -
    193  // SNR after denoising
    -
    194  double SNR_denoised = 10.0 * log10( s2let_mw_power(f, L) / s2let_mw_power(remaining_noise, L));
    -
    195  printf(" -> SNR before denoising = %f\n", SNR_actual);
    -
    196  printf(" -> SNR after denoising = %f\n", SNR_denoised);
    -
    197 
    -
    198  // Finally write the denoised signal
    -
    199  s2let_allocate_mw_real(&noise_r, L);
    -
    200  s2let_allocate_mw_real(&noise_i, L);
    -
    201  s2let_allocate_mw_real(&g_r, L);
    -
    202  s2let_allocate_mw_real(&g_i, L);
    -
    203  s2let_allocate_mw_real(&f_denoised_r, L);
    -
    204  s2let_allocate_mw_real(&f_denoised_i, L);
    -
    205  for (i = 0; i < L*(2*L-1); ++i)
    -
    206  {
    -
    207  noise_r[i] = creal(noise[i]);
    -
    208  noise_i[i] = cimag(noise[i]);
    -
    209  g_r[i] = creal(g[i]);
    -
    210  g_i[i] = cimag(g[i]);
    -
    211  f_denoised_r[i] = creal(f_denoised[i]);
    -
    212  f_denoised_i[i] = cimag(f_denoised[i]);
    -
    213  }
    -
    214  printf(" Write output files\n");
    -
    215  sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_input" , ".fits");
    -
    216  printf(" Outfile = %s\n", outfile);
    -
    217  remove(outfile); // In case the file exists
    -
    218  s2let_fits_mw_write_map(outfile, f_r, L); // Now write the map to fits file
    -
    219  sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_input" , ".fits");
    -
    220  printf(" Outfile = %s\n", outfile);
    -
    221  remove(outfile); // In case the file exists
    -
    222  s2let_fits_mw_write_map(outfile, f_i, L); // Now write the map to fits file
    -
    223 
    -
    224  sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_noise" , ".fits");
    -
    225  printf(" Outfile = %s\n", outfile);
    -
    226  remove(outfile); // In case the file exists
    -
    227  s2let_fits_mw_write_map(outfile, noise_r, L); // Now write the map to fits file
    -
    228  sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_noise" , ".fits");
    -
    229  printf(" Outfile = %s\n", outfile);
    -
    230  remove(outfile); // In case the file exists
    -
    231  s2let_fits_mw_write_map(outfile, noise_i, L); // Now write the map to fits file
    -
    232 
    -
    233  sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_input_noise" , ".fits");
    -
    234  printf(" Outfile = %s\n", outfile);
    -
    235  remove(outfile); // In case the file exists
    -
    236  s2let_fits_mw_write_map(outfile, g_r, L); // Now write the map to fits file
    -
    237  sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_input_noise" , ".fits");
    -
    238  printf(" Outfile = %s\n", outfile);
    -
    239  remove(outfile); // In case the file exists
    -
    240  s2let_fits_mw_write_map(outfile, g_i, L); // Now write the map to fits file
    -
    241 
    -
    242  sprintf(outfile, "%s%s%s", "data/spin_signal_real", "_denoised", ".fits");
    -
    243  printf(" Outfile = %s\n", outfile);
    -
    244  remove(outfile); // In case the file exists
    -
    245  s2let_fits_mw_write_map(outfile, f_denoised_r, L); // Now write the map to fits file
    -
    246  sprintf(outfile, "%s%s%s", "data/spin_signal_imag", "_denoised", ".fits");
    -
    247  printf(" Outfile = %s\n", outfile);
    -
    248  remove(outfile); // In case the file exists
    -
    249  s2let_fits_mw_write_map(outfile, f_denoised_i, L); // Now write the map to fits file
    -
    250 
    -
    251  free(f);
    -
    252  free(f_r);
    -
    253  free(f_i);
    -
    254  free(f_denoised);
    -
    255  free(f_denoised_r);
    -
    256  free(f_denoised_i);
    -
    257  free(noise);
    -
    258  free(noise_r);
    -
    259  free(noise_i);
    -
    260  free(g);
    -
    261  free(g_r);
    -
    262  free(g_i);
    -
    263  free(g_wav);
    -
    264  free(g_scal);
    -
    265  free(scal_l);
    -
    266  free(remaining_noise);
    -
    267  free(noise_lm);
    -
    268 
    -
    269  printf("--------------------------------------------------\n");
    -
    270  return 0;
    -
    271 }
    -
    -
    s2let_allocate_mw
    void s2let_allocate_mw(complex double **f, int L)
    Definition: s2let_alloc.c:18
    -
    s2let_lm_power
    double s2let_lm_power(complex double *flm, int L)
    Definition: s2let_lm.c:16
    -
    s2let_analysis_px2wav
    void s2let_analysis_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:498
    -
    s2let_mw_alm2map
    void s2let_mw_alm2map(complex double *f, const complex double *flm, int L, int spin)
    Definition: s2let_mw.c:20
    -
    s2let_tiling_wavelet_allocate
    void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:339
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    waveletpower
    double waveletpower(complex double *wav_lm, int L)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_spin_denoising_demo.c:21
    -
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_allocate_mw_real
    void s2let_allocate_mw_real(double **f, int L)
    Definition: s2let_alloc.c:28
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_spin_denoising_demo.c:55
    -
    s2let_switch_wavtype
    void s2let_switch_wavtype(int typenum)
    Definition: s2let_tiling.c:23
    -
    hard_threshold
    void hard_threshold(complex double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    Definition: s2let_spin_denoising_demo.c:29
    -
    s2let_fits_mw_read_bandlimit
    int s2let_fits_mw_read_bandlimit(char *filename)
    Definition: s2let_fits.c:18
    -
    s2let_tiling_wavelet
    void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:388
    -
    s2let_fits_mw_write_map
    void s2let_fits_mw_write_map(char *filename, double *f, int L)
    Definition: s2let_fits.c:98
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_lm_random_flm_sigma
    void s2let_lm_random_flm_sigma(complex double *flm, int L, int spin, int seed, double sigmanoise)
    Definition: s2let_spin_denoising_demo.c:14
    -
    s2let_fits_mw_read_map
    void s2let_fits_mw_read_map(double *f, char *filename, int L)
    Definition: s2let_fits.c:207
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_mw_power
    double s2let_mw_power(complex double *f, int L)
    Definition: s2let_mw.c:74
    -
    s2let_allocate_f_wav
    void s2let_allocate_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:105
    -
    ran2_dp
    double ran2_dp(int idum)
    Definition: s2let_math.c:104
    -
    s2let_synthesis_wav2px
    void s2let_synthesis_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:520
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__synthesis_8c.html b/docs/c/s2let__synthesis_8c.html index 6d65aa43..2478a77a 100644 --- a/docs/c/s2let__synthesis_8c.html +++ b/docs/c/s2let__synthesis_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_synthesis.c File Reference +s2let: src/main/c/s2let_synthesis.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,16 +74,50 @@
    s2let_synthesis.c File Reference
    -
    #include "s2let.h"
    +
    #include <complex.h>
    +#include <math.h>
    #include <so3/so3.h>
    #include <ssht/ssht.h>
    -#include <complex.h>
    -#include <math.h>
    -#include <stdlib.h>
    #include <stdio.h>
    +#include <stdlib.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_synthesis.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -155,11 +189,11 @@

    Parameters

    Functions

    void s2let_synthesis_lmn2lm (complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    - - - - - + + + + +
    [out]flmSpherical harmonic coefficients of input function.
    [in]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_synthesis_lmn2lm_real instead for real signals.
    [in]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_synthesis_lmn2lm_real instead for real signals.
    @@ -170,8 +204,6 @@

    Definition at line 27 of file s2let_synthesis.c.

    -

    @@ -227,11 +259,11 @@

    Parameters
    - - - - - + + + + +
    [out]flmSpherical harmonic coefficients of input function.
    [in]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_synthesis_lmn2lm instead for complex signals.
    [in]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_synthesis_lmn2lm instead for complex signals.
    @@ -242,8 +274,6 @@

    Definition at line 114 of file s2let_synthesis.c.

    -

    @@ -300,8 +330,6 @@

    Definition at line 338 of file s2let_synthesis.c.

    - @@ -407,8 +435,6 @@

    Definition at line 225 of file s2let_synthesis.c.

    - @@ -465,8 +491,6 @@

    Definition at line 428 of file s2let_synthesis.c.

    - @@ -523,8 +547,6 @@

    Definition at line 520 of file s2let_synthesis.c.

    - @@ -581,14 +603,12 @@

    Definition at line 563 of file s2let_synthesis.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__synthesis_8c__incl.map b/docs/c/s2let__synthesis_8c__incl.map new file mode 100644 index 00000000..f9254953 --- /dev/null +++ b/docs/c/s2let__synthesis_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__synthesis_8c__incl.md5 b/docs/c/s2let__synthesis_8c__incl.md5 new file mode 100644 index 00000000..8623ef99 --- /dev/null +++ b/docs/c/s2let__synthesis_8c__incl.md5 @@ -0,0 +1 @@ +f22b4a35e69559b2c8a7ed4cf840d643 \ No newline at end of file diff --git a/docs/c/s2let__synthesis_8c_source.html b/docs/c/s2let__synthesis_8c_source.html deleted file mode 100644 index 33136db5..00000000 --- a/docs/c/s2let__synthesis_8c_source.html +++ /dev/null @@ -1,603 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_synthesis.c Source File - - - - - - - - - -
    -
    - - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_synthesis.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <so3/so3.h>
    -
    7 #include <ssht/ssht.h>
    -
    8 #include <complex.h>
    -
    9 #include <math.h>
    -
    10 #include <stdlib.h>
    -
    11 #include <stdio.h>
    -
    12 
    -
    27 void s2let_synthesis_lmn2lm(
    -
    28  complex double *flm,
    -
    29  const complex double *f_wav_lmn,
    -
    30  const complex double *f_scal_lm,
    -
    31  const complex double *wav_lm,
    -
    32  const double *scal_l,
    -
    33  const s2let_parameters_t *parameters
    -
    34 ) {
    -
    35  int L = parameters->L;
    -
    36  int J_min = parameters->J_min;
    -
    37  int N = parameters->N;
    -
    38  int spin = parameters->spin;
    -
    39 
    -
    40  int j, el, m ,n;
    -
    41  int J = s2let_j_max(parameters);
    -
    42  int bandlimit = L;
    -
    43  int Nj = N;
    -
    44 
    -
    45  int lm_ind, lmn_ind;
    -
    46  so3_parameters_t so3_parameters = {};
    -
    47  fill_so3_parameters(&so3_parameters, parameters);
    -
    48 
    -
    49  complex double psi;
    -
    50  double phi;
    -
    51 
    -
    52  int offset = 0;
    -
    53 
    -
    54  // Clear output
    -
    55  for (el = 0; el < L*L; ++el)
    -
    56  flm[el] = 0;
    -
    57 
    -
    58  for (j = J_min; j <= J; ++j)
    -
    59  {
    -
    60  if (!parameters->upsample)
    -
    61  {
    -
    62  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    63  so3_parameters.L = bandlimit;
    -
    64  int Nj = MIN(N,bandlimit);
    -
    65  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    66  so3_parameters.N = Nj;
    -
    67  }
    -
    68 
    -
    69  for (n = -Nj+1; n < Nj; n+=2)
    -
    70  {
    -
    71  for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el)
    -
    72  {
    -
    73  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    74  psi = wav_lm[j*L*L + lm_ind];
    -
    75  for (m = -el; m <= el; ++m)
    -
    76  {
    -
    77  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    78  so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters);
    -
    79  flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi;
    -
    80  }
    -
    81  }
    -
    82  }
    -
    83  offset += so3_sampling_flmn_size(&so3_parameters);
    -
    84  }
    -
    85 
    -
    86  if (!parameters->upsample)
    -
    87  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    88 
    -
    89  for (el = ABS(spin); el < bandlimit; ++el)
    -
    90  {
    -
    91  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    92  for (m = -el; m <= el; ++m)
    -
    93  {
    -
    94  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    95  flm[lm_ind] += f_scal_lm[lm_ind] * phi;
    -
    96  }
    -
    97  }
    -
    98 }
    -
    99 
    -
    114 void s2let_synthesis_lmn2lm_real(
    -
    115  complex double *flm,
    -
    116  const complex double *f_wav_lmn,
    -
    117  const complex double *f_scal_lm,
    -
    118  const complex double *wav_lm,
    -
    119  const double *scal_l,
    -
    120  const s2let_parameters_t *parameters
    -
    121 ) {
    -
    122  int L = parameters->L;
    -
    123  int J_min = parameters->J_min;
    -
    124  int N = parameters->N;
    -
    125 
    -
    126  int j, el, m ,n;
    -
    127  int J = s2let_j_max(parameters);
    -
    128  int bandlimit = L;
    -
    129  int Nj = N;
    -
    130 
    -
    131  int lm_ind, lmn_ind;
    -
    132  so3_parameters_t so3_parameters = {};
    -
    133  fill_so3_parameters(&so3_parameters, parameters);
    -
    134 
    -
    135  complex double psi, npsi;
    -
    136  double phi;
    -
    137 
    -
    138  int offset = 0;
    -
    139 
    -
    140  // Clear output
    -
    141  for (el = 0; el < L*L; ++el)
    -
    142  flm[el] = 0;
    -
    143 
    -
    144  for (j = J_min; j <= J; ++j)
    -
    145  {
    -
    146  if (!parameters->upsample)
    -
    147  {
    -
    148  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    149  so3_parameters.L = bandlimit;
    -
    150  int Nj = MIN(N,bandlimit);
    -
    151  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    152  so3_parameters.N = Nj;
    -
    153  }
    -
    154 
    -
    155  for (n = 1-Nj%2; n < Nj; n+=2)
    -
    156  {
    -
    157  for (el = n; el < bandlimit; ++el)
    -
    158  {
    -
    159  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    160  psi = wav_lm[j*L*L + lm_ind];
    -
    161 
    -
    162  if (n)
    -
    163  {
    -
    164  ssht_sampling_elm2ind(&lm_ind, el, -n);
    -
    165  npsi = wav_lm[j*L*L + lm_ind];
    -
    166  }
    -
    167 
    -
    168  for (m = -el; m <= el; ++m)
    -
    169  {
    -
    170  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    171  so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters);
    -
    172  flm[lm_ind] += f_wav_lmn[offset + lmn_ind] * psi;
    -
    173 
    -
    174  if (n)
    -
    175  {
    -
    176  so3_sampling_elmn2ind_real(&lmn_ind, el, -m, n, &so3_parameters);
    -
    177  int sign = (m+n)%2 ? -1 : 1;
    -
    178  flm[lm_ind] += sign * conj(f_wav_lmn[offset + lmn_ind]) * npsi;
    -
    179  }
    -
    180  }
    -
    181  }
    -
    182  }
    -
    183  offset += so3_sampling_flmn_size(&so3_parameters);
    -
    184  }
    -
    185 
    -
    186  if (!parameters->upsample)
    -
    187  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    188 
    -
    189  for (el = 0; el < bandlimit; ++el)
    -
    190  {
    -
    191  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    192  for (m = -el; m <= el; ++m)
    -
    193  {
    -
    194  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    195  flm[lm_ind] += f_scal_lm[lm_ind] * phi;
    -
    196  }
    -
    197  }
    -
    198 }
    -
    199 
    -
    225 void s2let_synthesis_wav2lm_manual(
    -
    226  complex double *flm,
    -
    227  const complex double *f_wav,
    -
    228  const complex double *f_scal,
    -
    229  const double *scal_l,
    -
    230  const complex double *wav_lm,
    -
    231  const int scal_bandlimit,
    -
    232  const int *wav_bandlimits,
    -
    233  int J,
    -
    234  int L,
    -
    235  int spin,
    -
    236  int N
    -
    237 ) {
    -
    238  s2let_parameters_t parameters = {};
    -
    239  parameters.L = L;
    -
    240  parameters.J_min = 0;
    -
    241  parameters.B = pow(L, 1.0/(float)J);
    -
    242  parameters.N = N;
    -
    243  parameters.dl_method = SSHT_DL_RISBO;
    -
    244 
    -
    245  int bandlimit = L;
    -
    246  int verbosity = 0;
    -
    247  so3_parameters_t so3_parameters = {};
    -
    248  fill_so3_parameters(&so3_parameters, &parameters);
    -
    249 
    -
    250  int j, offset;
    -
    251  complex double *f_wav_lmn, *f_scal_lm;
    -
    252  complex double psi;
    -
    253  double phi;
    -
    254  int el, m, n, lm_ind, lmn_ind;
    -
    255 
    -
    256  bandlimit = MIN(scal_bandlimit, L);
    -
    257 
    -
    258  f_scal_lm = (complex double*)calloc(bandlimit*bandlimit, sizeof(complex double));
    -
    259 
    -
    260  // Note, this is a spin-0 transform!
    -
    261  switch (parameters.sampling_scheme)
    -
    262  {
    -
    263  case S2LET_SAMPLING_MW:
    -
    264  ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity);
    -
    265  break;
    -
    266  case S2LET_SAMPLING_MW_SS:
    -
    267  ssht_core_mw_forward_sov_conv_sym_ss(f_scal_lm, f_scal, bandlimit, 0, parameters.dl_method, verbosity);
    -
    268  break;
    -
    269  default:
    -
    270  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    271  }
    -
    272 
    -
    273  for (el = ABS(spin); el < bandlimit; ++el)
    -
    274  {
    -
    275  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    276  for (m = -el; m <= el; ++m)
    -
    277  {
    -
    278  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    279  flm[lm_ind] += f_scal_lm[lm_ind] * phi;
    -
    280  }
    -
    281  }
    -
    282 
    -
    283  free(f_scal_lm);
    -
    284 
    -
    285  offset = 0;
    -
    286  for (j = 0; j <= J; ++j)
    -
    287  {
    -
    288  bandlimit = MIN(wav_bandlimits[j], L);
    -
    289  so3_parameters.L = bandlimit;
    -
    290  int Nj = MIN(N,bandlimit);
    -
    291  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    292  so3_parameters.N = Nj;
    -
    293  so3_parameters.L0 = 0;
    -
    294 
    -
    295  f_wav_lmn = (complex double*)calloc(so3_sampling_flmn_size(&so3_parameters), sizeof(complex double));
    -
    296 
    -
    297  so3_core_forward_direct(
    -
    298  f_wav_lmn,
    -
    299  f_wav + offset,
    -
    300  &so3_parameters
    -
    301  );
    -
    302 
    -
    303  for (n = -Nj+1; n < Nj; n+=2)
    -
    304  {
    -
    305  for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el)
    -
    306  {
    -
    307  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    308  psi = wav_lm[j*L*L + lm_ind];
    -
    309  for (m = -el; m <= el; ++m)
    -
    310  {
    -
    311  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    312  so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters);
    -
    313  flm[lm_ind] += f_wav_lmn[lmn_ind] * psi;
    -
    314  }
    -
    315  }
    -
    316  }
    -
    317 
    -
    318  free(f_wav_lmn);
    -
    319  offset += so3_sampling_f_size(&so3_parameters);
    -
    320 
    -
    321  }
    -
    322 
    -
    323 }
    -
    324 
    -
    325 
    -
    338 void s2let_synthesis_wav2lm(
    -
    339  complex double *flm,
    -
    340  const complex double *f_wav,
    -
    341  const complex double *f_scal,
    -
    342  const s2let_parameters_t *parameters
    -
    343 ) {
    -
    344  int L = parameters->L;
    -
    345  int J_min = parameters->J_min;
    -
    346  int N = parameters->N;
    -
    347  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    348 
    -
    349  int bandlimit = L;
    -
    350  int verbosity = 0;
    -
    351  so3_parameters_t so3_parameters = {};
    -
    352  fill_so3_parameters(&so3_parameters, parameters);
    -
    353 
    -
    354  int j, offset, offset_lmn;
    -
    355  int J = s2let_j_max(parameters);
    -
    356 
    -
    357  complex double *wav_lm;
    -
    358  double *scal_l;
    -
    359  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters);
    -
    360  s2let_tiling_wavelet(wav_lm, scal_l, parameters);
    -
    361 
    -
    362  complex double *f_wav_lmn, *f_scal_lm;
    -
    363  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters);
    -
    364 
    -
    365  if (!parameters->upsample)
    -
    366  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    367 
    -
    368  // Note, this is a spin-0 transform!
    -
    369  switch (parameters->sampling_scheme)
    -
    370  {
    -
    371  case S2LET_SAMPLING_MW:
    -
    372  ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity);
    -
    373  break;
    -
    374  case S2LET_SAMPLING_MW_SS:
    -
    375  ssht_core_mw_forward_sov_conv_sym_ss(f_scal_lm, f_scal, bandlimit, 0, dl_method, verbosity);
    -
    376  break;
    -
    377  default:
    -
    378  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    379  }
    -
    380 
    -
    381  offset = 0;
    -
    382  offset_lmn = 0;
    -
    383  for (j = J_min; j <= J; ++j)
    -
    384  {
    -
    385  if (!parameters->upsample)
    -
    386  {
    -
    387  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    388  so3_parameters.L = bandlimit;
    -
    389  int Nj = MIN(N,bandlimit);
    -
    390  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    391  so3_parameters.N = Nj;
    -
    392  }
    -
    393 
    -
    394  so3_parameters.L0 = s2let_L0(j, parameters);
    -
    395 
    -
    396 
    -
    397 // so3_adjoint_inverse_direct(
    -
    398 // so3_core_forward_direct(
    -
    399  so3_core_forward_via_ssht(
    -
    400  f_wav_lmn + offset_lmn,
    -
    401  f_wav + offset,
    -
    402  &so3_parameters
    -
    403  );
    -
    404  offset_lmn += so3_sampling_flmn_size(&so3_parameters);
    -
    405  offset += so3_sampling_f_size(&so3_parameters);
    -
    406  }
    -
    407 
    -
    408  s2let_synthesis_lmn2lm(flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, parameters);
    -
    409 
    -
    410  free(wav_lm);
    -
    411  free(scal_l);
    -
    412  free(f_scal_lm);
    -
    413  free(f_wav_lmn);
    -
    414 }
    -
    415 
    -
    428 void s2let_synthesis_wav2lm_real(
    -
    429  complex double *flm,
    -
    430  const double *f_wav,
    -
    431  const double *f_scal,
    -
    432  const s2let_parameters_t *parameters
    -
    433 ) {
    -
    434  int L = parameters->L;
    -
    435  int J_min = parameters->J_min;
    -
    436  int N = parameters->N;
    -
    437  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    438 
    -
    439  s2let_parameters_t real_parameters = *parameters;
    -
    440  real_parameters.reality = 1;
    -
    441 
    -
    442  int bandlimit = L;
    -
    443  int verbosity = 0;
    -
    444  so3_parameters_t so3_parameters = {};
    -
    445  fill_so3_parameters(&so3_parameters, &real_parameters);
    -
    446 
    -
    447  int j, offset, offset_lmn;
    -
    448  int J = s2let_j_max(&real_parameters);
    -
    449 
    -
    450  complex double *wav_lm;
    -
    451  double *scal_l;
    -
    452  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters);
    -
    453  s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters);
    -
    454 
    -
    455  complex double *f_wav_lmn, *f_scal_lm;
    -
    456  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters);
    -
    457 
    -
    458  if (!parameters->upsample)
    -
    459  bandlimit = MIN(s2let_bandlimit(J_min-1, &real_parameters), L);
    -
    460 
    -
    461  switch (parameters->sampling_scheme)
    -
    462  {
    -
    463  case S2LET_SAMPLING_MW:
    -
    464  ssht_core_mw_forward_sov_conv_sym_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity);
    -
    465  break;
    -
    466  case S2LET_SAMPLING_MW_SS:
    -
    467  ssht_core_mw_forward_sov_conv_sym_ss_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity);
    -
    468  break;
    -
    469  default:
    -
    470  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    471  }
    -
    472 
    -
    473 
    -
    474  offset = 0;
    -
    475  offset_lmn = 0;
    -
    476  for (j = J_min; j <= J; ++j)
    -
    477  {
    -
    478  if (!parameters->upsample)
    -
    479  {
    -
    480  bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L);
    -
    481  so3_parameters.L = bandlimit;
    -
    482  int Nj = MIN(N,bandlimit);
    -
    483  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    484  so3_parameters.N = Nj;
    -
    485  }
    -
    486 
    -
    487  so3_parameters.L0 = s2let_L0(j, parameters);
    -
    488 
    -
    489  so3_core_forward_via_ssht_real(
    -
    490  f_wav_lmn + offset_lmn,
    -
    491  f_wav + offset,
    -
    492  &so3_parameters
    -
    493  );
    -
    494 
    -
    495  offset_lmn += so3_sampling_flmn_size(&so3_parameters);
    -
    496  offset += so3_sampling_f_size(&so3_parameters);
    -
    497  }
    -
    498 
    -
    499  s2let_synthesis_lmn2lm_real(
    -
    500  flm, f_wav_lmn, f_scal_lm, wav_lm, scal_l, &real_parameters);
    -
    501 
    -
    502  free(wav_lm);
    -
    503  free(scal_l);
    -
    504  free(f_scal_lm);
    -
    505  free(f_wav_lmn);
    -
    506 }
    -
    507 
    -
    520 void s2let_synthesis_wav2px(
    -
    521  complex double *f,
    -
    522  const complex double *f_wav,
    -
    523  const complex double *f_scal,
    -
    524  const s2let_parameters_t *parameters
    -
    525 ) {
    -
    526  int L = parameters->L;
    -
    527  int spin = parameters->spin;
    -
    528  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    529  int verbosity = 0;
    -
    530 
    -
    531  complex double *flm;
    -
    532  s2let_allocate_lm(&flm, L);
    -
    533 
    -
    534  s2let_synthesis_wav2lm(flm, f_wav, f_scal, parameters);
    -
    535 
    -
    536  switch (parameters->sampling_scheme)
    -
    537  {
    -
    538  case S2LET_SAMPLING_MW:
    -
    539  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    540  break;
    -
    541  case S2LET_SAMPLING_MW_SS:
    -
    542  ssht_core_mw_inverse_sov_sym_ss(f, flm, L, spin, dl_method, verbosity);
    -
    543  break;
    -
    544  default:
    -
    545  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    546  }
    -
    547 
    -
    548  free(flm);
    -
    549 }
    -
    550 
    -
    563 void s2let_synthesis_wav2px_real(
    -
    564  double *f,
    -
    565  const double *f_wav,
    -
    566  const double *f_scal,
    -
    567  const s2let_parameters_t *parameters
    -
    568 ) {
    -
    569  int L = parameters->L;
    -
    570  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    571  int verbosity = 0;
    -
    572 
    -
    573  complex double *flm;
    -
    574  s2let_allocate_lm(&flm, L);
    -
    575 
    -
    576  s2let_synthesis_wav2lm_real(flm, f_wav, f_scal, parameters);
    -
    577 
    -
    578  switch (parameters->sampling_scheme)
    -
    579  {
    -
    580  case S2LET_SAMPLING_MW:
    -
    581  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    582  break;
    -
    583  case S2LET_SAMPLING_MW_SS:
    -
    584  ssht_core_mw_inverse_sov_sym_ss_real(f, flm, L, dl_method, verbosity);
    -
    585  break;
    -
    586  default:
    -
    587  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    588  }
    -
    589 
    -
    590  free(flm);
    -
    591 }
    -
    -
    s2let_synthesis_wav2lm_real
    void s2let_synthesis_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:428
    -
    s2let_synthesis_wav2lm_manual
    void s2let_synthesis_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    Definition: s2let_synthesis.c:225
    -
    s2let_synthesis_wav2lm
    void s2let_synthesis_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:338
    -
    s2let_synthesis_wav2px_real
    void s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:563
    -
    s2let_tiling_wavelet_allocate
    void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:339
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    - -
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    ABS
    #define ABS(a)
    Definition: s2let_math.h:13
    -
    s2let_allocate_lmn_f_wav
    void s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:82
    -
    S2LET_ERROR_GENERIC
    #define S2LET_ERROR_GENERIC(comment)
    Definition: s2let_error.h:13
    -
    S2LET_SAMPLING_MW_SS
    @ S2LET_SAMPLING_MW_SS
    Definition: s2let_types.h:32
    -
    s2let_synthesis_lmn2lm_real
    void s2let_synthesis_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:114
    -
    s2let_tiling_wavelet
    void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:388
    -
    s2let_parameters_t::reality
    int reality
    Definition: s2let_types.h:70
    -
    PI
    #define PI
    Definition: s2let_math.h:9
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_L0
    int s2let_L0(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:83
    -
    s2let_synthesis_lmn2lm
    void s2let_synthesis_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:27
    -
    MAX
    #define MAX(a, b)
    Definition: s2let_math.h:12
    -
    s2let_synthesis_wav2px
    void s2let_synthesis_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:520
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    -
    S2LET_SAMPLING_MW
    @ S2LET_SAMPLING_MW
    Definition: s2let_types.h:25
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__synthesis_8h.html b/docs/c/s2let__synthesis_8h.html index 33411904..4b809e73 100644 --- a/docs/c/s2let__synthesis_8h.html +++ b/docs/c/s2let__synthesis_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_synthesis.h File Reference +s2let: include/s2let_synthesis.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_synthesis.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -462,14 +512,12 @@

    Definition at line 563 of file s2let_synthesis.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__synthesis_8h__dep__incl.map b/docs/c/s2let__synthesis_8h__dep__incl.map new file mode 100644 index 00000000..9393b2ce --- /dev/null +++ b/docs/c/s2let__synthesis_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__synthesis_8h__dep__incl.md5 b/docs/c/s2let__synthesis_8h__dep__incl.md5 new file mode 100644 index 00000000..2b991662 --- /dev/null +++ b/docs/c/s2let__synthesis_8h__dep__incl.md5 @@ -0,0 +1 @@ +6c746741d56910ee6acee9898c2c375d \ No newline at end of file diff --git a/docs/c/s2let__synthesis_8h__incl.map b/docs/c/s2let__synthesis_8h__incl.map new file mode 100644 index 00000000..0287d1e9 --- /dev/null +++ b/docs/c/s2let__synthesis_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__synthesis_8h__incl.md5 b/docs/c/s2let__synthesis_8h__incl.md5 new file mode 100644 index 00000000..03b9867a --- /dev/null +++ b/docs/c/s2let__synthesis_8h__incl.md5 @@ -0,0 +1 @@ +3e1b7662d90611c656bf096dfcd0f067 \ No newline at end of file diff --git a/docs/c/s2let__synthesis_8h_source.html b/docs/c/s2let__synthesis_8h_source.html index c9898ff0..7df1bbe7 100644 --- a/docs/c/s2let__synthesis_8h_source.html +++ b/docs/c/s2let__synthesis_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_synthesis.h Source File +s2let: include/s2let_synthesis.h Source File @@ -22,10 +22,10 @@

    @@ -144,17 +144,17 @@
    82 #endif
    s2let_synthesis_wav2px
    void s2let_synthesis_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters)
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    s2let_synthesis_lmn2lm_real
    void s2let_synthesis_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    s2let_synthesis_wav2lm_real
    void s2let_synthesis_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    s2let_synthesis_wav2lm_manual
    void s2let_synthesis_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    -
    s2let_synthesis_wav2px_real
    void s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:563
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_synthesis_wav2px_real
    void s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:513
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    s2let_synthesis_wav2lm
    void s2let_synthesis_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters)
    s2let_synthesis_lmn2lm
    void s2let_synthesis_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__synthesis__adjoint_8c.html b/docs/c/s2let__synthesis__adjoint_8c.html index d8598aa1..f6a6b9fc 100644 --- a/docs/c/s2let__synthesis__adjoint_8c.html +++ b/docs/c/s2let__synthesis__adjoint_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_synthesis_adjoint.c File Reference +s2let: src/main/c/s2let_synthesis_adjoint.c File Reference @@ -22,10 +22,10 @@ @@ -74,16 +74,50 @@
    s2let_synthesis_adjoint.c File Reference
    -
    #include "s2let.h"
    +
    #include <complex.h>
    +#include <math.h>
    #include <so3/so3.h>
    #include <ssht/ssht.h>
    -#include <complex.h>
    -#include <math.h>
    -#include <stdlib.h>
    #include <stdio.h>
    +#include <stdlib.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_synthesis_adjoint.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    @@ -155,9 +189,9 @@

    Parameters

    Functions

    void s2let_synthesis_adjoint_lm2lmn (complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    - - - + + + @@ -171,8 +205,6 @@

    Definition at line 27 of file s2let_synthesis_adjoint.c.

    - @@ -227,12 +259,12 @@

    Parameters

    [out]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (Spherical harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic coefficients of input function.
    [out]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (Spherical harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic coefficients of input function.
    [in]wav_lmWavelet kernels in harmonic space.
    [in]scal_lScaling function kernels in harmonic space.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_analysis_lm2lmn_real instead for real signals.
    - - - - - - + + + + + +
    [out]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic coefficients of input function.
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_analysis_lm2lmn instead for complex signals.
    [out]f_wav_lmnWavelet transform (Wigner coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (spherical harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic coefficients of input function.
    [in]wav_lmWavelet kernels.
    [in]scal_lScaling function kernels.
    [in]parametersA fully populated parameters object. The reality flag is ignored. Use s2let_analysis_lm2lmn instead for complex signals.
    @@ -243,8 +275,6 @@

    Definition at line 113 of file s2let_synthesis_adjoint.c.

    -

    @@ -301,8 +331,6 @@

    Definition at line 325 of file s2let_synthesis_adjoint.c.

    - @@ -408,8 +436,6 @@

    Definition at line 208 of file s2let_synthesis_adjoint.c.

    - @@ -466,8 +492,6 @@

    Definition at line 415 of file s2let_synthesis_adjoint.c.

    - @@ -524,8 +548,6 @@

    Definition at line 504 of file s2let_synthesis_adjoint.c.

    - @@ -584,14 +606,12 @@

    Definition at line 547 of file s2let_synthesis_adjoint.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__synthesis__adjoint_8c__incl.map b/docs/c/s2let__synthesis__adjoint_8c__incl.map new file mode 100644 index 00000000..ea6a0641 --- /dev/null +++ b/docs/c/s2let__synthesis__adjoint_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__synthesis__adjoint_8c__incl.md5 b/docs/c/s2let__synthesis__adjoint_8c__incl.md5 new file mode 100644 index 00000000..b5a99105 --- /dev/null +++ b/docs/c/s2let__synthesis__adjoint_8c__incl.md5 @@ -0,0 +1 @@ +1d83ba4f93cacfad117bf10829c088ef \ No newline at end of file diff --git a/docs/c/s2let__synthesis__adjoint_8c_source.html b/docs/c/s2let__synthesis__adjoint_8c_source.html deleted file mode 100644 index bb14047c..00000000 --- a/docs/c/s2let__synthesis__adjoint_8c_source.html +++ /dev/null @@ -1,588 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_synthesis_adjoint.c Source File - - - - - - - - - -
    -
    - - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_synthesis_adjoint.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <so3/so3.h>
    -
    7 #include <ssht/ssht.h>
    -
    8 #include <complex.h>
    -
    9 #include <math.h>
    -
    10 #include <stdlib.h>
    -
    11 #include <stdio.h>
    -
    12 
    -
    27 void s2let_synthesis_adjoint_lm2lmn(
    -
    28  complex double *f_wav_lmn,
    -
    29  complex double *f_scal_lm,
    -
    30  const complex double *flm,
    -
    31  const complex double *wav_lm,
    -
    32  const double *scal_l,
    -
    33  const s2let_parameters_t *parameters
    -
    34 ) {
    -
    35  int L = parameters->L;
    -
    36  int J_min = parameters->J_min;
    -
    37  int N = parameters->N;
    -
    38  int spin = parameters->spin;
    -
    39 
    -
    40  int j, el, m ,n;
    -
    41  int J = s2let_j_max(parameters);
    -
    42  int bandlimit = L;
    -
    43  int Nj = N;
    -
    44 
    -
    45  int lm_ind, lmn_ind;
    -
    46  so3_parameters_t so3_parameters = {};
    -
    47  fill_so3_parameters(&so3_parameters, parameters);
    -
    48 
    -
    49  complex double psi;
    -
    50  double phi;
    -
    51 
    -
    52  int offset = 0;
    -
    53 
    -
    54  for (j = J_min; j <= J; ++j)
    -
    55  {
    -
    56 
    -
    57  if (!parameters->upsample)
    -
    58  {
    -
    59  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    60  so3_parameters.L = bandlimit;
    -
    61  Nj = MIN(N,bandlimit);
    -
    62  // ensure N and Nj are both even or both odd
    -
    63  Nj += (Nj+N)%2;
    -
    64  so3_parameters.N = Nj;
    -
    65  }
    -
    66 
    -
    67  for (n = -Nj+1; n < Nj; n+=2)
    -
    68  {
    -
    69  for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el)
    -
    70  {
    -
    71  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    72  psi = conj(wav_lm[j*L*L + lm_ind]);
    -
    73 
    -
    74  for (m = -el; m <= el; ++m)
    -
    75  {
    -
    76  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    77  so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters);
    -
    78  f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi;
    -
    79  }
    -
    80  }
    -
    81  }
    -
    82  offset += so3_sampling_flmn_size(&so3_parameters);
    -
    83  }
    -
    84 
    -
    85  if (!parameters->upsample)
    -
    86  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    87 
    -
    88  for (el = ABS(spin); el < bandlimit; ++el)
    -
    89  {
    -
    90  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    91  for (m = -el; m <= el; ++m)
    -
    92  {
    -
    93  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    94  f_scal_lm[lm_ind] = flm[lm_ind] * phi;
    -
    95  }
    -
    96  }
    -
    97 }
    -
    98 
    -
    113 void s2let_synthesis_adjoint_lm2lmn_real(
    -
    114  complex double *f_wav_lmn,
    -
    115  complex double *f_scal_lm,
    -
    116  const complex double *flm,
    -
    117  const complex double *wav_lm,
    -
    118  const double *scal_l,
    -
    119  const s2let_parameters_t *parameters
    -
    120 ) {
    -
    121  int L = parameters->L;
    -
    122  int J_min = parameters->J_min;
    -
    123  int N = parameters->N;
    -
    124 
    -
    125  int j, el, m ,n;
    -
    126  int J = s2let_j_max(parameters);
    -
    127  int bandlimit = L;
    -
    128  int Nj = N;
    -
    129 
    -
    130  int lm_ind, lmn_ind;
    -
    131  so3_parameters_t so3_parameters = {};
    -
    132  fill_so3_parameters(&so3_parameters, parameters);
    -
    133 
    -
    134  complex double psi;
    -
    135  double phi;
    -
    136 
    -
    137  int offset = 0;
    -
    138 
    -
    139  for (j = J_min; j <= J; ++j)
    -
    140  {
    -
    141  if (!parameters->upsample)
    -
    142  {
    -
    143  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    144  so3_parameters.L = bandlimit;
    -
    145  int Nj = MIN(N,bandlimit);
    -
    146  // ensure N and Nj are both even or both odd
    -
    147  Nj += (Nj+N)%2;
    -
    148  so3_parameters.N = Nj;
    -
    149  }
    -
    150 
    -
    151  for (n = 1-Nj%2; n < Nj; n+=2)
    -
    152  {
    -
    153  for (el = n; el < bandlimit; ++el)
    -
    154  {
    -
    155  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    156  psi = conj(wav_lm[j*L*L + lm_ind]);
    -
    157  for (m = -el; m <= el; ++m)
    -
    158  {
    -
    159  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    160  so3_sampling_elmn2ind_real(&lmn_ind, el, m, n, &so3_parameters);
    -
    161  f_wav_lmn[offset + lmn_ind] = flm[lm_ind] * psi;
    -
    162  }
    -
    163  }
    -
    164  }
    -
    165  offset += so3_sampling_flmn_size(&so3_parameters);
    -
    166  }
    -
    167 
    -
    168  if (!parameters->upsample)
    -
    169  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    170 
    -
    171  for (el = 0; el < bandlimit; ++el)
    -
    172  {
    -
    173  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    174  for (m = -el; m <= el; ++m)
    -
    175  {
    -
    176  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    177  f_scal_lm[lm_ind] = flm[lm_ind] * phi;
    -
    178  }
    -
    179  }
    -
    180 }
    -
    181 
    -
    182 
    -
    208 void s2let_synthesis_adjoint_lm2wav_manual(
    -
    209  complex double *f_wav,
    -
    210  complex double *f_scal,
    -
    211  const complex double *flm,
    -
    212  const double *scal_l,
    -
    213  const complex double *wav_lm,
    -
    214  const int scal_bandlimit,
    -
    215  const int *wav_bandlimits,
    -
    216  int J,
    -
    217  int L,
    -
    218  int spin,
    -
    219  int N
    -
    220 ) {
    -
    221  s2let_parameters_t parameters = {};
    -
    222  parameters.L = L;
    -
    223  parameters.J_min = 0;
    -
    224  parameters.B = pow(L, 1.0/(float)(J+2));
    -
    225  parameters.N = N;
    -
    226  parameters.dl_method = SSHT_DL_RISBO;
    -
    227  printf("J = %i\n", J);
    -
    228  printf("B = %g\n", parameters.B);
    -
    229  printf("N = %i\n", parameters.N);
    -
    230  printf("L = %i\n", parameters.L);
    -
    231 
    -
    232  int bandlimit = L;
    -
    233  int verbosity = 0;
    -
    234  so3_parameters_t so3_parameters = {};
    -
    235  fill_so3_parameters(&so3_parameters, &parameters);
    -
    236 
    -
    237  int j, offset, offset_lmn;
    -
    238  complex double *f_wav_lmn, *f_scal_lm;
    -
    239  complex double psi, npsi;
    -
    240  double phi;
    -
    241  int el, m, n, lm_ind, lmn_ind;
    -
    242 
    -
    243  int Nj = N;
    -
    244 
    -
    245  bandlimit = MIN(scal_bandlimit, L);
    -
    246  f_scal_lm = (complex double*)calloc(bandlimit*bandlimit, sizeof(complex double));
    -
    247 
    -
    248  for (el = ABS(spin); el < bandlimit; ++el)
    -
    249  {
    -
    250  phi = sqrt(4.0*PI/(2*el+1)) * scal_l[el];
    -
    251  for (m = -el; m <= el; ++m)
    -
    252  {
    -
    253  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    254  f_scal_lm[lm_ind] = flm[lm_ind] * phi;
    -
    255  }
    -
    256  }
    -
    257 
    -
    258  switch (parameters.sampling_scheme)
    -
    259  {
    -
    260  case S2LET_SAMPLING_MW:
    -
    261  ssht_adjoint_mw_forward_sov_sym(f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity);
    -
    262  break;
    -
    263  case S2LET_SAMPLING_MW_SS:
    -
    264  ssht_adjoint_mw_forward_sov_sym_ss(f_scal, f_scal_lm, bandlimit, 0, parameters.dl_method, verbosity);
    -
    265  break;
    -
    266  default:
    -
    267  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    268  }
    -
    269 
    -
    270  free(f_scal_lm);
    -
    271 
    -
    272  offset = 0;
    -
    273  for (j = 0; j <= J; ++j)
    -
    274  {
    -
    275  bandlimit = MIN(wav_bandlimits[j], L);
    -
    276  so3_parameters.L = bandlimit;
    -
    277  int Nj = MIN(N, bandlimit);
    -
    278  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    279  so3_parameters.N = Nj;
    -
    280  so3_parameters.L0 = 0;
    -
    281 
    -
    282  f_wav_lmn = (complex double*)calloc(so3_sampling_flmn_size(&so3_parameters), sizeof(complex double));
    -
    283 
    -
    284  for (n = -Nj+1; n < Nj; n+=2)
    -
    285  {
    -
    286  for (el = MAX(ABS(spin), ABS(n)); el < bandlimit; ++el)
    -
    287  {
    -
    288  ssht_sampling_elm2ind(&lm_ind, el, n);
    -
    289  psi = wav_lm[j*L*L + lm_ind];
    -
    290  for (m = -el; m <= el; ++m)
    -
    291  {
    -
    292  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    293  so3_sampling_elmn2ind(&lmn_ind, el, m, n, &so3_parameters);
    -
    294  f_wav_lmn[lmn_ind] = flm[lm_ind] * psi;
    -
    295  }
    -
    296  }
    -
    297  }
    -
    298 
    -
    299  so3_adjoint_forward_direct(
    -
    300  f_wav + offset,
    -
    301  f_wav_lmn,
    -
    302  &so3_parameters
    -
    303  );
    -
    304 
    -
    305  free(f_wav_lmn);
    -
    306  offset += so3_sampling_f_size(&so3_parameters);
    -
    307 
    -
    308  }
    -
    309 
    -
    310 }
    -
    311 
    -
    312 
    -
    325 void s2let_synthesis_adjoint_lm2wav(
    -
    326  complex double *f_wav,
    -
    327  complex double *f_scal,
    -
    328  const complex double *flm,
    -
    329  const s2let_parameters_t *parameters
    -
    330 ) {
    -
    331  int L = parameters->L, i;
    -
    332  int J_min = parameters->J_min;
    -
    333  int N = parameters->N;
    -
    334  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    335 
    -
    336  int bandlimit = L;
    -
    337  int verbosity = 0;
    -
    338  so3_parameters_t so3_parameters = {};
    -
    339  fill_so3_parameters(&so3_parameters, parameters);
    -
    340 
    -
    341  int j, offset, offset_lmn;
    -
    342  int J = s2let_j_max(parameters);
    -
    343 
    -
    344  complex double *wav_lm;
    -
    345  double *scal_l;
    -
    346  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, parameters);
    -
    347  s2let_tiling_wavelet(wav_lm, scal_l, parameters);
    -
    348 
    -
    349  complex double *f_wav_lmn, *f_scal_lm;
    -
    350 
    -
    351  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, parameters);
    -
    352  s2let_synthesis_adjoint_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, parameters);
    -
    353 
    -
    354 
    -
    355  if (!parameters->upsample)
    -
    356  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    357 
    -
    358  // Note, this is a spin-0 transform!
    -
    359  switch (parameters->sampling_scheme)
    -
    360  {
    -
    361  case S2LET_SAMPLING_MW:
    -
    362  ssht_adjoint_mw_forward_sov_sym(f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity);
    -
    363  break;
    -
    364  case S2LET_SAMPLING_MW_SS:
    -
    365  ssht_adjoint_mw_forward_sov_sym_ss(f_scal, f_scal_lm, bandlimit, 0, dl_method, verbosity);
    -
    366  break;
    -
    367  default:
    -
    368  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    369  }
    -
    370 
    -
    371  offset = 0;
    -
    372  offset_lmn = 0;
    -
    373  for (j = J_min; j <= J; ++j)
    -
    374  {
    -
    375  if (!parameters->upsample)
    -
    376  {
    -
    377  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    378  so3_parameters.L = bandlimit;
    -
    379  int Nj = MIN(N,bandlimit);
    -
    380  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    381  so3_parameters.N = Nj;
    -
    382  }
    -
    383 
    -
    384  so3_parameters.L0 = s2let_L0(j, parameters);
    -
    385 
    -
    386  so3_adjoint_forward_direct(
    -
    387 // so3_core_inverse_direct(
    -
    388 // so3_core_inverse_direct(
    -
    389  f_wav + offset,
    -
    390  f_wav_lmn + offset_lmn,
    -
    391  &so3_parameters
    -
    392  );
    -
    393  offset_lmn += so3_sampling_flmn_size(&so3_parameters);
    -
    394  offset += so3_sampling_f_size(&so3_parameters);
    -
    395  }
    -
    396 
    -
    397  free(wav_lm);
    -
    398  free(scal_l);
    -
    399  free(f_scal_lm);
    -
    400  free(f_wav_lmn);
    -
    401 }
    -
    402 
    -
    415 void s2let_synthesis_adjoint_lm2wav_real(
    -
    416  double *f_wav,
    -
    417  double *f_scal,
    -
    418  const complex double *flm,
    -
    419  const s2let_parameters_t *parameters
    -
    420 ) {
    -
    421  int L = parameters->L;
    -
    422  int J_min = parameters->J_min;
    -
    423  int N = parameters->N;
    -
    424  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    425 
    -
    426  s2let_parameters_t real_parameters = *parameters;
    -
    427  real_parameters.reality = 1;
    -
    428 
    -
    429  int bandlimit = L;
    -
    430  int verbosity = 0;
    -
    431  so3_parameters_t so3_parameters = {};
    -
    432  fill_so3_parameters(&so3_parameters, &real_parameters);
    -
    433 
    -
    434  int j, offset, offset_lmn;
    -
    435  int J = s2let_j_max(&real_parameters);
    -
    436 
    -
    437  complex double *wav_lm;
    -
    438  double *scal_l;
    -
    439  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &real_parameters);
    -
    440  s2let_tiling_wavelet(wav_lm, scal_l, &real_parameters);
    -
    441 
    -
    442  complex double *f_wav_lmn, *f_scal_lm;
    -
    443 
    -
    444  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &real_parameters);
    -
    445  s2let_synthesis_adjoint_lm2lmn_real(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, &real_parameters);
    -
    446 
    -
    447  if (!parameters->upsample)
    -
    448  bandlimit = MIN(s2let_bandlimit(J_min-1, &real_parameters), L);
    -
    449 
    -
    450  switch (parameters->sampling_scheme)
    -
    451  {
    -
    452  case S2LET_SAMPLING_MW:
    -
    453  ssht_adjoint_mw_forward_sov_sym_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity);
    -
    454  break;
    -
    455  case S2LET_SAMPLING_MW_SS:
    -
    456  ssht_adjoint_mw_forward_sov_sym_ss_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity);
    -
    457  break;
    -
    458  default:
    -
    459  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    460  }
    -
    461 
    -
    462  offset = 0;
    -
    463  offset_lmn = 0;
    -
    464  for (j = J_min; j <= J; ++j)
    -
    465  {
    -
    466  if (!parameters->upsample)
    -
    467  {
    -
    468  bandlimit = MIN(s2let_bandlimit(j, &real_parameters), L);
    -
    469  so3_parameters.L = bandlimit;
    -
    470  int Nj = MIN(N,bandlimit);
    -
    471  Nj += (Nj+N)%2; // ensure N and Nj are both even or both odd
    -
    472  so3_parameters.N = Nj;
    -
    473  }
    -
    474 
    -
    475  so3_parameters.L0 = s2let_L0(j, parameters);
    -
    476 
    -
    477  so3_adjoint_forward_direct_real(
    -
    478  f_wav + offset,
    -
    479  f_wav_lmn + offset_lmn,
    -
    480  &so3_parameters
    -
    481  );
    -
    482  offset_lmn += so3_sampling_flmn_size(&so3_parameters);
    -
    483  offset += so3_sampling_f_size(&so3_parameters);
    -
    484  }
    -
    485 
    -
    486  free(wav_lm);
    -
    487  free(scal_l);
    -
    488  free(f_scal_lm);
    -
    489  free(f_wav_lmn);
    -
    490 }
    -
    491 
    -
    504 void s2let_synthesis_adjoint_px2wav(
    -
    505  complex double *f_wav,
    -
    506  complex double *f_scal,
    -
    507  const complex double *f,
    -
    508  const s2let_parameters_t *parameters
    -
    509 ) {
    -
    510  int L = parameters->L, i;
    -
    511  int spin = parameters->spin;
    -
    512  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    513  int verbosity = parameters->verbosity;
    -
    514 
    -
    515  complex double *flm;
    -
    516  s2let_allocate_lm(&flm, L);
    -
    517 
    -
    518  switch (parameters->sampling_scheme)
    -
    519  {
    -
    520  case S2LET_SAMPLING_MW:
    -
    521  ssht_adjoint_mw_inverse_sov_sym(flm, f, L, spin, dl_method, verbosity);
    -
    522  break;
    -
    523  case S2LET_SAMPLING_MW_SS:
    -
    524  ssht_adjoint_mw_inverse_sov_sym_ss(flm, f, L, spin, dl_method, verbosity);
    -
    525  break;
    -
    526  default:
    -
    527  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    528  }
    -
    529 
    -
    530  s2let_synthesis_adjoint_lm2wav(f_wav, f_scal, flm, parameters);
    -
    531 
    -
    532  free(flm);
    -
    533 }
    -
    534 
    -
    547 void s2let_synthesis_adjoint_px2wav_real(
    -
    548  double *f_wav,
    -
    549  double *f_scal,
    -
    550  const double *f,
    -
    551  const s2let_parameters_t *parameters
    -
    552 ) {
    -
    553  int L = parameters->L;
    -
    554  ssht_dl_method_t dl_method = parameters->dl_method;
    -
    555  int verbosity = 0;
    -
    556 
    -
    557  complex double *flm;
    -
    558  s2let_allocate_lm(&flm, L);
    -
    559 
    -
    560  switch (parameters->sampling_scheme)
    -
    561  {
    -
    562  case S2LET_SAMPLING_MW:
    -
    563  ssht_adjoint_mw_inverse_sov_sym_real(flm, f, L, dl_method, verbosity);
    -
    564  break;
    -
    565  case S2LET_SAMPLING_MW_SS:
    -
    566  ssht_adjoint_mw_inverse_sov_sym_ss_real(flm, f, L, dl_method, verbosity);
    -
    567  break;
    -
    568  default:
    -
    569  S2LET_ERROR_GENERIC("Sampling scheme not supported.");
    -
    570  }
    -
    571 
    -
    572  s2let_synthesis_adjoint_lm2wav_real(f_wav, f_scal, flm, parameters);
    -
    573 
    -
    574  free(flm);
    -
    575 }
    -
    -
    s2let_synthesis_adjoint_lm2lmn_real
    void s2let_synthesis_adjoint_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis_adjoint.c:113
    -
    s2let_tiling_wavelet_allocate
    void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:339
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    - -
    s2let_parameters_t::verbosity
    int verbosity
    Definition: s2let_types.h:61
    -
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    ABS
    #define ABS(a)
    Definition: s2let_math.h:13
    -
    s2let_allocate_lmn_f_wav
    void s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:82
    -
    S2LET_ERROR_GENERIC
    #define S2LET_ERROR_GENERIC(comment)
    Definition: s2let_error.h:13
    -
    S2LET_SAMPLING_MW_SS
    @ S2LET_SAMPLING_MW_SS
    Definition: s2let_types.h:32
    -
    s2let_synthesis_adjoint_lm2wav_real
    void s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis_adjoint.c:415
    -
    s2let_tiling_wavelet
    void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:388
    -
    s2let_parameters_t::reality
    int reality
    Definition: s2let_types.h:70
    -
    PI
    #define PI
    Definition: s2let_math.h:9
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_synthesis_adjoint_lm2wav_manual
    void s2let_synthesis_adjoint_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    Definition: s2let_synthesis_adjoint.c:208
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_L0
    int s2let_L0(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:83
    -
    s2let_synthesis_adjoint_px2wav_real
    void s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_synthesis_adjoint.c:547
    -
    s2let_synthesis_adjoint_lm2wav
    void s2let_synthesis_adjoint_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis_adjoint.c:325
    -
    MAX
    #define MAX(a, b)
    Definition: s2let_math.h:12
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_synthesis_adjoint_lm2lmn
    void s2let_synthesis_adjoint_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis_adjoint.c:27
    -
    s2let_synthesis_adjoint_px2wav
    void s2let_synthesis_adjoint_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis_adjoint.c:504
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    -
    S2LET_SAMPLING_MW
    @ S2LET_SAMPLING_MW
    Definition: s2let_types.h:25
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__synthesis__adjoint_8h.html b/docs/c/s2let__synthesis__adjoint_8h.html index 64032dd5..db1fcdc1 100644 --- a/docs/c/s2let__synthesis__adjoint_8h.html +++ b/docs/c/s2let__synthesis__adjoint_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_synthesis_adjoint.h File Reference +s2let: include/s2let_synthesis_adjoint.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_synthesis_adjoint.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -584,14 +634,12 @@

    Definition at line 547 of file s2let_synthesis_adjoint.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__synthesis__adjoint_8h__dep__incl.map b/docs/c/s2let__synthesis__adjoint_8h__dep__incl.map new file mode 100644 index 00000000..fe96565b --- /dev/null +++ b/docs/c/s2let__synthesis__adjoint_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__synthesis__adjoint_8h__dep__incl.md5 b/docs/c/s2let__synthesis__adjoint_8h__dep__incl.md5 new file mode 100644 index 00000000..dcd59b2d --- /dev/null +++ b/docs/c/s2let__synthesis__adjoint_8h__dep__incl.md5 @@ -0,0 +1 @@ +0e4e3be17e5a1026f211ac1af4f2ecd0 \ No newline at end of file diff --git a/docs/c/s2let__synthesis__adjoint_8h__incl.map b/docs/c/s2let__synthesis__adjoint_8h__incl.map new file mode 100644 index 00000000..b01224e8 --- /dev/null +++ b/docs/c/s2let__synthesis__adjoint_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__synthesis__adjoint_8h__incl.md5 b/docs/c/s2let__synthesis__adjoint_8h__incl.md5 new file mode 100644 index 00000000..e0dcd634 --- /dev/null +++ b/docs/c/s2let__synthesis__adjoint_8h__incl.md5 @@ -0,0 +1 @@ +025fb3108b1a84e4b609c2a3b3f9920a \ No newline at end of file diff --git a/docs/c/s2let__synthesis__adjoint_8h_source.html b/docs/c/s2let__synthesis__adjoint_8h_source.html index 560ddf9a..acfb32f1 100644 --- a/docs/c/s2let__synthesis__adjoint_8h_source.html +++ b/docs/c/s2let__synthesis__adjoint_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_synthesis_adjoint.h Source File +s2let: include/s2let_synthesis_adjoint.h Source File @@ -22,10 +22,10 @@

    @@ -171,18 +171,18 @@
    205 #endif
    206 #endif
    -
    s2let_synthesis_adjoint_px2wav_real
    void s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_synthesis_adjoint.c:547
    +
    s2let_synthesis_adjoint_px2wav_real
    void s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_synthesis_adjoint.c:506
    s2let_synthesis_adjoint_lm2lmn_real
    void s2let_synthesis_adjoint_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    s2let_synthesis_adjoint_px2wav
    void s2let_synthesis_adjoint_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    s2let_synthesis_adjoint_lm2wav_manual
    void s2let_synthesis_adjoint_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    s2let_synthesis_adjoint_lm2lmn
    void s2let_synthesis_adjoint_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    s2let_synthesis_adjoint_lm2wav_real
    void s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    s2let_synthesis_adjoint_lm2wav
    void s2let_synthesis_adjoint_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__test_8c.html b/docs/c/s2let__test_8c.html index 1d11c242..851d793a 100644 --- a/docs/c/s2let__test_8c.html +++ b/docs/c/s2let__test_8c.html @@ -5,7 +5,7 @@ -S2LET: src/test/c/s2let_test.c File Reference +s2let: src/test/c/s2let_test.c File Reference @@ -22,10 +22,10 @@ @@ -82,9 +82,44 @@ #include <math.h>
    #include <time.h>
    #include <so3/so3.h>
    - -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    +Include dependency graph for s2let_test.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    @@ -95,81 +130,81 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + @@ -201,8 +236,6 @@

    -

    Definition at line 2910 of file s2let_test.c.

    - @@ -221,8 +254,6 @@

    -

    Definition at line 117 of file s2let_test.c.

    - @@ -257,8 +288,6 @@

    -

    Definition at line 900 of file s2let_test.c.

    - @@ -293,8 +322,6 @@

    -

    Definition at line 921 of file s2let_test.c.

    - @@ -344,8 +371,6 @@

    Definition at line 22 of file s2let_test.c.

    - @@ -388,8 +413,6 @@

    Definition at line 54 of file s2let_test.c.

    - @@ -453,8 +476,6 @@

    Definition at line 88 of file s2let_test.c.

    - @@ -511,8 +532,6 @@

    Definition at line 235 of file s2let_test.c.

    - @@ -569,8 +588,6 @@

    Definition at line 170 of file s2let_test.c.

    - @@ -600,7 +617,7 @@

    - + @@ -627,8 +644,6 @@

    Definition at line 2553 of file s2let_test.c.

    - @@ -658,7 +673,7 @@

    - + @@ -685,8 +700,6 @@

    Definition at line 2496 of file s2let_test.c.

    - @@ -743,8 +756,6 @@

    Definition at line 770 of file s2let_test.c.

    - @@ -801,8 +812,6 @@

    Definition at line 704 of file s2let_test.c.

    - @@ -859,8 +868,6 @@

    Definition at line 638 of file s2let_test.c.

    - @@ -917,8 +924,6 @@

    Definition at line 573 of file s2let_test.c.

    - @@ -965,8 +970,6 @@

    -

    Definition at line 2836 of file s2let_test.c.

    - @@ -1013,8 +1016,6 @@

    -

    Definition at line 2761 of file s2let_test.c.

    - @@ -1061,8 +1062,6 @@

    -

    Definition at line 2685 of file s2let_test.c.

    - @@ -1109,8 +1108,6 @@

    -

    Definition at line 2610 of file s2let_test.c.

    - @@ -1181,8 +1178,6 @@

    Definition at line 947 of file s2let_test.c.

    - @@ -1235,8 +1230,6 @@

    -

    Definition at line 1228 of file s2let_test.c.

    - @@ -1289,8 +1282,6 @@

    -

    Definition at line 1139 of file s2let_test.c.

    - @@ -1343,8 +1334,6 @@

    -

    Definition at line 1638 of file s2let_test.c.

    - @@ -1397,8 +1386,6 @@

    -

    Definition at line 1318 of file s2let_test.c.

    - @@ -1469,8 +1456,6 @@

    Definition at line 1047 of file s2let_test.c.

    - @@ -1523,8 +1508,6 @@

    -

    Definition at line 1496 of file s2let_test.c.

    - @@ -1577,8 +1560,6 @@

    -

    Definition at line 1407 of file s2let_test.c.

    - @@ -1649,8 +1630,6 @@

    Definition at line 483 of file s2let_test.c.

    - @@ -1721,8 +1700,6 @@

    Definition at line 410 of file s2let_test.c.

    - @@ -1787,8 +1764,6 @@

    Definition at line 2437 of file s2let_test.c.

    - @@ -1859,8 +1834,6 @@

    Definition at line 2375 of file s2let_test.c.

    - @@ -1924,8 +1897,6 @@

    Definition at line 2312 of file s2let_test.c.

    - @@ -1996,8 +1967,6 @@

    Definition at line 2250 of file s2let_test.c.

    - @@ -2062,8 +2031,6 @@

    Definition at line 1881 of file s2let_test.c.

    - @@ -2134,8 +2101,6 @@

    Definition at line 1808 of file s2let_test.c.

    - @@ -2199,8 +2164,6 @@

    Definition at line 1734 of file s2let_test.c.

    - @@ -2271,8 +2234,6 @@

    Definition at line 838 of file s2let_test.c.

    - @@ -2337,8 +2298,6 @@

    Definition at line 2176 of file s2let_test.c.

    - @@ -2409,8 +2368,6 @@

    Definition at line 2102 of file s2let_test.c.

    - @@ -2474,8 +2431,6 @@

    Definition at line 2027 of file s2let_test.c.

    - @@ -2546,8 +2501,6 @@

    Definition at line 1953 of file s2let_test.c.

    - @@ -2618,8 +2571,6 @@

    Definition at line 304 of file s2let_test.c.

    - @@ -2654,14 +2605,12 @@

    -

    Definition at line 1585 of file s2let_test.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__test_8c__incl.map b/docs/c/s2let__test_8c__incl.map new file mode 100644 index 00000000..447c8153 --- /dev/null +++ b/docs/c/s2let__test_8c__incl.map @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__test_8c__incl.md5 b/docs/c/s2let__test_8c__incl.md5 new file mode 100644 index 00000000..ab05af4d --- /dev/null +++ b/docs/c/s2let__test_8c__incl.md5 @@ -0,0 +1 @@ +a4c350f110ba01f440f90cc56d044780 \ No newline at end of file diff --git a/docs/c/s2let__test_8c_source.html b/docs/c/s2let__test_8c_source.html deleted file mode 100644 index 7d87162d..00000000 --- a/docs/c/s2let__test_8c_source.html +++ /dev/null @@ -1,2980 +0,0 @@ - - - - - - - -S2LET: src/test/c/s2let_test.c Source File - - - - - - - - - -
    -
    -

    Functions

    void s2let_tiling_axisym_test (int B, int L, int J_min)
     
    void s2let_binomial_coefficient_test (int n_max)
     
    void s2let_transform_axisym_lm_wav_test (int B, int L, int J_min, int seed)
    void s2let_transform_axisym_lm_wav_test (int B, int L, int J_min, int seed)
     
    void s2let_transform_axisym_lm_wav_multires_test (int B, int L, int J_min, int seed)
    void s2let_transform_axisym_lm_wav_multires_test (int B, int L, int J_min, int seed)
     
    void s2let_wav_transform_wavlm_manual_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_transform_wavlm_manual_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_transform_harmonic_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_transform_harmonic_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_transform_harmonic_multires_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_transform_harmonic_multires_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_transform_axisym_wav_test (int B, int L, int J_min, int seed)
    void s2let_transform_axisym_wav_test (int B, int L, int J_min, int seed)
     
    void s2let_transform_axisym_wav_real_test (int B, int L, int J_min, int seed)
    void s2let_transform_axisym_wav_real_test (int B, int L, int J_min, int seed)
     
    void s2let_transform_axisym_wav_multires_test (int B, int L, int J_min, int seed)
    void s2let_transform_axisym_wav_multires_test (int B, int L, int J_min, int seed)
     
    void s2let_transform_axisym_wav_multires_real_test (int B, int L, int J_min, int seed)
    void s2let_transform_axisym_wav_multires_real_test (int B, int L, int J_min, int seed)
     
    void s2let_wav_transform_mw_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_transform_mw_test (int B, int L, int J_min, int N, int spin, int seed)
     
    complex double s2let_dot_product_complex (complex double *v1, complex double *v2, int N_length)
     
    complex double s2let_dot_product_real (double *v1, double *v2, int N_length)
     
    void s2let_wav_analysis_adjoint_lm_lmn_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_analysis_adjoint_lm_lmn_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_synthesis_adjoint_lm_lmn_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_synthesis_adjoint_lm_lmn_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_analysis_adjoint_mw_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_analysis_adjoint_mw_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_analysis_adjoint_mw_real_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_analysis_adjoint_mw_real_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_synthesis_adjoint_lm2wav_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_synthesis_adjoint_lm2wav_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_synthesis_adjoint_mw_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_synthesis_adjoint_mw_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_synthesis_adjoint_mw_real_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_synthesis_adjoint_mw_real_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void so3_test_gen_flmn_complex (complex double *flmn, const so3_parameters_t *parameters, int seed)
    void so3_test_gen_flmn_complex (complex double *flmn, const so3_parameters_t *parameters, int seed)
     
    void s2let_wav_so3_forward_adjoint_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_so3_forward_adjoint_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_transform_mw_real_test (int B, int L, int J_min, int N, int seed)
    void s2let_wav_transform_mw_real_test (int B, int L, int J_min, int N, int seed)
     
    void s2let_wav_transform_mw_multires_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_transform_mw_multires_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_transform_mw_multires_real_test (int B, int L, int J_min, int N, int seed)
    void s2let_wav_transform_mw_multires_real_test (int B, int L, int J_min, int N, int seed)
     
    void s2let_wav_transform_mwss_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_transform_mwss_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_transform_mwss_real_test (int B, int L, int J_min, int N, int seed)
    void s2let_wav_transform_mwss_real_test (int B, int L, int J_min, int N, int seed)
     
    void s2let_wav_transform_mwss_multires_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_transform_mwss_multires_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_transform_mwss_multires_real_test (int B, int L, int J_min, int N, int seed)
    void s2let_wav_transform_mwss_multires_real_test (int B, int L, int J_min, int N, int seed)
     
    void s2let_wav_transform_lm2wav_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_transform_lm2wav_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_transform_lm2wav_real_test (int B, int L, int J_min, int N, int seed)
    void s2let_wav_transform_lm2wav_real_test (int B, int L, int J_min, int N, int seed)
     
    void s2let_wav_transform_lm2wav_multires_test (int B, int L, int J_min, int N, int spin, int seed)
    void s2let_wav_transform_lm2wav_multires_test (int B, int L, int J_min, int N, int spin, int seed)
     
    void s2let_wav_transform_lm2wav_multires_real_test (int B, int L, int J_min, int N, int seed)
    void s2let_wav_transform_lm2wav_multires_real_test (int B, int L, int J_min, int N, int seed)
     
    void s2let_transform_axisym_vs_directional_mw_test (B, L, J_min, seed)
    void s2let_transform_axisym_vs_directional_mw_test (B, L, J_min, seed)
     
    void s2let_transform_axisym_vs_directional_mw_multires_test (B, L, J_min, seed)
    void s2let_transform_axisym_vs_directional_mw_multires_test (B, L, J_min, seed)
     
    void s2let_transform_performance_test (int B, int J_min, int NREPEAT, int NSCALE, int seed)
    void s2let_transform_performance_test (int B, int J_min, int NREPEAT, int NSCALE, int seed)
     
    void s2let_transform_performance_multires_test (int B, int J_min, int NREPEAT, int NSCALE, int seed)
    void s2let_transform_performance_multires_test (int B, int J_min, int NREPEAT, int NSCALE, int seed)
     
    void s2let_transform_lm_performance_test (int B, int J_min, int NREPEAT, int NSCALE, int seed)
    void s2let_transform_lm_performance_test (int B, int J_min, int NREPEAT, int NSCALE, int seed)
     
    void s2let_transform_lm_performance_multires_test (int B, int J_min, int NREPEAT, int NSCALE, int seed)
    void s2let_transform_lm_performance_multires_test (int B, int J_min, int NREPEAT, int NSCALE, int seed)
     
    int main (int argc, char *argv[])
     
    seed seed   
    seed seed   
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_test.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <ssht/ssht.h>
    -
    7 #include <assert.h>
    -
    8 #include <complex.h>
    -
    9 #include <stdlib.h>
    -
    10 #include <math.h>
    -
    11 #include <time.h>
    -
    12 #include <so3/so3.h>
    -
    13 
    -
    22 void s2let_tiling_axisym_test(int B, int L, int J_min)
    -
    23 {
    -
    24  s2let_parameters_t parameters = {};
    -
    25  parameters.B = B;
    -
    26  parameters.L = L;
    -
    27  parameters.J_min = J_min;
    -
    28 
    -
    29  double *kappa, *kappa0;
    -
    30 
    -
    31  // Allocate the kernels corresponding to the parameters B, L
    -
    32  s2let_tiling_axisym_allocate(&kappa, &kappa0, &parameters);
    -
    33 
    -
    34  // Construct the tiling of harmonic space
    -
    35  s2let_tiling_axisym(kappa, kappa0, &parameters);
    -
    36 
    -
    37  // Check that they recover the identity relation,
    -
    38  // ensuring exactness of the wavelet transform.
    -
    39  double res = s2let_tiling_axisym_check_identity(kappa, kappa0, &parameters);
    -
    40  printf(" - Maximum error : %6.5e\n", res);
    -
    41 
    -
    42  free(kappa);
    -
    43  free(kappa0);
    -
    44 }
    -
    45 
    -
    54 void s2let_tiling_direction_test(int L, int N)
    -
    55 {
    -
    56  s2let_parameters_t parameters = {};
    -
    57  parameters.L = L;
    -
    58  parameters.N = N;
    -
    59 
    -
    60  complex double *s_elm;
    -
    61  double error;
    -
    62 
    -
    63  // Allocate space for the harmonic coefficients
    -
    64  s2let_tiling_direction_allocate(&s_elm, &parameters);
    -
    65 
    -
    66  // Construct the harmonic coefficients
    -
    67  s2let_tiling_direction(s_elm, &parameters);
    -
    68 
    -
    69  // Check that they recover the identity relation,
    -
    70  // ensuring exactness of the wavelet transform.
    -
    71  error = s2let_tiling_direction_check_identity(s_elm, &parameters);
    -
    72  printf(" - Maximum error : %6.5e\n", error);
    -
    73 
    -
    74  free(s_elm);
    -
    75 }
    -
    76 
    -
    88 void s2let_tiling_wavelet_test(int B, int L, int J_min, int N, int spin)
    -
    89 {
    -
    90  s2let_parameters_t parameters = {};
    -
    91  parameters.B = B;
    -
    92  parameters.L = L;
    -
    93  parameters.J_min = J_min;
    -
    94  parameters.N = N;
    -
    95  parameters.spin = spin;
    -
    96  parameters.original_spin = 0;
    -
    97 
    -
    98  complex double *phi;
    -
    99  double *psi;
    -
    100  double error;
    -
    101 
    -
    102  // Allocate space for the harmonic coefficients
    -
    103  s2let_tiling_wavelet_allocate(&phi, &psi, &parameters);
    -
    104 
    -
    105  // Construct the harmonic coefficients
    -
    106  s2let_tiling_wavelet(phi, psi, &parameters);
    -
    107 
    -
    108  // Check that they recover the identity relation,
    -
    109  // ensuring exactness of the wavelet transform.
    -
    110  error = s2let_tiling_wavelet_check_identity(phi, psi, &parameters);
    -
    111  printf(" - Maximum error : %6.5e\n", error);
    -
    112 
    -
    113  free(phi);
    -
    114  free(psi);
    -
    115 }
    -
    116 
    -
    117 void s2let_binomial_coefficient_test(int n_max)
    -
    118 {
    -
    119  const int nRepeat = 100000;
    -
    120  int n, k, i;
    -
    121  int firstError = 0;
    -
    122 
    -
    123  long error;
    -
    124 
    -
    125  clock_t time_start, time_end;
    -
    126 
    -
    127  for (n = 1; n <= n_max; ++n)
    -
    128  {
    -
    129  for (k = 0; k <= n/2; ++k)
    -
    130  {
    -
    131  error = binomial_coefficient(n, k, 0) -
    -
    132  binomial_coefficient(n, k, 1);
    -
    133 
    -
    134  if (error && !firstError)
    -
    135  {
    -
    136  printf(" - First error at: n = %d, k = %d, error = %ld\n", n, k, error);
    -
    137  firstError = 1;
    -
    138  }
    -
    139  }
    -
    140  }
    -
    141 
    -
    142  printf(" - Maximum error: %ld\n", error);
    -
    143 
    -
    144  printf(" - Duration for %d computations of (%d,%d)\n", nRepeat, n_max, n_max/2);
    -
    145 
    -
    146  time_start = clock();
    -
    147  for (i = 0; i < nRepeat; ++i)
    -
    148  binomial_coefficient(n_max, n_max/2, 0);
    -
    149  time_end = clock();
    -
    150  printf(" logfact implementation: %4.4f seconds\n",
    -
    151  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    152 
    -
    153  time_start = clock();
    -
    154  for (i = 0; i < nRepeat; ++i)
    -
    155  binomial_coefficient(n_max, n_max/2, 1);
    -
    156  time_end = clock();
    -
    157  printf(" exact implementation: %4.4f seconds\n",
    -
    158  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    159 }
    -
    160 
    -
    170 void s2let_transform_axisym_lm_wav_test(int B, int L, int J_min, int seed)
    -
    171 {
    -
    172  s2let_parameters_t parameters = {};
    -
    173  parameters.B = B;
    -
    174  parameters.L = L;
    -
    175  parameters.J_min = J_min;
    -
    176 
    -
    177  clock_t time_start, time_end;
    -
    178  double *wav_lm, *scal_lm;
    -
    179 
    -
    180  // Allocate the wavelet kernels
    -
    181  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, &parameters);
    -
    182 
    -
    183  // Compute the wavelet kernels
    -
    184  time_start = clock();
    -
    185  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, &parameters);
    -
    186  time_end = clock();
    -
    187  printf(" - Generate wavelets : %4.4f seconds\n",
    -
    188  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    189 
    -
    190  complex double *f_wav_lm, *f_scal_lm, *flm, *flm_rec;
    -
    191  s2let_allocate_lm(&flm, L);
    -
    192  s2let_allocate_lm(&flm_rec, L);
    -
    193 
    -
    194  // Generate a random spherical harmonic decomposition
    -
    195  s2let_lm_random_flm(flm, L, 0, seed);
    -
    196 
    -
    197  // Allocate space for the wavelet scales (their harmonic coefficients)
    -
    198  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, &parameters);
    -
    199 
    -
    200  // Perform the wavelet transform through exact harmonic tiling
    -
    201  time_start = clock();
    -
    202  s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, &parameters);
    -
    203  time_end = clock();
    -
    204  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    205  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    206 
    -
    207  // Reconstruct the initial harmonic coefficients from those of the wavelets
    -
    208  time_start = clock();
    -
    209  s2let_transform_axisym_lm_wav_synthesis(flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, &parameters);
    -
    210  time_end = clock();
    -
    211  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    212  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    213 
    -
    214  // Compute the maximum absolute error on the harmonic coefficients
    -
    215  printf(" - Maximum abs error : %6.5e\n",
    -
    216  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    217 
    -
    218  free(flm);
    -
    219  free(flm_rec);
    -
    220  free(f_wav_lm);
    -
    221  free(f_scal_lm);
    -
    222  free(wav_lm);
    -
    223  free(scal_lm);
    -
    224 }
    -
    225 
    -
    235 void s2let_transform_axisym_lm_wav_multires_test(int B, int L, int J_min, int seed)
    -
    236 {
    -
    237  s2let_parameters_t parameters = {};
    -
    238  parameters.B = B;
    -
    239  parameters.L = L;
    -
    240  parameters.J_min = J_min;
    -
    241 
    -
    242  clock_t time_start, time_end;
    -
    243  double *wav_lm, *scal_lm;
    -
    244 
    -
    245  // Allocate the wavelet kernels
    -
    246  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, &parameters);
    -
    247 
    -
    248  // Compute the wavelet kernels
    -
    249  time_start = clock();
    -
    250  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, &parameters);
    -
    251  time_end = clock();
    -
    252  printf(" - Generate wavelets : %4.4f seconds\n",
    -
    253  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    254 
    -
    255  complex double *f_wav_lm, *f_scal_lm, *flm, *flm_rec;
    -
    256  s2let_allocate_lm(&flm, L);
    -
    257  s2let_allocate_lm(&flm_rec, L);
    -
    258 
    -
    259  // Generate a random spherical harmonic decomposition
    -
    260  s2let_lm_random_flm(flm, L, 0, seed);
    -
    261 
    -
    262  // Allocate space for the wavelet scales (their harmonic coefficients)
    -
    263  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, &parameters);
    -
    264 
    -
    265  // Perform the wavelet transform through exact harmonic tiling
    -
    266  time_start = clock();
    -
    267  s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, &parameters);
    -
    268  time_end = clock();
    -
    269  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    270  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    271 
    -
    272  // Reconstruct the initial harmonic coefficients from those of the wavelets
    -
    273  time_start = clock();
    -
    274  s2let_transform_axisym_lm_wav_synthesis_multires(flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, &parameters);
    -
    275  time_end = clock();
    -
    276  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    277  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    278 
    -
    279  // Compute the maximum absolute error on the harmonic coefficients
    -
    280  printf(" - Maximum abs error : %6.5e\n",
    -
    281  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    282 
    -
    283  free(flm);
    -
    284  free(flm_rec);
    -
    285  free(f_wav_lm);
    -
    286  free(f_scal_lm);
    -
    287  free(wav_lm);
    -
    288  free(scal_lm);
    -
    289 }
    -
    290 
    -
    291 
    -
    304 void s2let_wav_transform_wavlm_manual_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    305 {
    -
    306  s2let_parameters_t parameters = {};
    -
    307  parameters.B = B;
    -
    308  parameters.L = L;
    -
    309  parameters.J_min = J_min;
    -
    310  parameters.N = N;
    -
    311  parameters.spin = spin;
    -
    312  parameters.upsample = 1;
    -
    313  parameters.original_spin = 0;
    -
    314 
    -
    315  int el, m, i, j;
    -
    316  int J = s2let_j_max(&parameters) - J_min;
    -
    317 
    -
    318  clock_t time_start, time_end;
    -
    319  complex double *psi;
    -
    320  double *phi;
    -
    321 
    -
    322  // Allocate the wavelet kernels
    -
    323  s2let_tiling_wavelet_allocate(&psi, &phi, &parameters);
    -
    324  // Compute the wavelet kernels
    -
    325  time_start = clock();
    -
    326  s2let_tiling_wavelet(psi, phi, &parameters);
    -
    327  time_end = clock();
    -
    328  printf(" - Generate wavelets : %4.4f seconds\n",
    -
    329  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    330 
    -
    331  int scal_bandlimit;
    -
    332  if (!parameters.upsample)
    -
    333  scal_bandlimit = MIN(s2let_bandlimit(J_min-1, &parameters), L);
    -
    334  else
    -
    335  scal_bandlimit = L;
    -
    336 
    -
    337  complex double *wav_l = (complex double*)calloc((J+1)*L*L, sizeof(complex double));
    -
    338  int *wav_bandlimits = (int*)calloc(J+1, sizeof(int));
    -
    339  for (j = 0; j <= J; ++j)
    -
    340  {
    -
    341  if (!parameters.upsample)
    -
    342  wav_bandlimits[j] = MIN(s2let_bandlimit(J_min+j, &parameters), L);
    -
    343  else
    -
    344  wav_bandlimits[j] = L;
    -
    345  printf("j = %i, wav_bandlimit = %i\n",j,wav_bandlimits[j]);
    -
    346  for(i = 0; i < L*L; ++i){
    -
    347  wav_l[j*L*L + i] = psi[(J_min+j)*L*L + i];
    -
    348  }
    -
    349  }
    -
    350 
    -
    351 
    -
    352  complex double *f_wav, *f_scal, *flm, *flm_rec;
    -
    353  s2let_allocate_lm(&flm, L);
    -
    354  s2let_allocate_lm(&flm_rec, L);
    -
    355 
    -
    356  // Generate a random spherical harmonic decomposition
    -
    357  s2let_lm_random_flm(flm, L, spin, seed);
    -
    358 
    -
    359  // Allocate space for the wavelet scales (their harmonic/Wigner coefficients)
    -
    360  s2let_allocate_f_wav_manual(&f_wav, &f_scal, wav_bandlimits, scal_bandlimit, N, J, &parameters);
    -
    361 
    -
    362  // Perform the wavelet transform through exact harmonic tiling
    -
    363  time_start = clock();
    -
    364  s2let_analysis_lm2wav_manual(f_wav, f_scal, flm, phi, wav_l, scal_bandlimit, wav_bandlimits, J, L, spin, N);
    -
    365  time_end = clock();
    -
    366  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    367  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    368 
    -
    369  // Reconstruct the initial harmonic coefficients from those of the wavelets
    -
    370  time_start = clock();
    -
    371  s2let_synthesis_wav2lm_manual(flm_rec, f_wav, f_scal, phi, wav_l, scal_bandlimit, wav_bandlimits, J, L, spin, N);
    -
    372  time_end = clock();
    -
    373  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    374  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    375 
    -
    376  // Compute the maximum absolute error on the harmonic coefficients
    -
    377  printf(" - Maximum abs error : %6.5e\n",
    -
    378  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    379 
    -
    380  for (el = 0; el < L; ++el)
    -
    381  {
    -
    382  for (m = -el; m <= el; ++m)
    -
    383  {
    -
    384  i = el*el + el + m;
    -
    385  if( cabs( flm[i]-flm_rec[i] ) > 0.001 )
    -
    386  printf("%(l,m) = (%i,%i) : %f+i%f %f+i%f\n",el, m, creal(flm[i]), cimag(flm[i]), creal(flm_rec[i]), cimag(flm_rec[i]));
    -
    387  }
    -
    388  }
    -
    389 
    -
    390  free(flm);
    -
    391  free(flm_rec);
    -
    392  free(f_wav);
    -
    393  free(f_scal);
    -
    394  free(psi);
    -
    395  free(phi);
    -
    396 }
    -
    397 
    -
    410 void s2let_wav_transform_harmonic_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    411 {
    -
    412  s2let_parameters_t parameters = {};
    -
    413  parameters.B = B;
    -
    414  parameters.L = L;
    -
    415  parameters.J_min = J_min;
    -
    416  parameters.N = N;
    -
    417  parameters.spin = spin;
    -
    418  parameters.upsample = 1;
    -
    419  parameters.original_spin = 0;
    -
    420 
    -
    421  clock_t time_start, time_end;
    -
    422  complex double *psi;
    -
    423  double *phi;
    -
    424 
    -
    425  // Allocate the wavelet kernels
    -
    426  s2let_tiling_wavelet_allocate(&psi, &phi, &parameters);
    -
    427 
    -
    428  // Compute the wavelet kernels
    -
    429  time_start = clock();
    -
    430  s2let_tiling_wavelet(psi, phi, &parameters);
    -
    431  time_end = clock();
    -
    432  printf(" - Generate wavelets : %4.4f seconds\n",
    -
    433  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    434 
    -
    435  complex double *f_wav_lmn, *f_scal_lm, *flm, *flm_rec;
    -
    436  s2let_allocate_lm(&flm, L);
    -
    437  s2let_allocate_lm(&flm_rec, L);
    -
    438 
    -
    439  // Generate a random spherical harmonic decomposition
    -
    440  s2let_lm_random_flm(flm, L, spin, seed);
    -
    441 
    -
    442  // Allocate space for the wavelet scales (their harmonic/Wigner coefficients)
    -
    443  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &parameters);
    -
    444 
    -
    445  // Perform the wavelet transform through exact harmonic tiling
    -
    446  time_start = clock();
    -
    447  s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, psi, phi, &parameters);
    -
    448  time_end = clock();
    -
    449  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    450  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    451 
    -
    452  // Reconstruct the initial harmonic coefficients from those of the wavelets
    -
    453  time_start = clock();
    -
    454  s2let_synthesis_lmn2lm(flm_rec, f_wav_lmn, f_scal_lm, psi, phi, &parameters);
    -
    455  time_end = clock();
    -
    456  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    457  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    458 
    -
    459  // Compute the maximum absolute error on the harmonic coefficients
    -
    460  printf(" - Maximum abs error : %6.5e\n",
    -
    461  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    462 
    -
    463  free(flm);
    -
    464  free(flm_rec);
    -
    465  free(f_wav_lmn);
    -
    466  free(f_scal_lm);
    -
    467  free(psi);
    -
    468  free(phi);
    -
    469 }
    -
    470 
    -
    483 void s2let_wav_transform_harmonic_multires_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    484 {
    -
    485  s2let_parameters_t parameters = {};
    -
    486  parameters.B = B;
    -
    487  parameters.L = L;
    -
    488  parameters.J_min = J_min;
    -
    489  parameters.N = N;
    -
    490  parameters.spin = spin;
    -
    491  parameters.original_spin = 0;
    -
    492 
    -
    493  clock_t time_start, time_end;
    -
    494  complex double *psi;
    -
    495  double *phi;
    -
    496 
    -
    497  // Allocate the wavelet kernels
    -
    498  s2let_tiling_wavelet_allocate(&psi, &phi, &parameters);
    -
    499 
    -
    500  // Compute the wavelet kernels
    -
    501  time_start = clock();
    -
    502  s2let_tiling_wavelet(psi, phi, &parameters);
    -
    503  time_end = clock();
    -
    504  printf(" - Generate wavelets : %4.4f seconds\n",
    -
    505  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    506 
    -
    507  complex double *f_wav_lmn, *f_scal_lm, *flm, *flm_rec;
    -
    508  s2let_allocate_lm(&flm, L);
    -
    509  s2let_allocate_lm(&flm_rec, L);
    -
    510 
    -
    511  // Generate a random spherical harmonic decomposition
    -
    512  s2let_lm_random_flm(flm, L, spin, seed);
    -
    513 
    -
    514  // Allocate space for the wavelet scales (their harmonic/Wigner coefficients)
    -
    515  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &parameters);
    -
    516 
    -
    517  FILE *fp1, *fp2;
    -
    518  int el, m, lm_ind;
    -
    519  fp1 = fopen("f_lm_before.dat", "w");
    -
    520  for (el = ABS(spin); el < L; ++el) {
    -
    521  for (m = -el; m <= el; ++m){
    -
    522  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    523  fprintf(fp1, "%d, %d, %d, %f, %f\n",el,m,lm_ind, creal(flm[lm_ind]), cimag(flm[lm_ind]));
    -
    524  }
    -
    525  }
    -
    526  fclose(fp1);
    -
    527 
    -
    528  // Perform the wavelet transform through exact harmonic tiling
    -
    529  time_start = clock();
    -
    530  s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, psi, phi, &parameters);
    -
    531  time_end = clock();
    -
    532  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    533  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    534 
    -
    535  // Reconstruct the initial harmonic coefficients from those of the wavelets
    -
    536  time_start = clock();
    -
    537  s2let_synthesis_lmn2lm(flm_rec, f_wav_lmn, f_scal_lm, psi, phi, &parameters);
    -
    538  time_end = clock();
    -
    539  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    540  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    541 
    -
    542  fp2 = fopen("f_lm_rec_after.dat", "w");
    -
    543  for (el = ABS(spin); el < L; ++el) {
    -
    544  for (m = -el; m <= el; ++m){
    -
    545  ssht_sampling_elm2ind(&lm_ind, el, m);
    -
    546  fprintf(fp2, "%d, %d, %d, %f, %f\n",el,m,lm_ind, creal(flm_rec[lm_ind]), cimag(flm_rec[lm_ind]));
    -
    547  }
    -
    548  }
    -
    549  fclose(fp2);
    -
    550 
    -
    551  // Compute the maximum absolute error on the harmonic coefficients
    -
    552  printf(" - Maximum abs error : %6.5e\n",
    -
    553  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    554 
    -
    555  free(flm);
    -
    556  free(flm_rec);
    -
    557  free(f_wav_lmn);
    -
    558  free(f_scal_lm);
    -
    559  free(psi);
    -
    560  free(phi);
    -
    561 }
    -
    562 
    -
    563 
    -
    573 void s2let_transform_axisym_wav_test(int B, int L, int J_min, int seed)
    -
    574 {
    -
    575  s2let_parameters_t parameters = {};
    -
    576  parameters.B = B;
    -
    577  parameters.L = L;
    -
    578  parameters.J_min = J_min;
    -
    579 
    -
    580  clock_t time_start, time_end;
    -
    581  int spin = 0;
    -
    582  int verbosity = 0;
    -
    583  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    584  //int J = s2let_j_max(L, B);
    -
    585 
    -
    586  complex double *f, *f_rec, *flm, *flm_rec;
    -
    587  s2let_allocate_lm(&flm, L);
    -
    588  s2let_allocate_lm(&flm_rec, L);
    -
    589  s2let_allocate_mw(&f, L);
    -
    590  s2let_allocate_mw(&f_rec, L);
    -
    591 
    -
    592  // Generate random harmonic coefficients for a complex signal
    -
    593  s2let_lm_random_flm(flm, L, 0, seed);
    -
    594 
    -
    595  // Construct the corresponding signal on the sphere (MW sampling)
    -
    596  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    597 
    -
    598  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    599  complex double *f_wav, *f_scal;
    -
    600  s2let_transform_axisym_allocate_mw_f_wav(&f_wav, &f_scal, &parameters);
    -
    601 
    -
    602  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    603  time_start = clock();
    -
    604  s2let_transform_axisym_wav_analysis_mw(f_wav, f_scal, f, &parameters);
    -
    605  time_end = clock();
    -
    606  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    607  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    608 
    -
    609  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    610  time_start = clock();
    -
    611  s2let_transform_axisym_wav_synthesis_mw(f_rec, f_wav, f_scal, &parameters);
    -
    612  time_end = clock();
    -
    613  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    614  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    615 
    -
    616  // Compute the initial harmonic coefficients back
    -
    617  ssht_core_mw_forward_sov_conv_sym(flm_rec, f_rec, L, spin, dl_method, verbosity);
    -
    618 
    -
    619  // Compute the maximum absolute error on the harmonic coefficients
    -
    620  printf(" - Maximum abs error : %6.5e\n",
    -
    621  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    622 
    -
    623  free(f);
    -
    624  free(f_rec);
    -
    625  free(f_wav);
    -
    626  free(f_scal);
    -
    627 }
    -
    628 
    -
    638 void s2let_transform_axisym_wav_real_test(int B, int L, int J_min, int seed)
    -
    639 {
    -
    640  s2let_parameters_t parameters = {};
    -
    641  parameters.B = B;
    -
    642  parameters.L = L;
    -
    643  parameters.J_min = J_min;
    -
    644 
    -
    645  clock_t time_start, time_end;
    -
    646  int verbosity = 0;
    -
    647  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    648  //int J = s2let_j_max(L, B);
    -
    649 
    -
    650  complex *flm, *flm_rec;
    -
    651  double *f, *f_rec;
    -
    652  s2let_allocate_lm(&flm, L);
    -
    653  s2let_allocate_lm(&flm_rec, L);
    -
    654  s2let_allocate_mw_real(&f, L);
    -
    655  s2let_allocate_mw_real(&f_rec, L);
    -
    656 
    -
    657  // Generate random harmonic coefficients for a real signal
    -
    658  s2let_lm_random_flm_real(flm, L, seed);
    -
    659 
    -
    660  // Construct the corresponding signal on the sphere (MW sampling)
    -
    661  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    662 
    -
    663  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    664  double *f_wav, *f_scal;
    -
    665  s2let_transform_axisym_allocate_mw_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    666 
    -
    667  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    668  time_start = clock();
    -
    669  s2let_transform_axisym_wav_analysis_mw_real(f_wav, f_scal, f, &parameters);
    -
    670  time_end = clock();
    -
    671  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    672  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    673 
    -
    674  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    675  time_start = clock();
    -
    676  s2let_transform_axisym_wav_synthesis_mw_real(f_rec, f_wav, f_scal, &parameters);
    -
    677  time_end = clock();
    -
    678  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    679  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    680 
    -
    681  // Compute the initial harmonic coefficients back
    -
    682  ssht_core_mw_forward_sov_conv_sym_real(flm_rec, f_rec, L, dl_method, verbosity);
    -
    683 
    -
    684  // Compute the maximum absolute error on the harmonic coefficients
    -
    685  printf(" - Maximum abs error : %6.5e\n",
    -
    686  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    687 
    -
    688  free(f);
    -
    689  free(f_rec);
    -
    690  free(f_wav);
    -
    691  free(f_scal);
    -
    692 }
    -
    693 
    -
    694 
    -
    704 void s2let_transform_axisym_wav_multires_test(int B, int L, int J_min, int seed)
    -
    705 {
    -
    706  s2let_parameters_t parameters = {};
    -
    707  parameters.B = B;
    -
    708  parameters.L = L;
    -
    709  parameters.J_min = J_min;
    -
    710 
    -
    711  clock_t time_start, time_end;
    -
    712  int spin = 0;
    -
    713  int verbosity = 0;
    -
    714  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    715  //int J = s2let_j_max(L, B);
    -
    716 
    -
    717  complex double *f, *f_rec, *flm, *flm_rec;
    -
    718  s2let_allocate_lm(&flm, L);
    -
    719  s2let_allocate_lm(&flm_rec, L);
    -
    720  s2let_allocate_mw(&f, L);
    -
    721  s2let_allocate_mw(&f_rec, L);
    -
    722 
    -
    723  // Generate random harmonic coefficients for a complex signal
    -
    724  s2let_lm_random_flm(flm, L, 0, seed);
    -
    725 
    -
    726  // Construct the corresponding signal on the sphere (MW sampling)
    -
    727  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    728 
    -
    729  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    730  complex double *f_wav, *f_scal;
    -
    731  s2let_transform_axisym_allocate_mw_f_wav_multires(&f_wav, &f_scal, &parameters);
    -
    732 
    -
    733  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    734  time_start = clock();
    -
    735  s2let_transform_axisym_wav_analysis_mw_multires(f_wav, f_scal, f, &parameters);
    -
    736  time_end = clock();
    -
    737  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    738  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    739 
    -
    740  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    741  time_start = clock();
    -
    742  s2let_transform_axisym_wav_synthesis_mw_multires(f_rec, f_wav, f_scal, &parameters);
    -
    743  time_end = clock();
    -
    744  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    745  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    746 
    -
    747  // Compute the initial harmonic coefficients back
    -
    748  ssht_core_mw_forward_sov_conv_sym(flm_rec, f_rec, L, spin, dl_method, verbosity);
    -
    749 
    -
    750  // Compute the maximum absolute error on the harmonic coefficients
    -
    751  printf(" - Maximum abs error : %6.5e\n",
    -
    752  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    753 
    -
    754  free(f);
    -
    755  free(f_rec);
    -
    756  free(f_wav);
    -
    757  free(f_scal);
    -
    758 }
    -
    759 
    -
    760 
    -
    770 void s2let_transform_axisym_wav_multires_real_test(int B, int L, int J_min, int seed)
    -
    771 {
    -
    772  s2let_parameters_t parameters = {};
    -
    773  parameters.B = B;
    -
    774  parameters.L = L;
    -
    775  parameters.J_min = J_min;
    -
    776 
    -
    777  clock_t time_start, time_end;
    -
    778  int verbosity = 0;
    -
    779  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    780  //int J = s2let_j_max(L, B);
    -
    781 
    -
    782  complex *flm, *flm_rec;
    -
    783  double *f, *f_rec;
    -
    784  s2let_allocate_lm(&flm, L);
    -
    785  s2let_allocate_lm(&flm_rec, L);
    -
    786  s2let_allocate_mw_real(&f, L);
    -
    787  s2let_allocate_mw_real(&f_rec, L);
    -
    788 
    -
    789  // Generate random harmonic coefficients for a real signal
    -
    790  s2let_lm_random_flm_real(flm, L, seed);
    -
    791 
    -
    792  // Construct the corresponding signal on the sphere (MW sampling)
    -
    793  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    794 
    -
    795  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    796  double *f_wav, *f_scal;
    -
    797  s2let_transform_axisym_allocate_mw_f_wav_multires_real(&f_wav, &f_scal, &parameters);
    -
    798 
    -
    799  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    800  time_start = clock();
    -
    801  s2let_transform_axisym_wav_analysis_mw_multires_real(f_wav, f_scal, f, &parameters);
    -
    802  time_end = clock();
    -
    803  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    804  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    805 
    -
    806  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    807  time_start = clock();
    -
    808  s2let_transform_axisym_wav_synthesis_mw_multires_real(f_rec, f_wav, f_scal, &parameters);
    -
    809  time_end = clock();
    -
    810  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    811  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    812 
    -
    813  // Compute the initial harmonic coefficients back
    -
    814  ssht_core_mw_forward_sov_conv_sym_real(flm_rec, f_rec, L, dl_method, verbosity);
    -
    815 
    -
    816  // Compute the maximum absolute error on the harmonic coefficients
    -
    817  printf(" - Maximum abs error : %6.5e\n",
    -
    818  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    819 
    -
    820  free(f);
    -
    821  free(f_rec);
    -
    822  free(f_wav);
    -
    823  free(f_scal);
    -
    824 }
    -
    825 
    -
    838 void s2let_wav_transform_mw_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    839 {
    -
    840  clock_t time_start, time_end;
    -
    841 
    -
    842  s2let_parameters_t parameters = {};
    -
    843  parameters.B = B;
    -
    844  parameters.L = L;
    -
    845  parameters.J_min = J_min;
    -
    846  parameters.N = N;
    -
    847  parameters.spin = spin;
    -
    848  parameters.upsample = 1;
    -
    849  parameters.original_spin = 0;
    -
    850 
    -
    851  int verbosity = parameters.verbosity = 0;
    -
    852  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    853  //int J = s2let_j_max(L, B);
    -
    854 
    -
    855  complex double *f, *f_rec, *flm, *flm_rec;
    -
    856  s2let_allocate_lm(&flm, L);
    -
    857  s2let_allocate_lm(&flm_rec, L);
    -
    858  s2let_allocate_mw(&f, L);
    -
    859  s2let_allocate_mw(&f_rec, L);
    -
    860 
    -
    861  // Generate random harmonic coefficients for a complex signal
    -
    862  s2let_lm_random_flm(flm, L, spin, seed);
    -
    863 
    -
    864  // Construct the corresponding signal on the sphere (MW sampling)
    -
    865  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    866 
    -
    867  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    868  complex double *f_wav, *f_scal;
    -
    869  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    870 
    -
    871  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    872  time_start = clock();
    -
    873  s2let_analysis_px2wav(f_wav, f_scal, f, &parameters);
    -
    874  time_end = clock();
    -
    875  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    876  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    877 
    -
    878  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    879  time_start = clock();
    -
    880  s2let_synthesis_wav2px(f_rec, f_wav, f_scal, &parameters);
    -
    881  time_end = clock();
    -
    882  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    883  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    884 
    -
    885  // Convert back to harmonic coefficients
    -
    886  ssht_core_mw_forward_sov_conv_sym(flm_rec, f_rec, L, spin, dl_method, verbosity);
    -
    887 
    -
    888  // Compute the maximum absolute error on the harmonic coefficients
    -
    889  printf(" - Maximum abs error : %6.5e\n",
    -
    890  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    891 
    -
    892  free(f);
    -
    893  free(f_rec);
    -
    894  free(flm);
    -
    895  free(flm_rec);
    -
    896  free(f_wav);
    -
    897  free(f_scal);
    -
    898 }
    -
    899 
    -
    900 complex double s2let_dot_product_complex(complex double* v1, complex double* v2, int N_length)
    -
    901 {
    -
    902 
    -
    903  complex long double dot_product= 0.0;
    -
    904  int i;
    -
    905 
    -
    906  for (i=0; i<N_length; i++)
    -
    907  {
    -
    908  dot_product += conj(v1[i])*v2[i];
    -
    909  // if ((i%200)==0){
    -
    910  // printf(" %6.5e i%6.5e",
    -
    911  // creal(v1[i]), cimag(v1[i]));fflush(NULL);
    -
    912  // printf(" %6.5e i%6.5e",
    -
    913  // creal(v2[i]), cimag(v2[i]));fflush(NULL);
    -
    914  // printf(" %6.5e i%6.5e\n",
    -
    915  // creal(dot_product), cimag(dot_product));fflush(NULL);}
    -
    916  }
    -
    917  return dot_product;
    -
    918 
    -
    919 }
    -
    920 
    -
    921 complex double s2let_dot_product_real(double* v1, double* v2, int N_length)
    -
    922 {
    -
    923 
    -
    924  long double dot_product= 0.0;
    -
    925  int i;
    -
    926 
    -
    927  for (i=0; i<N_length; i++)
    -
    928  {
    -
    929  dot_product += v1[i]*v2[i];
    -
    930  }
    -
    931  return dot_product;
    -
    932 
    -
    933 }
    -
    934 
    -
    947 void s2let_wav_analysis_adjoint_lm_lmn_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    948 {
    -
    949  clock_t time_start, time_end;
    -
    950 
    -
    951  s2let_parameters_t parameters = {};
    -
    952  parameters.B = B;
    -
    953  parameters.L = L;
    -
    954  parameters.J_min = J_min;
    -
    955  parameters.N = N;
    -
    956  parameters.spin = spin;
    -
    957  parameters.upsample = 0;
    -
    958  //parameters.normalization = S2LET_WAV_NORM_DEFAULT;
    -
    959  parameters.original_spin = 0;
    -
    960  parameters.sampling_scheme = S2LET_SAMPLING_MW;
    -
    961 
    -
    962  int verbosity = parameters.verbosity = 0;
    -
    963  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    964  //int J = s2let_j_max(L, B);
    -
    965 
    -
    966  complex double *flm, *flm_rec;
    -
    967  s2let_allocate_lm(&flm, L);
    -
    968  s2let_allocate_lm(&flm_rec, L);
    -
    969 
    -
    970  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    971  complex double *f_wav_lmn, *f_scal_lm, *f_wav_lmn_rec, *f_scal_lm_rec;
    -
    972  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &parameters);
    -
    973  s2let_allocate_lmn_f_wav(&f_wav_lmn_rec, &f_scal_lm_rec, &parameters);
    -
    974 
    -
    975  // Generate random harmonic coefficients for a complex signal
    -
    976  s2let_lm_random_flm(flm, L, spin, seed);
    -
    977  s2let_lm_random_flm(flm_rec, L, spin, seed);
    -
    978  // flm[0] = 1.0; flm_rec[0] = 1.0;
    -
    979 
    -
    980  complex double *wav_lm;
    -
    981  double *scal_l;
    -
    982  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &parameters);
    -
    983  s2let_tiling_wavelet(wav_lm, scal_l, &parameters);
    -
    984 
    -
    985  // Perform wavelet analysis to make f_wac_rec amd f_scal_rec
    -
    986  s2let_analysis_lm2lmn(f_wav_lmn_rec, f_scal_lm_rec, flm_rec, wav_lm, scal_l, &parameters);
    -
    987 
    -
    988 
    -
    989 
    -
    990  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    991  time_start = clock();
    -
    992 // s2let_synthesis_adjoint_px2wav(f_wav, f_scal, f, &parameters);
    -
    993  s2let_analysis_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, &parameters);
    -
    994  time_end = clock();
    -
    995  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    996  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    997 
    -
    998  // printf(" %6.5e i%6.5e\n",
    -
    999  // creal(f_wav[0]), cimag(f_wav[0]));fflush(NULL);
    -
    1000 
    -
    1001 
    -
    1002  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1003  time_start = clock();
    -
    1004  s2let_analysis_adjoint_lmn2lm(flm_rec, f_wav_lmn_rec, f_scal_lm_rec, wav_lm, scal_l, &parameters);
    -
    1005 // s2let_synthesis_wav2px(f_rec, f_wav_rec, f_scal_rec, &parameters);
    -
    1006  time_end = clock();
    -
    1007  printf(" - Wavelet analysis adjoint : %4.4f seconds\n",
    -
    1008  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1009 
    -
    1010  // printf(" %6.5e i%6.5e\n",
    -
    1011  // creal(f_rec[0]), cimag(f_rec[0]));fflush(NULL);
    -
    1012 
    -
    1013  // compute dot products of arrays
    -
    1014  complex double dot_product_error = 0.0;
    -
    1015  // dot_product_error = s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1016  // printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1017  // creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1018  dot_product_error = s2let_dot_product_complex(f_wav_lmn_rec, f_wav_lmn, s2let_n_lmn_wav(&parameters));
    -
    1019  dot_product_error += s2let_dot_product_complex(f_scal_lm_rec, f_scal_lm, s2let_n_lm_scal(&parameters));
    -
    1020  dot_product_error -= s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1021 
    -
    1022 
    -
    1023  // Compute the maximum absolute error on the harmonic coefficients
    -
    1024  printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1025  creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1026 
    -
    1027  free(flm);
    -
    1028  free(flm_rec);
    -
    1029  free(f_wav_lmn);
    -
    1030  free(f_scal_lm);
    -
    1031  free(f_wav_lmn_rec);
    -
    1032  free(f_scal_lm_rec);
    -
    1033 }
    -
    1034 
    -
    1047 void s2let_wav_synthesis_adjoint_lm_lmn_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    1048 {
    -
    1049  clock_t time_start, time_end;
    -
    1050 
    -
    1051  s2let_parameters_t parameters = {};
    -
    1052  parameters.B = B;
    -
    1053  parameters.L = L;
    -
    1054  parameters.J_min = J_min;
    -
    1055  parameters.N = N;
    -
    1056  parameters.spin = spin;
    -
    1057  parameters.upsample = 0;
    -
    1058  //parameters.normalization = S2LET_WAV_NORM_DEFAULT;
    -
    1059  parameters.original_spin = 0;
    -
    1060  parameters.sampling_scheme = S2LET_SAMPLING_MW;
    -
    1061 
    -
    1062  int verbosity = parameters.verbosity = 0;
    -
    1063  int i;
    -
    1064  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1065  //int J = s2let_j_max(L, B);
    -
    1066 
    -
    1067  complex double *flm, *flm_rec;
    -
    1068  s2let_allocate_lm(&flm, L);
    -
    1069  s2let_allocate_lm(&flm_rec, L);
    -
    1070 
    -
    1071  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1072  complex double *f_wav_lmn, *f_scal_lm, *f_wav_lmn_rec, *f_scal_lm_rec;
    -
    1073  s2let_allocate_lmn_f_wav(&f_wav_lmn, &f_scal_lm, &parameters);
    -
    1074  s2let_allocate_lmn_f_wav(&f_wav_lmn_rec, &f_scal_lm_rec, &parameters);
    -
    1075 
    -
    1076  // Generate random harmonic coefficients for a complex signal
    -
    1077  s2let_lm_random_flm(flm, L, spin, seed);
    -
    1078  s2let_lm_random_flm(flm_rec, L, spin, seed);
    -
    1079  // flm[0] = 1.0; flm_rec[0] = 1.0;
    -
    1080 
    -
    1081  complex double *wav_lm;
    -
    1082  double *scal_l;
    -
    1083  s2let_tiling_wavelet_allocate(&wav_lm, &scal_l, &parameters);
    -
    1084  s2let_tiling_wavelet(wav_lm, scal_l, &parameters);
    -
    1085 
    -
    1086  // Perform wavelet analysis to make f_wac_rec amd f_scal_rec
    -
    1087  s2let_analysis_lm2lmn(f_wav_lmn_rec, f_scal_lm_rec, flm_rec, wav_lm, scal_l, &parameters);
    -
    1088 
    -
    1089 
    -
    1090 
    -
    1091  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1092  time_start = clock();
    -
    1093 // s2let_synthesis_adjoint_px2wav(f_wav, f_scal, f, &parameters);
    -
    1094  s2let_synthesis_adjoint_lm2lmn(f_wav_lmn, f_scal_lm, flm, wav_lm, scal_l, &parameters);
    -
    1095  for (i=0; i<s2let_n_lmn_wav(&parameters); i++) if (abs(f_wav_lmn[i])>1E2) {printf("f_wav_lmn %6.5e i%6.5e\n", creal(f_wav_lmn[i]), cimag(f_wav_lmn[i]));fflush(NULL);}//
    -
    1096 
    -
    1097  time_end = clock();
    -
    1098  printf(" - Wavelet synthesis adjoint : %4.4f seconds\n",
    -
    1099  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1100 
    -
    1101  // printf(" %6.5e i%6.5e\n",
    -
    1102  // creal(f_wav[0]), cimag(f_wav[0]));fflush(NULL);
    -
    1103 
    -
    1104 
    -
    1105  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1106  time_start = clock();
    -
    1107  s2let_synthesis_lmn2lm(flm_rec, f_wav_lmn_rec, f_scal_lm_rec, wav_lm, scal_l, &parameters);
    -
    1108 // s2let_synthesis_wav2px(f_rec, f_wav_rec, f_scal_rec, &parameters);
    -
    1109  time_end = clock();
    -
    1110  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    1111  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1112 
    -
    1113  // printf(" %6.5e i%6.5e\n",
    -
    1114  // creal(f_rec[0]), cimag(f_rec[0]));fflush(NULL);
    -
    1115 
    -
    1116  // compute dot products of arrays
    -
    1117  complex double dot_product_error = 0.0;
    -
    1118  // dot_product_error = s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1119  // printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1120  // creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1121  dot_product_error = s2let_dot_product_complex(f_wav_lmn_rec, f_wav_lmn, s2let_n_lmn_wav(&parameters));
    -
    1122  dot_product_error += s2let_dot_product_complex(f_scal_lm_rec, f_scal_lm, s2let_n_lm_scal(&parameters));
    -
    1123  dot_product_error -= s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1124 
    -
    1125 
    -
    1126  // Compute the maximum absolute error on the harmonic coefficients
    -
    1127  printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1128  creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1129 
    -
    1130  free(flm);
    -
    1131  free(flm_rec);
    -
    1132  free(f_wav_lmn);
    -
    1133  free(f_scal_lm);
    -
    1134  free(f_wav_lmn_rec);
    -
    1135  free(f_scal_lm_rec);
    -
    1136 }
    -
    1137 
    -
    1138 
    -
    1139 void s2let_wav_analysis_adjoint_mw_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    1140 {
    -
    1141  clock_t time_start, time_end;
    -
    1142 
    -
    1143  s2let_parameters_t parameters = {};
    -
    1144  parameters.B = B;
    -
    1145  parameters.L = L;
    -
    1146  parameters.J_min = J_min;
    -
    1147  parameters.N = N;
    -
    1148  parameters.spin = spin;
    -
    1149  parameters.upsample = 1;
    -
    1150  //parameters.normalization = S2LET_WAV_NORM_DEFAULT;
    -
    1151  parameters.original_spin = 0;
    -
    1152  parameters.sampling_scheme = S2LET_SAMPLING_MW;
    -
    1153 
    -
    1154  int verbosity = parameters.verbosity = 0;
    -
    1155  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1156  //int J = s2let_j_max(L, B);
    -
    1157 
    -
    1158  complex double *f, *f_rec, *flm, *flm_rec;
    -
    1159  s2let_allocate_lm(&flm, L);
    -
    1160  s2let_allocate_lm(&flm_rec, L);
    -
    1161  s2let_allocate_mw(&f, L);
    -
    1162  s2let_allocate_mw(&f_rec, L);
    -
    1163 
    -
    1164  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1165  complex double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec;
    -
    1166  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    1167  s2let_allocate_f_wav(&f_wav_rec, &f_scal_rec, &parameters);
    -
    1168 
    -
    1169  // Generate random harmonic coefficients for a complex signal
    -
    1170  s2let_lm_random_flm(flm, L, spin, seed);
    -
    1171  s2let_lm_random_flm(flm_rec, L, spin, seed);
    -
    1172  // flm[0] = 1.0; flm_rec[0] = 1.0;
    -
    1173 
    -
    1174  // Construct the corresponding signal on the sphere (MW sampling)
    -
    1175  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    1176  ssht_core_mw_inverse_sov_sym(f_rec, flm_rec, L, spin, dl_method, verbosity);
    -
    1177 
    -
    1178  // Perform wavelet analysis to make f_wac_rec amd f_scal_rec
    -
    1179  s2let_analysis_px2wav(f_wav_rec, f_scal_rec, f_rec, &parameters);
    -
    1180 
    -
    1181 
    -
    1182 
    -
    1183  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1184  time_start = clock();
    -
    1185  s2let_analysis_px2wav(f_wav, f_scal, f, &parameters);
    -
    1186  time_end = clock();
    -
    1187  printf(" - Wavelet synthesis adjoint : %4.4f seconds\n",
    -
    1188  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1189 
    -
    1190 
    -
    1191 
    -
    1192  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1193  time_start = clock();
    -
    1194  s2let_analysis_adjoint_wav2px(f_rec, f_wav_rec, f_scal_rec, &parameters);
    -
    1195  time_end = clock();
    -
    1196  printf(" - Wavelet analysis adjoint : %4.4f seconds\n",
    -
    1197  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1198 
    -
    1199  // printf(" %6.5e i%6.5e\n",
    -
    1200  // creal(f_rec[0]), cimag(f_rec[0]));fflush(NULL);
    -
    1201 
    -
    1202  // compute dot products of arrays
    -
    1203  complex double dot_product_error = 0.0;
    -
    1204  // dot_product_error = s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1205  // printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1206  // creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1207  dot_product_error = s2let_dot_product_complex(f_wav_rec, f_wav, s2let_n_wav(&parameters));
    -
    1208  dot_product_error += s2let_dot_product_complex(f_scal_rec, f_scal, s2let_n_scal(&parameters));
    -
    1209  dot_product_error -= s2let_dot_product_complex(f_rec, f, L*(2*L-1));
    -
    1210 
    -
    1211 
    -
    1212  // Compute the maximum absolute error on the harmonic coefficients
    -
    1213  printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1214  creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1215 
    -
    1216  free(f);
    -
    1217  free(f_rec);
    -
    1218  free(flm);
    -
    1219  free(flm_rec);
    -
    1220  free(f_wav);
    -
    1221  free(f_scal);
    -
    1222  free(f_wav_rec);
    -
    1223  free(f_scal_rec);
    -
    1224 }
    -
    1225 
    -
    1226 
    -
    1227 
    -
    1228 void s2let_wav_analysis_adjoint_mw_real_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    1229 {
    -
    1230  clock_t time_start, time_end;
    -
    1231 
    -
    1232  s2let_parameters_t parameters = {};
    -
    1233  parameters.B = B;
    -
    1234  parameters.L = L;
    -
    1235  parameters.J_min = J_min;
    -
    1236  parameters.N = N;
    -
    1237  parameters.spin = spin;
    -
    1238  parameters.upsample = 1;
    -
    1239  //parameters.normalization = S2LET_WAV_NORM_DEFAULT;
    -
    1240  parameters.original_spin = 0;
    -
    1241  parameters.sampling_scheme = S2LET_SAMPLING_MW;
    -
    1242 
    -
    1243  int verbosity = parameters.verbosity = 0;
    -
    1244  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1245  //int J = s2let_j_max(L, B);
    -
    1246 
    -
    1247  double *f, *f_rec;
    -
    1248  complex double *flm, *flm_rec;
    -
    1249  s2let_allocate_lm(&flm, L);
    -
    1250  s2let_allocate_lm(&flm_rec, L);
    -
    1251  s2let_allocate_mw(&f, L);
    -
    1252  s2let_allocate_mw(&f_rec, L);
    -
    1253 
    -
    1254  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1255  double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec;
    -
    1256  s2let_allocate_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    1257  s2let_allocate_f_wav_real(&f_wav_rec, &f_scal_rec, &parameters);
    -
    1258 
    -
    1259  // Generate random harmonic coefficients for a complex signal
    -
    1260  s2let_lm_random_flm_real(flm, L, seed);
    -
    1261  s2let_lm_random_flm_real(flm_rec, L, seed);
    -
    1262  // flm[0] = 1.0; flm_rec[0] = 1.0;
    -
    1263 
    -
    1264  // Construct the corresponding signal on the sphere (MW sampling)
    -
    1265  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    1266  ssht_core_mw_inverse_sov_sym_real(f_rec, flm_rec, L, dl_method, verbosity);
    -
    1267 
    -
    1268  // Perform wavelet analysis to make f_wac_rec amd f_scal_rec
    -
    1269  s2let_analysis_px2wav_real(f_wav_rec, f_scal_rec, f_rec, &parameters);
    -
    1270 
    -
    1271 
    -
    1272 
    -
    1273  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1274  time_start = clock();
    -
    1275  s2let_analysis_px2wav_real(f_wav, f_scal, f, &parameters);
    -
    1276  time_end = clock();
    -
    1277  printf(" - Wavelet synthesis adjoint : %4.4f seconds\n",
    -
    1278  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1279 
    -
    1280 
    -
    1281 
    -
    1282  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1283  time_start = clock();
    -
    1284  s2let_analysis_adjoint_wav2px_real(f_rec, f_wav_rec, f_scal_rec, &parameters);
    -
    1285  time_end = clock();
    -
    1286  printf(" - Wavelet analysis adjoint : %4.4f seconds\n",
    -
    1287  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1288 
    -
    1289  // printf(" %6.5e i%6.5e\n",
    -
    1290  // creal(f_rec[0]), cimag(f_rec[0]));fflush(NULL);
    -
    1291 
    -
    1292  // compute dot products of arrays
    -
    1293  double dot_product_error = 0.0;
    -
    1294  // dot_product_error = s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1295  // printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1296  // creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1297  dot_product_error = s2let_dot_product_real(f_wav_rec, f_wav, s2let_n_wav(&parameters));
    -
    1298  dot_product_error += s2let_dot_product_real(f_scal_rec, f_scal, s2let_n_scal(&parameters));
    -
    1299  dot_product_error -= s2let_dot_product_real(f_rec, f, L*(2*L-1));
    -
    1300 
    -
    1301 
    -
    1302  // Compute the maximum absolute error on the harmonic coefficients
    -
    1303  printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1304  creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1305 
    -
    1306  free(f);
    -
    1307  free(f_rec);
    -
    1308  free(flm);
    -
    1309  free(flm_rec);
    -
    1310  free(f_wav);
    -
    1311  free(f_scal);
    -
    1312  free(f_wav_rec);
    -
    1313  free(f_scal_rec);
    -
    1314 }
    -
    1315 
    -
    1316 
    -
    1317 
    -
    1318 void s2let_wav_synthesis_adjoint_lm2wav_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    1319 {
    -
    1320  clock_t time_start, time_end;
    -
    1321 
    -
    1322  s2let_parameters_t parameters = {};
    -
    1323  parameters.B = B;
    -
    1324  parameters.L = L;
    -
    1325  parameters.J_min = J_min;
    -
    1326  parameters.N = N;
    -
    1327  parameters.spin = spin;
    -
    1328  parameters.upsample = 0;
    -
    1329  //parameters.normalization = S2LET_WAV_NORM_DEFAULT;
    -
    1330  parameters.original_spin = 0;
    -
    1331  parameters.sampling_scheme = S2LET_SAMPLING_MW;
    -
    1332 
    -
    1333  int verbosity = parameters.verbosity = 0;
    -
    1334  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1335  //int J = s2let_j_max(L, B);
    -
    1336 
    -
    1337  complex double *f, *f_rec, *flm, *flm_rec;
    -
    1338  s2let_allocate_lm(&flm, L);
    -
    1339  s2let_allocate_lm(&flm_rec, L);
    -
    1340  s2let_allocate_mw(&f, L);
    -
    1341  s2let_allocate_mw(&f_rec, L);
    -
    1342 
    -
    1343  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1344  complex double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec;
    -
    1345  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    1346  s2let_allocate_f_wav(&f_wav_rec, &f_scal_rec, &parameters);
    -
    1347 
    -
    1348  // Generate random harmonic coefficients for a complex signal
    -
    1349  s2let_lm_random_flm(flm, L, spin, seed);
    -
    1350  s2let_lm_random_flm(flm_rec, L, spin, seed);
    -
    1351  // flm[0] = 1.0; flm_rec[0] = 1.0;
    -
    1352 
    -
    1353  // Construct the corresponding signal on the sphere (MW sampling)
    -
    1354  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    1355  ssht_core_mw_inverse_sov_sym(f_rec, flm_rec, L, spin, dl_method, verbosity);
    -
    1356 
    -
    1357  // Perform wavelet analysis to make f_wac_rec amd f_scal_rec
    -
    1358  s2let_analysis_px2wav(f_wav_rec, f_scal_rec, f_rec, &parameters);
    -
    1359 
    -
    1360 
    -
    1361 
    -
    1362  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1363  time_start = clock();
    -
    1364  s2let_synthesis_adjoint_lm2wav(f_wav, f_scal, flm, &parameters);
    -
    1365  time_end = clock();
    -
    1366  printf(" - Wavelet synthesis adjoint : %4.4f seconds\n",
    -
    1367  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1368 
    -
    1369  // printf(" %6.5e i%6.5e\n",
    -
    1370  // creal(f_wav[0]), cimag(f_wav[0]));fflush(NULL);
    -
    1371 
    -
    1372 
    -
    1373  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1374  time_start = clock();
    -
    1375  s2let_synthesis_wav2lm(flm_rec, f_wav_rec, f_scal_rec, &parameters);
    -
    1376  time_end = clock();
    -
    1377  printf(" - Wavelet analysis adjoint : %4.4f seconds\n",
    -
    1378  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1379 
    -
    1380  // printf(" %6.5e i%6.5e\n",
    -
    1381  // creal(f_rec[0]), cimag(f_rec[0]));fflush(NULL);
    -
    1382 
    -
    1383  // compute dot products of arrays
    -
    1384  complex double dot_product_error = 0.0;
    -
    1385  // dot_product_error = s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1386  // printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1387  // creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1388  dot_product_error = s2let_dot_product_complex(f_wav_rec, f_wav, s2let_n_wav(&parameters));
    -
    1389  dot_product_error += s2let_dot_product_complex(f_scal_rec, f_scal, s2let_n_scal(&parameters));
    -
    1390  dot_product_error -= s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1391 
    -
    1392 
    -
    1393  // Compute the maximum absolute error on the harmonic coefficients
    -
    1394  printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1395  creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1396 
    -
    1397  free(f);
    -
    1398  free(f_rec);
    -
    1399  free(flm);
    -
    1400  free(flm_rec);
    -
    1401  free(f_wav);
    -
    1402  free(f_scal);
    -
    1403  free(f_wav_rec);
    -
    1404  free(f_scal_rec);
    -
    1405 }
    -
    1406 
    -
    1407 void s2let_wav_synthesis_adjoint_mw_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    1408 {
    -
    1409  clock_t time_start, time_end;
    -
    1410 
    -
    1411  s2let_parameters_t parameters = {};
    -
    1412  parameters.B = B;
    -
    1413  parameters.L = L;
    -
    1414  parameters.J_min = J_min;
    -
    1415  parameters.N = N;
    -
    1416  parameters.spin = spin;
    -
    1417  parameters.upsample = 1;
    -
    1418  //parameters.normalization = S2LET_WAV_NORM_DEFAULT;
    -
    1419  parameters.original_spin = 0;
    -
    1420  parameters.sampling_scheme = S2LET_SAMPLING_MW;
    -
    1421 
    -
    1422  int verbosity = parameters.verbosity = 0;
    -
    1423  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1424  //int J = s2let_j_max(L, B);
    -
    1425 
    -
    1426  complex double *f, *f_rec, *flm, *flm_rec;
    -
    1427  s2let_allocate_lm(&flm, L);
    -
    1428  s2let_allocate_lm(&flm_rec, L);
    -
    1429  s2let_allocate_mw(&f, L);
    -
    1430  s2let_allocate_mw(&f_rec, L);
    -
    1431 
    -
    1432  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1433  complex double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec;
    -
    1434  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    1435  s2let_allocate_f_wav(&f_wav_rec, &f_scal_rec, &parameters);
    -
    1436 
    -
    1437  // Generate random harmonic coefficients for a complex signal
    -
    1438  s2let_lm_random_flm(flm, L, spin, seed);
    -
    1439  s2let_lm_random_flm(flm_rec, L, spin, seed);
    -
    1440  // flm[0] = 1.0; flm_rec[0] = 1.0;
    -
    1441 
    -
    1442  // Construct the corresponding signal on the sphere (MW sampling)
    -
    1443  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    1444  ssht_core_mw_inverse_sov_sym(f_rec, flm_rec, L, spin, dl_method, verbosity);
    -
    1445 
    -
    1446  // Perform wavelet analysis to make f_wac_rec amd f_scal_rec
    -
    1447  s2let_analysis_lm2wav(f_wav_rec, f_scal_rec, flm_rec, &parameters);
    -
    1448 
    -
    1449 
    -
    1450 
    -
    1451  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1452  time_start = clock();
    -
    1453  s2let_synthesis_adjoint_px2wav(f_wav, f_scal, f, &parameters);
    -
    1454  time_end = clock();
    -
    1455  printf(" - Wavelet synthesis adjoint : %4.4f seconds\n",
    -
    1456  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1457 
    -
    1458  // printf(" %6.5e i%6.5e\n",
    -
    1459  // creal(f_wav[0]), cimag(f_wav[0]));fflush(NULL);
    -
    1460 
    -
    1461 
    -
    1462  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1463  time_start = clock();
    -
    1464  s2let_synthesis_wav2px(f_rec, f_wav_rec, f_scal_rec, &parameters);
    -
    1465  time_end = clock();
    -
    1466  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    1467  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1468 
    -
    1469  // printf(" %6.5e i%6.5e\n",
    -
    1470  // creal(f_rec[0]), cimag(f_rec[0]));fflush(NULL);
    -
    1471 
    -
    1472  // compute dot products of arrays
    -
    1473  complex double dot_product_error = 0.0;
    -
    1474  // dot_product_error = s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1475  // printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1476  // creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1477  dot_product_error = s2let_dot_product_complex(f_wav_rec, f_wav, s2let_n_wav(&parameters));
    -
    1478  dot_product_error += s2let_dot_product_complex(f_scal_rec, f_scal, s2let_n_scal(&parameters));
    -
    1479  dot_product_error -= s2let_dot_product_complex(f_rec, f, L*(2*L-1));
    -
    1480 
    -
    1481 
    -
    1482  // Compute the maximum absolute error on the harmonic coefficients
    -
    1483  printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1484  creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1485 
    -
    1486  free(f);
    -
    1487  free(f_rec);
    -
    1488  free(flm);
    -
    1489  free(flm_rec);
    -
    1490  free(f_wav);
    -
    1491  free(f_scal);
    -
    1492  free(f_wav_rec);
    -
    1493  free(f_scal_rec);
    -
    1494 }
    -
    1495 
    -
    1496 void s2let_wav_synthesis_adjoint_mw_real_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    1497 {
    -
    1498  clock_t time_start, time_end;
    -
    1499 
    -
    1500  s2let_parameters_t parameters = {};
    -
    1501  parameters.B = B;
    -
    1502  parameters.L = L;
    -
    1503  parameters.J_min = J_min;
    -
    1504  parameters.N = N;
    -
    1505  parameters.spin = spin;
    -
    1506  parameters.upsample = 1;
    -
    1507  //parameters.normalization = S2LET_WAV_NORM_DEFAULT;
    -
    1508  parameters.original_spin = 0;
    -
    1509  parameters.sampling_scheme = S2LET_SAMPLING_MW;
    -
    1510 
    -
    1511  int verbosity = parameters.verbosity = 0;
    -
    1512  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1513  //int J = s2let_j_max(L, B);
    -
    1514 
    -
    1515  double *f, *f_rec;
    -
    1516  complex double *flm, *flm_rec;
    -
    1517  s2let_allocate_lm(&flm, L);
    -
    1518  s2let_allocate_lm(&flm_rec, L);
    -
    1519  s2let_allocate_mw_real(&f, L);
    -
    1520  s2let_allocate_mw_real(&f_rec, L);
    -
    1521 
    -
    1522  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1523  double *f_wav, *f_scal, *f_wav_rec, *f_scal_rec;
    -
    1524  s2let_allocate_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    1525  s2let_allocate_f_wav_real(&f_wav_rec, &f_scal_rec, &parameters);
    -
    1526 
    -
    1527  // Generate random harmonic coefficients for a complex signal
    -
    1528  s2let_lm_random_flm_real(flm, L, seed);
    -
    1529  s2let_lm_random_flm_real(flm_rec, L, seed);
    -
    1530  // flm[0] = 1.0; flm_rec[0] = 1.0;
    -
    1531 
    -
    1532  // Construct the corresponding signal on the sphere (MW sampling)
    -
    1533  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    1534  ssht_core_mw_inverse_sov_sym_real(f_rec, flm_rec, L, dl_method, verbosity);
    -
    1535 
    -
    1536  // Perform wavelet analysis to make f_wac_rec amd f_scal_rec
    -
    1537  s2let_analysis_px2wav_real(f_wav_rec, f_scal_rec, f_rec, &parameters);
    -
    1538 
    -
    1539 
    -
    1540 
    -
    1541  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1542  time_start = clock();
    -
    1543  s2let_synthesis_adjoint_px2wav_real(f_wav, f_scal, f, &parameters);
    -
    1544  time_end = clock();
    -
    1545  printf(" - Wavelet synthesis adjoint : %4.4f seconds\n",
    -
    1546  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1547 
    -
    1548  // printf(" %6.5e i%6.5e\n",
    -
    1549  // creal(f_wav[0]), cimag(f_wav[0]));fflush(NULL);
    -
    1550 
    -
    1551 
    -
    1552  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1553  time_start = clock();
    -
    1554  s2let_synthesis_wav2px_real(f_rec, f_wav_rec, f_scal_rec, &parameters);
    -
    1555  time_end = clock();
    -
    1556  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    1557  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1558 
    -
    1559  // printf(" %6.5e i%6.5e\n",
    -
    1560  // creal(f_rec[0]), cimag(f_rec[0]));fflush(NULL);
    -
    1561 
    -
    1562  // compute dot products of arrays
    -
    1563  double dot_product_error = 0.0;
    -
    1564  // dot_product_error = s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1565  // printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1566  // creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1567  dot_product_error = s2let_dot_product_real(f_wav_rec, f_wav, s2let_n_wav(&parameters));
    -
    1568  dot_product_error += s2let_dot_product_real(f_scal_rec, f_scal, s2let_n_scal(&parameters));
    -
    1569  dot_product_error -= s2let_dot_product_real(f_rec, f, L*(2*L-1));
    -
    1570 
    -
    1571 
    -
    1572  // Compute the maximum absolute error on the harmonic coefficients
    -
    1573  printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1574  creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1575 
    -
    1576  free(f);
    -
    1577  free(f_rec);
    -
    1578  free(flm);
    -
    1579  free(flm_rec);
    -
    1580  free(f_wav);
    -
    1581  free(f_scal);
    -
    1582  free(f_wav_rec);
    -
    1583  free(f_scal_rec);
    -
    1584 }
    -
    1585 void so3_test_gen_flmn_complex(
    -
    1586  complex double *flmn,
    -
    1587  const so3_parameters_t *parameters,
    -
    1588  int seed)
    -
    1589 {
    -
    1590  int L0, L, N;
    -
    1591  int i, el, m, n, n_start, n_stop, n_inc, ind;
    -
    1592 
    -
    1593  L0 = parameters->L0;
    -
    1594  L = parameters->L;
    -
    1595  N = parameters->N;
    -
    1596 
    -
    1597  for (i = 0; i < (2*N-1)*L*L; ++i)
    -
    1598  flmn[i] = 0.0;
    -
    1599 
    -
    1600  switch (parameters->n_mode)
    -
    1601  {
    -
    1602  case SO3_N_MODE_ALL:
    -
    1603  n_start = -N+1;
    -
    1604  n_stop = N-1;
    -
    1605  n_inc = 1;
    -
    1606  break;
    -
    1607  case SO3_N_MODE_EVEN:
    -
    1608  n_start = ((N-1) % 2 == 0) ? -N+1 : -N+2;
    -
    1609  n_stop = ((N-1) % 2 == 0) ? N-1 : N-2;
    -
    1610  n_inc = 2;
    -
    1611  break;
    -
    1612  case SO3_N_MODE_ODD:
    -
    1613  n_start = ((N-1) % 2 != 0) ? -N+1 : -N+2;
    -
    1614  n_stop = ((N-1) % 2 != 0) ? N-1 : N-2;
    -
    1615  n_inc = 2;
    -
    1616  break;
    -
    1617  case SO3_N_MODE_MAXIMUM:
    -
    1618  n_start = -N+1;
    -
    1619  n_stop = N-1;
    -
    1620  n_inc = 2*N - 2;
    -
    1621  break;
    -
    1622  default:
    -
    1623  SO3_ERROR_GENERIC("Invalid n-mode.");
    -
    1624  }
    -
    1625 
    -
    1626  for (n = n_start; n <= n_stop; n += n_inc)
    -
    1627  {
    -
    1628  for (el = MAX(L0, abs(n)); el < L; ++el)
    -
    1629  {
    -
    1630  for (m = -el; m <= el; ++m)
    -
    1631  {
    -
    1632  so3_sampling_elmn2ind(&ind, el, m, n, parameters);
    -
    1633  flmn[ind] = (2.0*ran2_dp(seed) - 1.0) + I * (2.0*ran2_dp(seed) - 1.0);
    -
    1634  }
    -
    1635  }
    -
    1636  }
    -
    1637 }
    -
    1638 void s2let_wav_so3_forward_adjoint_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    1639 {
    -
    1640  clock_t time_start, time_end;
    -
    1641 
    -
    1642  s2let_parameters_t parameters = {};
    -
    1643  parameters.B = B;
    -
    1644  parameters.L = L;
    -
    1645  parameters.J_min = J_min;
    -
    1646  parameters.N = N;
    -
    1647  parameters.spin = spin;
    -
    1648  parameters.upsample = 0;
    -
    1649  //parameters.normalization = S2LET_WAV_NORM_DEFAULT;
    -
    1650  parameters.original_spin = 0;
    -
    1651  parameters.sampling_scheme = S2LET_SAMPLING_MW;
    -
    1652 
    -
    1653  int verbosity = parameters.verbosity = 0;
    -
    1654  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1655  //int J = s2let_j_max(L, B);
    -
    1656 
    -
    1657  so3_parameters_t so3_parameters = {};
    -
    1658  fill_so3_parameters(&so3_parameters, &parameters);
    -
    1659 
    -
    1660  complex double *f, *f_rec, *flmn, *flmn_rec;
    -
    1661  // (2*N-1)*L*L is the largest number of flmn ever needed. For more
    -
    1662  // compact storage modes, only part of the memory will be used.
    -
    1663  flmn = malloc((2*N-1)*L*L * sizeof *flmn);
    -
    1664  SO3_ERROR_MEM_ALLOC_CHECK(flmn);
    -
    1665  flmn_rec = malloc((2*N-1)*L*L * sizeof *flmn_rec);
    -
    1666  SO3_ERROR_MEM_ALLOC_CHECK(flmn_rec);
    -
    1667 
    -
    1668  // We only need (2*L) * (L+1) * (2*N-1) samples for MW symmetric sampling.
    -
    1669  // For the usual MW sampling, only part of the memory will be used.
    -
    1670  f = malloc((2*L-1)*(L)*(2*N-1) * sizeof *f);
    -
    1671  SO3_ERROR_MEM_ALLOC_CHECK(f);
    -
    1672  f_rec = malloc((2*L-1)*(L)*(2*N-1) * sizeof *f_rec);
    -
    1673  SO3_ERROR_MEM_ALLOC_CHECK(f_rec);
    -
    1674 
    -
    1675  // Generate random harmonic coefficients for a complex signal
    -
    1676  so3_test_gen_flmn_complex(flmn, &so3_parameters, seed);
    -
    1677  so3_test_gen_flmn_complex(flmn_rec, &so3_parameters, seed);
    -
    1678 
    -
    1679  // Perform so3 transform to make flmn
    -
    1680  so3_core_inverse_direct(f_rec, flmn_rec, &so3_parameters);
    -
    1681 
    -
    1682  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1683  time_start = clock();
    -
    1684  so3_adjoint_forward_direct(f, flmn, &so3_parameters);
    -
    1685  // so3_core_inverse_direct(f, flmn, &so3_parameters);
    -
    1686  time_end = clock();
    -
    1687  printf(" - Wavelet synthesis adjoint : %4.4f seconds\n",
    -
    1688  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1689 
    -
    1690  // printf(" %6.5e i%6.5e\n",
    -
    1691  // creal(f_wav[0]), cimag(f_wav[0]));fflush(NULL);
    -
    1692 
    -
    1693 
    -
    1694  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1695  time_start = clock();
    -
    1696  //so3_adjoint_inverse_direct(flmn_rec, f_rec, &so3_parameters);
    -
    1697  so3_core_forward_direct(flmn_rec, f_rec, &so3_parameters);
    -
    1698  time_end = clock();
    -
    1699  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    1700  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1701 
    -
    1702  // printf(" %6.5e i%6.5e\n",
    -
    1703  // creal(f_rec[0]), cimag(f_rec[0]));fflush(NULL);
    -
    1704 
    -
    1705  // compute dot products of arrays
    -
    1706  complex double dot_product_error = 0.0;
    -
    1707  // dot_product_error = s2let_dot_product_complex(flm_rec, flm, L*L);
    -
    1708  // printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1709  // creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1710  dot_product_error = s2let_dot_product_complex(f_rec, f, (2*L-1)*(L)*(2*N-1));
    -
    1711  dot_product_error -= s2let_dot_product_complex(flmn_rec, flmn, L*L*(2*N-1));
    -
    1712 
    -
    1713 
    -
    1714  // Compute the maximum absolute error on the harmonic coefficients
    -
    1715  printf(" - Dot product test error : %6.5e i%6.5e\n",
    -
    1716  creal(dot_product_error), cimag(dot_product_error));fflush(NULL);
    -
    1717 
    -
    1718  free(f);
    -
    1719  free(f_rec);
    -
    1720  free(flmn);
    -
    1721  free(flmn_rec);}
    -
    1722 
    -
    1734 void s2let_wav_transform_mw_real_test(int B, int L, int J_min, int N, int seed)
    -
    1735 {
    -
    1736  clock_t time_start, time_end;
    -
    1737 
    -
    1738  s2let_parameters_t parameters = {};
    -
    1739  parameters.B = B;
    -
    1740  parameters.L = L;
    -
    1741  parameters.J_min = J_min;
    -
    1742  parameters.N = N;
    -
    1743  parameters.spin = 0;
    -
    1744  parameters.upsample = 1;
    -
    1745 
    -
    1746  int verbosity = parameters.verbosity = 0;
    -
    1747  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1748  //int J = s2let_j_max(L, B);
    -
    1749 
    -
    1750  double *f, *f_rec;
    -
    1751  complex double *flm, *flm_rec;
    -
    1752  s2let_allocate_lm(&flm, L);
    -
    1753  s2let_allocate_lm(&flm_rec, L);
    -
    1754  s2let_allocate_mw_real(&f, L);
    -
    1755  s2let_allocate_mw_real(&f_rec, L);
    -
    1756 
    -
    1757  // Generate random harmonic coefficients for a complex signal
    -
    1758  s2let_lm_random_flm_real(flm, L, seed);
    -
    1759 
    -
    1760  // Construct the corresponding signal on the sphere (MW sampling)
    -
    1761  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    1762 
    -
    1763  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1764  double *f_wav, *f_scal;
    -
    1765  s2let_allocate_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    1766 
    -
    1767  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1768  time_start = clock();
    -
    1769  s2let_analysis_px2wav_real(f_wav, f_scal, f, &parameters);
    -
    1770  time_end = clock();
    -
    1771  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    1772  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1773 
    -
    1774  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1775  time_start = clock();
    -
    1776  s2let_synthesis_wav2px_real(f_rec, f_wav, f_scal, &parameters);
    -
    1777  time_end = clock();
    -
    1778  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    1779  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1780 
    -
    1781  // Convert back to harmonic coefficients
    -
    1782  ssht_core_mw_forward_sov_conv_sym_real(flm_rec, f_rec, L, dl_method, verbosity);
    -
    1783 
    -
    1784  // Compute the maximum absolute error on the harmonic coefficients
    -
    1785  printf(" - Maximum abs error : %6.5e\n",
    -
    1786  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    1787 
    -
    1788  free(f);
    -
    1789  free(f_rec);
    -
    1790  free(flm);
    -
    1791  free(flm_rec);
    -
    1792  free(f_wav);
    -
    1793  free(f_scal);
    -
    1794 }
    -
    1795 
    -
    1808 void s2let_wav_transform_mw_multires_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    1809 {
    -
    1810  clock_t time_start, time_end;
    -
    1811 
    -
    1812  s2let_parameters_t parameters = {};
    -
    1813  parameters.B = B;
    -
    1814  parameters.L = L;
    -
    1815  parameters.J_min = J_min;
    -
    1816  parameters.N = N;
    -
    1817  parameters.spin = spin;
    -
    1818  parameters.original_spin = 0;
    -
    1819 
    -
    1820  int verbosity = parameters.verbosity = 0;
    -
    1821  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1822  //int J = s2let_j_max(L, B);
    -
    1823 
    -
    1824  complex double *f, *f_rec, *flm, *flm_rec;
    -
    1825  s2let_allocate_lm(&flm, L);
    -
    1826  s2let_allocate_lm(&flm_rec, L);
    -
    1827  s2let_allocate_mw(&f, L);
    -
    1828  s2let_allocate_mw(&f_rec, L);
    -
    1829 
    -
    1830  // Generate random harmonic coefficients for a complex signal
    -
    1831  s2let_lm_random_flm(flm, L, spin, seed);
    -
    1832 
    -
    1833  // Construct the corresponding signal on the sphere (MW sampling)
    -
    1834  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    1835 
    -
    1836  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1837  complex double *f_wav, *f_scal;
    -
    1838  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    1839 
    -
    1840  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1841  time_start = clock();
    -
    1842  s2let_analysis_px2wav(f_wav, f_scal, f, &parameters);
    -
    1843  time_end = clock();
    -
    1844  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    1845  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1846 
    -
    1847  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1848  time_start = clock();
    -
    1849  s2let_synthesis_wav2px(f_rec, f_wav, f_scal, &parameters);
    -
    1850  time_end = clock();
    -
    1851  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    1852  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1853 
    -
    1854  // Convert back to harmonic coefficients
    -
    1855  ssht_core_mw_forward_sov_conv_sym(flm_rec, f_rec, L, spin, dl_method, verbosity);
    -
    1856 
    -
    1857  // Compute the maximum absolute error on the harmonic coefficients
    -
    1858  printf(" - Maximum abs error : %6.5e\n",
    -
    1859  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    1860 
    -
    1861  free(f);
    -
    1862  free(f_rec);
    -
    1863  free(flm);
    -
    1864  free(flm_rec);
    -
    1865  free(f_wav);
    -
    1866  free(f_scal);
    -
    1867 }
    -
    1868 
    -
    1881 void s2let_wav_transform_mw_multires_real_test(int B, int L, int J_min, int N, int seed)
    -
    1882 {
    -
    1883  clock_t time_start, time_end;
    -
    1884 
    -
    1885  s2let_parameters_t parameters = {};
    -
    1886  parameters.B = B;
    -
    1887  parameters.L = L;
    -
    1888  parameters.J_min = J_min;
    -
    1889  parameters.N = N;
    -
    1890  parameters.spin = 0;
    -
    1891  int verbosity = parameters.verbosity = 0;
    -
    1892  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1893  //int J = s2let_j_max(L, B);
    -
    1894 
    -
    1895  double *f, *f_rec;
    -
    1896  complex double *flm, *flm_rec;
    -
    1897  s2let_allocate_lm(&flm, L);
    -
    1898  s2let_allocate_lm(&flm_rec, L);
    -
    1899  s2let_allocate_mw_real(&f, L);
    -
    1900  s2let_allocate_mw_real(&f_rec, L);
    -
    1901 
    -
    1902  // Generate random harmonic coefficients for a complex signal
    -
    1903  s2let_lm_random_flm_real(flm, L, seed);
    -
    1904 
    -
    1905  // Construct the corresponding signal on the sphere (MW sampling)
    -
    1906  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    1907 
    -
    1908  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1909  double *f_wav, *f_scal;
    -
    1910  s2let_allocate_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    1911 
    -
    1912  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1913  time_start = clock();
    -
    1914  s2let_analysis_px2wav_real(f_wav, f_scal, f, &parameters);
    -
    1915  time_end = clock();
    -
    1916  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    1917  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1918 
    -
    1919  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1920  time_start = clock();
    -
    1921  s2let_synthesis_wav2px_real(f_rec, f_wav, f_scal, &parameters);
    -
    1922  time_end = clock();
    -
    1923  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    1924  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1925 
    -
    1926  // Convert back to harmonic coefficients
    -
    1927  ssht_core_mw_forward_sov_conv_sym_real(flm_rec, f_rec, L, dl_method, verbosity);
    -
    1928 
    -
    1929  // Compute the maximum absolute error on the harmonic coefficients
    -
    1930  printf(" - Maximum abs error : %6.5e\n",
    -
    1931  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    1932 
    -
    1933  free(f);
    -
    1934  free(f_rec);
    -
    1935  free(flm);
    -
    1936  free(flm_rec);
    -
    1937  free(f_wav);
    -
    1938  free(f_scal);
    -
    1939 }
    -
    1940 
    -
    1953 void s2let_wav_transform_mwss_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    1954 {
    -
    1955  clock_t time_start, time_end;
    -
    1956 
    -
    1957  s2let_parameters_t parameters = {};
    -
    1958  parameters.B = B;
    -
    1959  parameters.L = L;
    -
    1960  parameters.J_min = J_min;
    -
    1961  parameters.N = N;
    -
    1962  parameters.spin = spin;
    -
    1963  parameters.upsample = 1;
    -
    1964  parameters.original_spin = 0;
    -
    1965  parameters.sampling_scheme = S2LET_SAMPLING_MW_SS;
    -
    1966 
    -
    1967  int verbosity = parameters.verbosity = 0;
    -
    1968  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    1969  //int J = s2let_j_max(L, B);
    -
    1970 
    -
    1971  complex double *f, *f_rec, *flm, *flm_rec;
    -
    1972  s2let_allocate_lm(&flm, L);
    -
    1973  s2let_allocate_lm(&flm_rec, L);
    -
    1974  s2let_allocate_mwss(&f, L);
    -
    1975  s2let_allocate_mwss(&f_rec, L);
    -
    1976 
    -
    1977  // Generate random harmonic coefficients for a complex signal
    -
    1978  s2let_lm_random_flm(flm, L, spin, seed);
    -
    1979 
    -
    1980  // Construct the corresponding signal on the sphere (MW sampling)
    -
    1981  ssht_core_mw_inverse_sov_sym_ss(f, flm, L, spin, dl_method, verbosity);
    -
    1982 
    -
    1983  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    1984  complex double *f_wav, *f_scal;
    -
    1985  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    1986 
    -
    1987  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    1988  time_start = clock();
    -
    1989  s2let_analysis_px2wav(f_wav, f_scal, f, &parameters);
    -
    1990  time_end = clock();
    -
    1991  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    1992  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    1993 
    -
    1994  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    1995  time_start = clock();
    -
    1996  s2let_synthesis_wav2px(f_rec, f_wav, f_scal, &parameters);
    -
    1997  time_end = clock();
    -
    1998  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    1999  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2000 
    -
    2001  // Convert back to harmonic coefficients
    -
    2002  ssht_core_mw_forward_sov_conv_sym_ss(flm_rec, f_rec, L, spin, dl_method, verbosity);
    -
    2003 
    -
    2004  // Compute the maximum absolute error on the harmonic coefficients
    -
    2005  printf(" - Maximum abs error : %6.5e\n",
    -
    2006  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    2007 
    -
    2008  free(f);
    -
    2009  free(f_rec);
    -
    2010  free(flm);
    -
    2011  free(flm_rec);
    -
    2012  free(f_wav);
    -
    2013  free(f_scal);
    -
    2014 }
    -
    2015 
    -
    2027 void s2let_wav_transform_mwss_real_test(int B, int L, int J_min, int N, int seed)
    -
    2028 {
    -
    2029  clock_t time_start, time_end;
    -
    2030 
    -
    2031  s2let_parameters_t parameters = {};
    -
    2032  parameters.B = B;
    -
    2033  parameters.L = L;
    -
    2034  parameters.J_min = J_min;
    -
    2035  parameters.N = N;
    -
    2036  parameters.spin = 0;
    -
    2037  parameters.upsample = 1;
    -
    2038  parameters.sampling_scheme = S2LET_SAMPLING_MW_SS;
    -
    2039 
    -
    2040  int verbosity = parameters.verbosity = 0;
    -
    2041  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    2042  //int J = s2let_j_max(L, B);
    -
    2043 
    -
    2044  double *f, *f_rec;
    -
    2045  complex double *flm, *flm_rec;
    -
    2046  s2let_allocate_lm(&flm, L);
    -
    2047  s2let_allocate_lm(&flm_rec, L);
    -
    2048  s2let_allocate_mwss_real(&f, L);
    -
    2049  s2let_allocate_mwss_real(&f_rec, L);
    -
    2050 
    -
    2051  // Generate random harmonic coefficients for a complex signal
    -
    2052  s2let_lm_random_flm_real(flm, L, seed);
    -
    2053 
    -
    2054  // Construct the corresponding signal on the sphere (MW sampling)
    -
    2055  ssht_core_mw_inverse_sov_sym_ss_real(f, flm, L, dl_method, verbosity);
    -
    2056 
    -
    2057  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    2058  double *f_wav, *f_scal;
    -
    2059  s2let_allocate_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    2060 
    -
    2061  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    2062  time_start = clock();
    -
    2063  s2let_analysis_px2wav_real(f_wav, f_scal, f, &parameters);
    -
    2064  time_end = clock();
    -
    2065  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    2066  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2067 
    -
    2068  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    2069  time_start = clock();
    -
    2070  s2let_synthesis_wav2px_real(f_rec, f_wav, f_scal, &parameters);
    -
    2071  time_end = clock();
    -
    2072  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    2073  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2074 
    -
    2075  // Convert back to harmonic coefficients
    -
    2076  ssht_core_mw_forward_sov_conv_sym_ss_real(flm_rec, f_rec, L, dl_method, verbosity);
    -
    2077 
    -
    2078  // Compute the maximum absolute error on the harmonic coefficients
    -
    2079  printf(" - Maximum abs error : %6.5e\n",
    -
    2080  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    2081 
    -
    2082  free(f);
    -
    2083  free(f_rec);
    -
    2084  free(flm);
    -
    2085  free(flm_rec);
    -
    2086  free(f_wav);
    -
    2087  free(f_scal);
    -
    2088 }
    -
    2089 
    -
    2102 void s2let_wav_transform_mwss_multires_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    2103 {
    -
    2104  clock_t time_start, time_end;
    -
    2105 
    -
    2106  s2let_parameters_t parameters = {};
    -
    2107  parameters.B = B;
    -
    2108  parameters.L = L;
    -
    2109  parameters.J_min = J_min;
    -
    2110  parameters.N = N;
    -
    2111  parameters.spin = spin;
    -
    2112  parameters.original_spin = 0;
    -
    2113  parameters.sampling_scheme = S2LET_SAMPLING_MW_SS;
    -
    2114 
    -
    2115  int verbosity = parameters.verbosity = 0;
    -
    2116  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    2117  //int J = s2let_j_max(L, B);
    -
    2118 
    -
    2119  complex double *f, *f_rec, *flm, *flm_rec;
    -
    2120  s2let_allocate_lm(&flm, L);
    -
    2121  s2let_allocate_lm(&flm_rec, L);
    -
    2122  s2let_allocate_mwss(&f, L);
    -
    2123  s2let_allocate_mwss(&f_rec, L);
    -
    2124 
    -
    2125  // Generate random harmonic coefficients for a complex signal
    -
    2126  s2let_lm_random_flm(flm, L, spin, seed);
    -
    2127 
    -
    2128  // Construct the corresponding signal on the sphere (MW sampling)
    -
    2129  ssht_core_mw_inverse_sov_sym_ss(f, flm, L, spin, dl_method, verbosity);
    -
    2130 
    -
    2131  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    2132  complex double *f_wav, *f_scal;
    -
    2133  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    2134 
    -
    2135  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    2136  time_start = clock();
    -
    2137  s2let_analysis_px2wav(f_wav, f_scal, f, &parameters);
    -
    2138  time_end = clock();
    -
    2139  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    2140  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2141 
    -
    2142  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    2143  time_start = clock();
    -
    2144  s2let_synthesis_wav2px(f_rec, f_wav, f_scal, &parameters);
    -
    2145  time_end = clock();
    -
    2146  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    2147  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2148 
    -
    2149  // Convert back to harmonic coefficients
    -
    2150  ssht_core_mw_forward_sov_conv_sym_ss(flm_rec, f_rec, L, spin, dl_method, verbosity);
    -
    2151 
    -
    2152  // Compute the maximum absolute error on the harmonic coefficients
    -
    2153  printf(" - Maximum abs error : %6.5e\n",
    -
    2154  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    2155 
    -
    2156  free(f);
    -
    2157  free(f_rec);
    -
    2158  free(flm);
    -
    2159  free(flm_rec);
    -
    2160  free(f_wav);
    -
    2161  free(f_scal);
    -
    2162 }
    -
    2163 
    -
    2176 void s2let_wav_transform_mwss_multires_real_test(int B, int L, int J_min, int N, int seed)
    -
    2177 {
    -
    2178  clock_t time_start, time_end;
    -
    2179 
    -
    2180  s2let_parameters_t parameters = {};
    -
    2181  parameters.B = B;
    -
    2182  parameters.L = L;
    -
    2183  parameters.J_min = J_min;
    -
    2184  parameters.N = N;
    -
    2185  parameters.spin = 0;
    -
    2186  parameters.sampling_scheme = S2LET_SAMPLING_MW_SS;
    -
    2187 
    -
    2188  int verbosity = parameters.verbosity = 0;
    -
    2189  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    2190  //int J = s2let_j_max(L, B);
    -
    2191 
    -
    2192  double *f, *f_rec;
    -
    2193  complex double *flm, *flm_rec;
    -
    2194  s2let_allocate_lm(&flm, L);
    -
    2195  s2let_allocate_lm(&flm_rec, L);
    -
    2196  s2let_allocate_mwss_real(&f, L);
    -
    2197  s2let_allocate_mwss_real(&f_rec, L);
    -
    2198 
    -
    2199  // Generate random harmonic coefficients for a complex signal
    -
    2200  s2let_lm_random_flm_real(flm, L, seed);
    -
    2201 
    -
    2202  // Construct the corresponding signal on the sphere (MW sampling)
    -
    2203  ssht_core_mw_inverse_sov_sym_ss_real(f, flm, L, dl_method, verbosity);
    -
    2204 
    -
    2205  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    2206  double *f_wav, *f_scal;
    -
    2207  s2let_allocate_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    2208 
    -
    2209  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    2210  time_start = clock();
    -
    2211  s2let_analysis_px2wav_real(f_wav, f_scal, f, &parameters);
    -
    2212  time_end = clock();
    -
    2213  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    2214  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2215 
    -
    2216  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    2217  time_start = clock();
    -
    2218  s2let_synthesis_wav2px_real(f_rec, f_wav, f_scal, &parameters);
    -
    2219  time_end = clock();
    -
    2220  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    2221  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2222 
    -
    2223  // Convert back to harmonic coefficients
    -
    2224  ssht_core_mw_forward_sov_conv_sym_ss_real(flm_rec, f_rec, L, dl_method, verbosity);
    -
    2225 
    -
    2226  // Compute the maximum absolute error on the harmonic coefficients
    -
    2227  printf(" - Maximum abs error : %6.5e\n",
    -
    2228  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    2229 
    -
    2230  free(f);
    -
    2231  free(f_rec);
    -
    2232  free(flm);
    -
    2233  free(flm_rec);
    -
    2234  free(f_wav);
    -
    2235  free(f_scal);
    -
    2236 }
    -
    2237 
    -
    2250 void s2let_wav_transform_lm2wav_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    2251 {
    -
    2252  clock_t time_start, time_end;
    -
    2253 
    -
    2254  s2let_parameters_t parameters = {};
    -
    2255  parameters.B = B;
    -
    2256  parameters.L = L;
    -
    2257  parameters.J_min = J_min;
    -
    2258  parameters.N = N;
    -
    2259  parameters.spin = spin;
    -
    2260  parameters.upsample = 1;
    -
    2261  parameters.original_spin = 0;
    -
    2262  parameters.verbosity = 0;
    -
    2263  parameters.dl_method = SSHT_DL_RISBO;
    -
    2264  //int J = s2let_j_max(L, B);
    -
    2265 
    -
    2266  complex double *flm, *flm_rec;
    -
    2267  s2let_allocate_lm(&flm, L);
    -
    2268  s2let_allocate_lm(&flm_rec, L);
    -
    2269 
    -
    2270  // Generate random harmonic coefficients for a complex signal
    -
    2271  s2let_lm_random_flm(flm, L, spin, seed);
    -
    2272 
    -
    2273  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    2274  complex double *f_wav, *f_scal;
    -
    2275  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    2276 
    -
    2277  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    2278  time_start = clock();
    -
    2279  s2let_analysis_lm2wav(f_wav, f_scal, flm, &parameters);
    -
    2280  time_end = clock();
    -
    2281  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    2282  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2283 
    -
    2284  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    2285  time_start = clock();
    -
    2286  s2let_synthesis_wav2lm(flm_rec, f_wav, f_scal, &parameters);
    -
    2287  time_end = clock();
    -
    2288  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    2289  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2290 
    -
    2291  // Compute the maximum absolute error on the harmonic coefficients
    -
    2292  printf(" - Maximum abs error : %6.5e\n",
    -
    2293  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    2294 
    -
    2295  free(flm);
    -
    2296  free(flm_rec);
    -
    2297  free(f_wav);
    -
    2298  free(f_scal);
    -
    2299 }
    -
    2300 
    -
    2312 void s2let_wav_transform_lm2wav_real_test(int B, int L, int J_min, int N, int seed)
    -
    2313 {
    -
    2314  clock_t time_start, time_end;
    -
    2315 
    -
    2316  s2let_parameters_t parameters = {};
    -
    2317  parameters.B = B;
    -
    2318  parameters.L = L;
    -
    2319  parameters.J_min = J_min;
    -
    2320  parameters.N = N;
    -
    2321  parameters.spin = 0;
    -
    2322  parameters.upsample = 1;
    -
    2323 
    -
    2324  parameters.verbosity = 0;
    -
    2325  parameters.dl_method = SSHT_DL_RISBO;
    -
    2326  //int J = s2let_j_max(L, B);
    -
    2327 
    -
    2328  complex double *flm, *flm_rec;
    -
    2329  s2let_allocate_lm(&flm, L);
    -
    2330  s2let_allocate_lm(&flm_rec, L);
    -
    2331 
    -
    2332  // Generate random harmonic coefficients for a complex signal
    -
    2333  s2let_lm_random_flm_real(flm, L, seed);
    -
    2334 
    -
    2335  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    2336  double *f_wav, *f_scal;
    -
    2337  s2let_allocate_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    2338 
    -
    2339  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    2340  time_start = clock();
    -
    2341  s2let_analysis_lm2wav_real(f_wav, f_scal, flm, &parameters);
    -
    2342  time_end = clock();
    -
    2343  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    2344  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2345 
    -
    2346  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    2347  time_start = clock();
    -
    2348  s2let_synthesis_wav2lm_real(flm_rec, f_wav, f_scal, &parameters);
    -
    2349  time_end = clock();
    -
    2350  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    2351  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2352 
    -
    2353  // Compute the maximum absolute error on the harmonic coefficients
    -
    2354  printf(" - Maximum abs error : %6.5e\n",
    -
    2355  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    2356 
    -
    2357  free(flm);
    -
    2358  free(flm_rec);
    -
    2359  free(f_wav);
    -
    2360  free(f_scal);
    -
    2361 }
    -
    2362 
    -
    2375 void s2let_wav_transform_lm2wav_multires_test(int B, int L, int J_min, int N, int spin, int seed)
    -
    2376 {
    -
    2377  clock_t time_start, time_end;
    -
    2378 
    -
    2379  s2let_parameters_t parameters = {};
    -
    2380  parameters.B = B;
    -
    2381  parameters.L = L;
    -
    2382  parameters.J_min = J_min;
    -
    2383  parameters.N = N;
    -
    2384  parameters.spin = spin;
    -
    2385  parameters.original_spin = 0;
    -
    2386  parameters.verbosity = 0;
    -
    2387  parameters.dl_method = SSHT_DL_RISBO;
    -
    2388  //int J = s2let_j_max(L, B);
    -
    2389 
    -
    2390  complex double *flm, *flm_rec;
    -
    2391  s2let_allocate_lm(&flm, L);
    -
    2392  s2let_allocate_lm(&flm_rec, L);
    -
    2393 
    -
    2394  // Generate random harmonic coefficients for a complex signal
    -
    2395  s2let_lm_random_flm(flm, L, spin, seed);
    -
    2396 
    -
    2397  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    2398  complex double *f_wav, *f_scal;
    -
    2399  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    2400 
    -
    2401  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    2402  time_start = clock();
    -
    2403  s2let_analysis_lm2wav(f_wav, f_scal, flm, &parameters);
    -
    2404  time_end = clock();
    -
    2405  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    2406  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2407 
    -
    2408  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    2409  time_start = clock();
    -
    2410  s2let_synthesis_wav2lm(flm_rec, f_wav, f_scal, &parameters);
    -
    2411  time_end = clock();
    -
    2412  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    2413  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2414 
    -
    2415  // Compute the maximum absolute error on the harmonic coefficients
    -
    2416  printf(" - Maximum abs error : %6.5e\n",
    -
    2417  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    2418 
    -
    2419  free(flm);
    -
    2420  free(flm_rec);
    -
    2421  free(f_wav);
    -
    2422  free(f_scal);
    -
    2423 }
    -
    2424 
    -
    2437 void s2let_wav_transform_lm2wav_multires_real_test(int B, int L, int J_min, int N, int seed)
    -
    2438 {
    -
    2439  clock_t time_start, time_end;
    -
    2440 
    -
    2441  s2let_parameters_t parameters = {};
    -
    2442  parameters.B = B;
    -
    2443  parameters.L = L;
    -
    2444  parameters.J_min = J_min;
    -
    2445  parameters.N = N;
    -
    2446  parameters.spin = 0;
    -
    2447  parameters.verbosity = 0;
    -
    2448  parameters.dl_method = SSHT_DL_RISBO;
    -
    2449  //int J = s2let_j_max(L, B);
    -
    2450 
    -
    2451  complex double *flm, *flm_rec;
    -
    2452  s2let_allocate_lm(&flm, L);
    -
    2453  s2let_allocate_lm(&flm_rec, L);
    -
    2454 
    -
    2455  // Generate random harmonic coefficients for a complex signal
    -
    2456  s2let_lm_random_flm_real(flm, L, seed);
    -
    2457 
    -
    2458  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    2459  double *f_wav, *f_scal;
    -
    2460  s2let_allocate_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    2461 
    -
    2462  // Perform wavelet analysis from scratch with all signals given on the sphere (MW sampling)
    -
    2463  time_start = clock();
    -
    2464  s2let_analysis_lm2wav_real(f_wav, f_scal, flm, &parameters);
    -
    2465  time_end = clock();
    -
    2466  printf(" - Wavelet analysis : %4.4f seconds\n",
    -
    2467  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2468 
    -
    2469  // Reconstruct the initial signal from the wavelet maps from scratch
    -
    2470  time_start = clock();
    -
    2471  s2let_synthesis_wav2lm_real(flm_rec, f_wav, f_scal, &parameters);
    -
    2472  time_end = clock();
    -
    2473  printf(" - Wavelet synthesis : %4.4f seconds\n",
    -
    2474  (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2475 
    -
    2476  // Compute the maximum absolute error on the harmonic coefficients
    -
    2477  printf(" - Maximum abs error : %6.5e\n",
    -
    2478  maxerr_cplx(flm, flm_rec, L*L));fflush(NULL);
    -
    2479 
    -
    2480  free(flm);
    -
    2481  free(flm_rec);
    -
    2482  free(f_wav);
    -
    2483  free(f_scal);
    -
    2484 }
    -
    2485 
    -
    2496 void s2let_transform_axisym_vs_directional_mw_test(B, L, J_min, seed)
    -
    2497 {
    -
    2498  s2let_parameters_t parameters = {};
    -
    2499  parameters.B = B;
    -
    2500  parameters.L = L;
    -
    2501  parameters.J_min = J_min;
    -
    2502  parameters.N = 1;
    -
    2503  parameters.upsample = 1;
    -
    2504 
    -
    2505  int spin = parameters.spin = 0;
    -
    2506  int J = s2let_j_max(&parameters);
    -
    2507  int verbosity = parameters.verbosity = 0;
    -
    2508  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    2509 
    -
    2510  parameters.original_spin = 0;
    -
    2511 
    -
    2512  double wav_error, scal_error;
    -
    2513 
    -
    2514  complex double *f, *flm;
    -
    2515  s2let_allocate_lm(&flm, L);
    -
    2516  s2let_allocate_mw(&f, L);
    -
    2517 
    -
    2518  // Generate random harmonic coefficients for a complex signal
    -
    2519  s2let_lm_random_flm(flm, L, spin, seed);
    -
    2520 
    -
    2521  // Construct the corresponding signal on the sphere (MW sampling)
    -
    2522  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    2523 
    -
    2524  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    2525  // from both transforms.
    -
    2526  complex double *f_wav_axisym, *f_scal_axisym, *f_wav_dir, *f_scal_dir;
    -
    2527  s2let_transform_axisym_allocate_mw_f_wav(&f_wav_axisym, &f_scal_axisym, &parameters);
    -
    2528  s2let_allocate_f_wav(&f_wav_dir, &f_scal_dir, &parameters);
    -
    2529 
    -
    2530  // Do both transforms
    -
    2531  s2let_transform_axisym_wav_analysis_mw(f_wav_axisym, f_scal_axisym, f, &parameters);
    -
    2532  s2let_analysis_px2wav(f_wav_dir, f_scal_dir, f, &parameters);
    -
    2533 
    -
    2534  // Compute the maximum absolute error in the computed wavelet transform
    -
    2535  wav_error = maxerr_cplx(f_wav_axisym, f_wav_dir, (J-J_min+1)*L*(2*L-1));
    -
    2536  scal_error = maxerr_cplx(f_scal_axisym, f_scal_dir, L*(2*L-1));
    -
    2537 
    -
    2538  printf(" - Maximum abs error in wavelets : %6.5e\n", wav_error);
    -
    2539  printf(" - Maximum abs error in scaling function : %6.5e\n", scal_error);
    -
    2540  fflush(NULL);
    -
    2541 }
    -
    2542 
    -
    2553 void s2let_transform_axisym_vs_directional_mw_multires_test(B, L, J_min, seed)
    -
    2554 {
    -
    2555  s2let_parameters_t parameters = {};
    -
    2556  parameters.B = B;
    -
    2557  parameters.L = L;
    -
    2558  parameters.J_min = J_min;
    -
    2559  parameters.N = 1;
    -
    2560 
    -
    2561  int spin = parameters.spin = 0;
    -
    2562 
    -
    2563  int J = s2let_j_max(&parameters);
    -
    2564  int verbosity = parameters.verbosity = 0;
    -
    2565  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    2566 
    -
    2567  parameters.original_spin = 0;
    -
    2568 
    -
    2569  int samples, bandlimit, j;
    -
    2570 
    -
    2571  double wav_error, scal_error;
    -
    2572 
    -
    2573  complex double *f, *flm;
    -
    2574  s2let_allocate_lm(&flm, L);
    -
    2575  s2let_allocate_mw(&f, L);
    -
    2576 
    -
    2577  // Generate random harmonic coefficients for a complex signal
    -
    2578  s2let_lm_random_flm(flm, L, spin, seed);
    -
    2579 
    -
    2580  // Construct the corresponding signal on the sphere (MW sampling)
    -
    2581  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    2582 
    -
    2583  // Allocate space for wavelet maps on the sphere (corresponding to the triplet B/L/J_min)
    -
    2584  // from both transforms.
    -
    2585  complex double *f_wav_axisym, *f_scal_axisym, *f_wav_dir, *f_scal_dir;
    -
    2586  s2let_transform_axisym_allocate_mw_f_wav_multires(&f_wav_axisym, &f_scal_axisym, &parameters);
    -
    2587  s2let_allocate_f_wav(&f_wav_dir, &f_scal_dir, &parameters);
    -
    2588 
    -
    2589  // Do both transforms
    -
    2590  s2let_transform_axisym_wav_analysis_mw_multires(f_wav_axisym, f_scal_axisym, f, &parameters);
    -
    2591  s2let_analysis_px2wav(f_wav_dir, f_scal_dir, f, &parameters);
    -
    2592 
    -
    2593  samples = 0;
    -
    2594  for (j = J_min; j <= J; ++j)
    -
    2595  {
    -
    2596  bandlimit = MIN(s2let_bandlimit(j, &parameters), L);
    -
    2597  samples += bandlimit * (2 * bandlimit - 1);
    -
    2598  }
    -
    2599 
    -
    2600  // Compute the maximum absolute error in the computed wavelet transform
    -
    2601  wav_error = maxerr_cplx(f_wav_axisym, f_wav_dir, samples);
    -
    2602  bandlimit = MIN(s2let_bandlimit(J_min-1, &parameters), L);
    -
    2603  scal_error = maxerr_cplx(f_scal_axisym, f_scal_dir, bandlimit*(2*bandlimit-1));
    -
    2604 
    -
    2605  printf(" - Maximum abs error in wavelets : %6.5e\n", wav_error);
    -
    2606  printf(" - Maximum abs error in scaling function : %6.5e\n", scal_error);
    -
    2607  fflush(NULL);
    -
    2608 }
    -
    2609 
    -
    2610 void s2let_transform_performance_test(int B, int J_min, int NREPEAT, int NSCALE, int seed)
    -
    2611 {
    -
    2612  s2let_parameters_t parameters = {};
    -
    2613  parameters.B = B;
    -
    2614  parameters.J_min = J_min;
    -
    2615 
    -
    2616  complex double *f, *flm, *flm_rec, *f_rec, *f_wav, *f_scal;
    -
    2617  clock_t time_start, time_end;
    -
    2618  int sc, repeat;
    -
    2619  double tottime_analysis = 0, tottime_synthesis = 0;
    -
    2620  double accuracy = 0.0;
    -
    2621 
    -
    2622  int L = 2;
    -
    2623 
    -
    2624  for (sc=0; sc<NSCALE; sc++) {
    -
    2625 
    -
    2626  L *= 2;
    -
    2627 
    -
    2628  parameters.L = L;
    -
    2629 
    -
    2630  s2let_allocate_lm(&flm, L);
    -
    2631 
    -
    2632  printf(" > L = %i \n", L);
    -
    2633  for (repeat=0; repeat<NREPEAT; repeat++){
    -
    2634 
    -
    2635  printf(" -> Iteration : %i on %i \n",repeat+1,NREPEAT);
    -
    2636 
    -
    2637  s2let_lm_random_flm(flm, L, 0, seed);
    -
    2638  s2let_allocate_mw(&f, L);
    -
    2639  s2let_mw_alm2map(f, flm, L, 0);
    -
    2640  s2let_transform_axisym_allocate_mw_f_wav(&f_wav, &f_scal, &parameters);
    -
    2641 
    -
    2642  time_start = clock();
    -
    2643  s2let_transform_axisym_wav_analysis_mw(f_wav, f_scal, f, &parameters);
    -
    2644  time_end = clock();
    -
    2645  tottime_synthesis += (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    2646  //printf(" - Duration for S2LET synthesis : %4.4f seconds\n", (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2647 
    -
    2648  s2let_allocate_mw(&f_rec, L);
    -
    2649 
    -
    2650  time_start = clock();
    -
    2651  s2let_transform_axisym_wav_synthesis_mw(f_rec, f_wav, f_scal, &parameters);
    -
    2652  time_end = clock();
    -
    2653  tottime_analysis += (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    2654 
    -
    2655  s2let_allocate_lm(&flm_rec, L);
    -
    2656  s2let_mw_map2alm(flm_rec, f_rec, L, 0);
    -
    2657 
    -
    2658  //printf(" - Duration for S2LET analysis : %4.4f seconds\n", (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2659  accuracy += maxerr_cplx(flm, flm_rec, L*L);fflush(NULL);
    -
    2660 
    -
    2661  free(f);
    -
    2662  free(f_rec);
    -
    2663  free(flm_rec);
    -
    2664  free(f_wav);
    -
    2665  free(f_scal);
    -
    2666 
    -
    2667  }
    -
    2668 
    -
    2669  tottime_synthesis = tottime_synthesis / (double)NREPEAT;
    -
    2670  tottime_analysis = tottime_analysis / (double)NREPEAT;
    -
    2671  accuracy = accuracy / (double)NREPEAT;
    -
    2672 
    -
    2673  printf(" - Average duration for S2LET synthesis : %5.5f seconds\n", tottime_synthesis);
    -
    2674  printf(" - Average duration for S2LET analysis : %5.5f seconds\n", tottime_analysis);
    -
    2675  printf(" - Average max error on reconstruction : %6.5e\n", accuracy);
    -
    2676 
    -
    2677  free(flm);
    -
    2678 
    -
    2679  }
    -
    2680 
    -
    2681 }
    -
    2682 
    -
    2683 
    -
    2684 
    -
    2685 void s2let_transform_performance_multires_test(int B, int J_min, int NREPEAT, int NSCALE, int seed)
    -
    2686 {
    -
    2687  s2let_parameters_t parameters = {};
    -
    2688  parameters.B = B;
    -
    2689  parameters.J_min = J_min;
    -
    2690 
    -
    2691  complex double *f, *flm, *flm_rec, *f_rec, *f_wav, *f_scal;
    -
    2692  clock_t time_start, time_end;
    -
    2693  int sc, repeat;
    -
    2694  double tottime_analysis = 0, tottime_synthesis = 0;
    -
    2695  double accuracy = 0.0;
    -
    2696 
    -
    2697  int L = 2;
    -
    2698 
    -
    2699  for (sc=0; sc<NSCALE; sc++) {
    -
    2700 
    -
    2701  L *= 2;
    -
    2702 
    -
    2703  parameters.L = L;
    -
    2704 
    -
    2705  s2let_allocate_lm(&flm, L);
    -
    2706 
    -
    2707  printf(" > L = %i \n", L);
    -
    2708  for (repeat=0; repeat<NREPEAT; repeat++){
    -
    2709 
    -
    2710  printf(" -> Iteration : %i on %i \n",repeat+1,NREPEAT);
    -
    2711 
    -
    2712  s2let_lm_random_flm(flm, L, 0, seed);
    -
    2713  s2let_allocate_mw(&f, L);
    -
    2714  s2let_mw_alm2map(f, flm, L, 0);
    -
    2715  s2let_transform_axisym_allocate_mw_f_wav_multires(&f_wav, &f_scal, &parameters);
    -
    2716 
    -
    2717  time_start = clock();
    -
    2718  s2let_transform_axisym_wav_analysis_mw_multires(f_wav, f_scal, f, &parameters);
    -
    2719  time_end = clock();
    -
    2720  tottime_synthesis += (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    2721  //printf(" - Duration for S2LET synthesis : %4.4f seconds\n", (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2722 
    -
    2723  s2let_allocate_mw(&f_rec, L);
    -
    2724 
    -
    2725  time_start = clock();
    -
    2726  s2let_transform_axisym_wav_synthesis_mw_multires(f_rec, f_wav, f_scal, &parameters);
    -
    2727  time_end = clock();
    -
    2728  tottime_analysis += (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    2729 
    -
    2730  s2let_allocate_lm(&flm_rec, L);
    -
    2731  s2let_mw_map2alm(flm_rec, f_rec, L, 0);
    -
    2732 
    -
    2733  //printf(" - Duration for S2LET analysis : %4.4f seconds\n", (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2734  accuracy += maxerr_cplx(flm, flm_rec, L*L);
    -
    2735 
    -
    2736  free(f);
    -
    2737  free(f_rec);
    -
    2738  free(flm_rec);
    -
    2739  free(f_wav);
    -
    2740  free(f_scal);
    -
    2741 
    -
    2742  }
    -
    2743 
    -
    2744  tottime_synthesis = tottime_synthesis / (double)NREPEAT;
    -
    2745  tottime_analysis = tottime_analysis / (double)NREPEAT;
    -
    2746  accuracy = accuracy / (double)NREPEAT;
    -
    2747 
    -
    2748  printf(" - Average duration for S2LET multires synthesis : %5.5f seconds\n", tottime_synthesis);
    -
    2749  printf(" - Average duration for S2LET multires analysis : %5.5f seconds\n", tottime_analysis);
    -
    2750  printf(" - Average max error on reconstruction : %6.5e\n", accuracy);
    -
    2751 
    -
    2752  free(flm);
    -
    2753 
    -
    2754  }
    -
    2755 
    -
    2756 }
    -
    2757 
    -
    2758 
    -
    2759 
    -
    2760 
    -
    2761 void s2let_transform_lm_performance_test(int B, int J_min, int NREPEAT, int NSCALE, int seed)
    -
    2762 {
    -
    2763  s2let_parameters_t parameters = {};
    -
    2764  parameters.B = B;
    -
    2765  parameters.J_min = J_min;
    -
    2766 
    -
    2767  complex double *flm, *flm_rec, *f_wav_lm, *f_scal_lm;
    -
    2768  clock_t time_start, time_end;
    -
    2769  int sc, repeat;
    -
    2770  double tottime_analysis = 0, tottime_synthesis = 0;
    -
    2771  double accuracy = 0.0;
    -
    2772  double *wav_lm, *scal_lm;
    -
    2773 
    -
    2774  int L = 4;
    -
    2775 
    -
    2776  for (sc=0; sc<NSCALE; sc++) {
    -
    2777 
    -
    2778  L *= 2;
    -
    2779 
    -
    2780  parameters.L = L;
    -
    2781 
    -
    2782  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, &parameters);
    -
    2783  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, &parameters);
    -
    2784  s2let_allocate_lm(&flm, L);
    -
    2785 
    -
    2786  printf(" > L = %i \n", L);
    -
    2787  for (repeat=0; repeat<NREPEAT; repeat++){
    -
    2788 
    -
    2789  //printf(" -> Iteration : %i on %i \n",repeat+1,NREPEAT);
    -
    2790 
    -
    2791  s2let_lm_random_flm(flm, L, 0, seed);
    -
    2792 
    -
    2793  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, &parameters);
    -
    2794 
    -
    2795  time_start = clock();
    -
    2796  s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, &parameters);
    -
    2797  time_end = clock();
    -
    2798  tottime_synthesis += (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    2799  //printf(" - Duration for S2LET synthesis : %4.4f seconds\n", (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2800 
    -
    2801  s2let_allocate_lm(&flm_rec, L);
    -
    2802 
    -
    2803  time_start = clock();
    -
    2804  s2let_transform_axisym_lm_wav_synthesis(flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, &parameters);
    -
    2805  time_end = clock();
    -
    2806  tottime_analysis += (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    2807 
    -
    2808  //printf(" - Duration for S2LET analysis : %4.4f seconds\n", (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2809  accuracy += maxerr_cplx(flm, flm_rec, L*L);
    -
    2810 
    -
    2811  free(flm_rec);
    -
    2812  free(f_wav_lm);
    -
    2813  free(f_scal_lm);
    -
    2814 
    -
    2815  }
    -
    2816 
    -
    2817  tottime_synthesis = tottime_synthesis / (double)NREPEAT;
    -
    2818  tottime_analysis = tottime_analysis / (double)NREPEAT;
    -
    2819  accuracy = accuracy / (double)NREPEAT;
    -
    2820 
    -
    2821  //printf(" - Average duration for S2LET synthesis : %5.2e seconds\n", tottime_synthesis);
    -
    2822  //printf(" - Average duration for S2LET analysis : %5.2e seconds\n", tottime_analysis);
    -
    2823  printf(" - Average duration for S2LET : %5.2e seconds\n", (tottime_analysis+tottime_synthesis)/2);
    -
    2824  printf(" - Average max error on reconstruction : %6.5e\n", accuracy);
    -
    2825 
    -
    2826  free(flm);
    -
    2827  free(wav_lm);
    -
    2828  free(scal_lm);
    -
    2829 
    -
    2830  }
    -
    2831 
    -
    2832 }
    -
    2833 
    -
    2834 
    -
    2835 
    -
    2836 void s2let_transform_lm_performance_multires_test(int B, int J_min, int NREPEAT, int NSCALE, int seed)
    -
    2837 {
    -
    2838  s2let_parameters_t parameters = {};
    -
    2839  parameters.B = B;
    -
    2840  parameters.J_min = J_min;
    -
    2841 
    -
    2842  complex double *flm, *flm_rec, *f_wav_lm, *f_scal_lm;
    -
    2843  clock_t time_start, time_end;
    -
    2844  int sc, repeat;
    -
    2845  double tottime_analysis = 0, tottime_synthesis = 0;
    -
    2846  double accuracy = 0.0;
    -
    2847  double *wav_lm, *scal_lm;
    -
    2848 
    -
    2849  int L = 4;
    -
    2850 
    -
    2851  for (sc=0; sc<NSCALE; sc++) {
    -
    2852 
    -
    2853  L *= 2;
    -
    2854 
    -
    2855  parameters.L = L;
    -
    2856 
    -
    2857  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, &parameters);
    -
    2858  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, &parameters);
    -
    2859  s2let_allocate_lm(&flm, L);
    -
    2860 
    -
    2861  printf(" > L = %i \n", L);
    -
    2862  for (repeat=0; repeat<NREPEAT; repeat++){
    -
    2863 
    -
    2864  //printf(" -> Iteration : %i on %i \n",repeat+1,NREPEAT);
    -
    2865 
    -
    2866  s2let_lm_random_flm(flm, L, 0, seed);
    -
    2867 
    -
    2868  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, &parameters);
    -
    2869 
    -
    2870  time_start = clock();
    -
    2871  s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, &parameters);
    -
    2872  time_end = clock();
    -
    2873  tottime_synthesis += (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    2874  //printf(" - Duration for S2LET synthesis : %4.4f seconds\n", (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2875 
    -
    2876  s2let_allocate_lm(&flm_rec, L);
    -
    2877 
    -
    2878  time_start = clock();
    -
    2879  s2let_transform_axisym_lm_wav_synthesis_multires(flm_rec, f_wav_lm, f_scal_lm, wav_lm, scal_lm, &parameters);
    -
    2880  time_end = clock();
    -
    2881  tottime_analysis += (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    2882 
    -
    2883  //printf(" - Duration for S2LET analysis : %4.4f seconds\n", (time_end - time_start) / (double)CLOCKS_PER_SEC);
    -
    2884  accuracy += maxerr_cplx(flm, flm_rec, L*L);
    -
    2885 
    -
    2886  free(flm_rec);
    -
    2887  free(f_wav_lm);
    -
    2888  free(f_scal_lm);
    -
    2889 
    -
    2890  }
    -
    2891 
    -
    2892  tottime_synthesis = tottime_synthesis / (double)NREPEAT;
    -
    2893  tottime_analysis = tottime_analysis / (double)NREPEAT;
    -
    2894  accuracy = accuracy / (double)NREPEAT;
    -
    2895 
    -
    2896  //printf(" - Average duration for S2LET multires synthesis : %5.2e seconds\n", tottime_synthesis);
    -
    2897  //printf(" - Average duration for S2LET multires analysis : %5.2e seconds\n", tottime_analysis);
    -
    2898  printf(" - Average duration for S2LET multires : %5.2e seconds\n", (tottime_analysis+tottime_synthesis)/2);
    -
    2899  printf(" - Average max error on reconstruction : %6.5e\n", accuracy);
    -
    2900 
    -
    2901  free(flm);
    -
    2902  free(wav_lm);
    -
    2903  free(scal_lm);
    -
    2904 
    -
    2905  }
    -
    2906 
    -
    2907 }
    -
    2908 
    -
    2909 
    -
    2910 int main(int argc, char *argv[])
    -
    2911 {
    -
    2912  const int L = 16;
    -
    2913  const int N = 4;
    -
    2914  const int B = 2;
    -
    2915  const int J_min = 2;
    -
    2916  const int spin = 0;
    -
    2917 
    -
    2918  s2let_parameters_t parameters = {};
    -
    2919 
    -
    2920  parameters.B = B;
    -
    2921  parameters.L = L;
    -
    2922  parameters.J_min = J_min;
    -
    2923  parameters.N = N;
    -
    2924  parameters.spin = spin;
    -
    2925 
    -
    2926  // This is too often zero, so we add 1 (zero will result in all random
    -
    2927  // numbers being the same).
    -
    2928 // const int seed = (int)((double)clock()/(double)CLOCKS_PER_SEC) + 1;
    -
    2929  const int seed = (int)((double)clock()) + 1;
    -
    2930  int l_min = s2let_L0(J_min, &parameters);
    -
    2931 
    -
    2932  printf("===========================================================================\n");
    -
    2933  printf("Testing S2LET facilities with the MW sampling\n");
    -
    2934  printf("===========================================================================\n");
    -
    2935  printf("PARAMETERS: ");
    -
    2936  printf("L = %i N = %i B = %i l_wav_min = %i spin = %i seed = %i\n",
    -
    2937  L, N, B, l_min, spin, seed);
    -
    2938  //s2let_switch_wavtype(3);
    -
    2939  printf("---------------------------------------------------------------------------\n");
    -
    2940  printf("> Testing logfact binomial coefficient implementation...\n");
    -
    2941  // Don't use more than 62 as the argument.
    -
    2942  s2let_binomial_coefficient_test(62);
    -
    2943  printf("===========================================================================\n");
    -
    2944  printf("> Testing axisymmetric kernels...\n");
    -
    2945  s2let_tiling_axisym_test(B, L, J_min);
    -
    2946  printf("---------------------------------------------------------------------------\n");
    -
    2947  printf("> Testing directionality components...\n");
    -
    2948  s2let_tiling_direction_test(L, N);
    -
    2949  printf("---------------------------------------------------------------------------\n");
    -
    2950  printf("> Testing directional wavelets...\n");
    -
    2951  s2let_tiling_wavelet_test(B, L, J_min, N, spin);
    -
    2952  printf("===========================================================================\n");
    -
    2953  printf("> Testing axisymmetric wavelets in harmonic space...\n");
    -
    2954  s2let_transform_axisym_lm_wav_test(B, L, J_min, seed);
    -
    2955  printf("---------------------------------------------------------------------------\n");
    -
    2956  printf("> Testing axisymmetric multiresolution algorithm in harmonic space...\n");
    -
    2957  s2let_transform_axisym_lm_wav_multires_test(B, L, J_min, seed);
    -
    2958  printf("---------------------------------------------------------------------------\n");
    -
    2959  printf("> Testing directional wavelets in harmonic space...\n");
    -
    2960  s2let_wav_transform_harmonic_test(B, L, J_min, N, spin, seed);
    -
    2961  printf("---------------------------------------------------------------------------\n");
    -
    2962  printf("> Testing directional multiresolution algorithm in harmonic space...\n");
    -
    2963  s2let_wav_transform_harmonic_multires_test(B, L, J_min, N, spin, seed);
    -
    2964 
    -
    2965  printf("===========================================================================\n");
    -
    2966  printf("> Testing axisymmetric wavelets in pixel space...\n");
    -
    2967  s2let_transform_axisym_wav_test(B, L, J_min, seed);
    -
    2968  printf("---------------------------------------------------------------------------\n");
    -
    2969  printf("> Testing axisymmetric multiresolution algorithm in pixel space...\n");
    -
    2970  s2let_transform_axisym_wav_multires_test(B, L, J_min, seed);
    -
    2971  printf("---------------------------------------------------------------------------\n");
    -
    2972  printf("> Testing directional wavelets in pixel space...\n");
    -
    2973  s2let_wav_transform_mw_test(B, L, J_min, N, spin, seed);
    -
    2974  printf("---------------------------------------------------------------------------\n");
    -
    2975  printf("> Testing directional analysis adjoint in harmonic space...\n");
    -
    2976  s2let_wav_analysis_adjoint_lm_lmn_test(B, L, J_min, N, spin, seed);
    -
    2977  printf("---------------------------------------------------------------------------\n");
    -
    2978  printf("> Testing directional synthesis adjoint in harmonic space...\n");
    -
    2979  s2let_wav_synthesis_adjoint_lm_lmn_test(B, L, J_min, N, spin, seed);
    -
    2980  printf("---------------------------------------------------------------------------\n");
    -
    2981  printf("> Testing directional analysis adjoint in pixel space...\n");
    -
    2982  s2let_wav_analysis_adjoint_mw_test(B, L, J_min, N, spin, seed);
    -
    2983  printf("---------------------------------------------------------------------------\n");
    -
    2984  printf("> Testing directional analysis real adjoint in pixel space...\n");
    -
    2985  s2let_wav_analysis_adjoint_mw_real_test(B, L, J_min, N, spin, seed);
    -
    2986  printf("---------------------------------------------------------------------------\n");
    -
    2987  printf("> Testing directional synthesis adjoint in pixel space...\n");
    -
    2988  s2let_wav_synthesis_adjoint_mw_test(B, L, J_min, N, spin, seed);
    -
    2989  printf("---------------------------------------------------------------------------\n");
    -
    2990  printf("> Testing directional synthesis real adjoint in pixel space...\n");
    -
    2991  s2let_wav_synthesis_adjoint_mw_real_test(B, L, J_min, N, spin, seed);
    -
    2992  printf("---------------------------------------------------------------------------\n");
    -
    2993  printf("> Testing directional so3_forward adjoint in pixel space...\n");
    -
    2994  s2let_wav_so3_forward_adjoint_test(B, L, J_min, N, spin, seed);
    -
    2995  printf("---------------------------------------------------------------------------\n");
    -
    2996  printf("> Testing directional multiresolution algorithm in pixel space...\n");
    -
    2997  s2let_wav_transform_mw_multires_test(B, L, J_min, N, spin, seed);
    -
    2998  printf("===========================================================================\n");
    -
    2999  printf("> Comparing directional and axisymmetric algorithm in pixel space...\n");
    -
    3000  s2let_transform_axisym_vs_directional_mw_test(B, L, J_min, seed);
    -
    3001  printf("---------------------------------------------------------------------------\n");
    -
    3002  printf("> Comparing directional and axisymmetric multiresolution algorithm\n");
    -
    3003  printf(" in pixel space...\n");
    -
    3004  s2let_transform_axisym_vs_directional_mw_multires_test(B, L, J_min, seed);
    -
    3005  printf("===========================================================================\n");
    -
    3006  printf("> Testing real axisymmetric wavelets in pixel space...\n");
    -
    3007  s2let_transform_axisym_wav_real_test(B, L, J_min, seed);
    -
    3008  printf("---------------------------------------------------------------------------\n");
    -
    3009  printf("> Testing real axisymmetric multiresolution algorithm...\n");
    -
    3010  s2let_transform_axisym_wav_multires_real_test(B, L, J_min, seed);
    -
    3011  printf("---------------------------------------------------------------------------\n");
    -
    3012  printf("> Testing real directional wavelets in pixel space...\n");
    -
    3013  s2let_wav_transform_mw_real_test(B, L, J_min, N, seed);
    -
    3014  printf("---------------------------------------------------------------------------\n");
    -
    3015  printf("> Testing real directional multiresolution algorithm...\n");
    -
    3016  s2let_wav_transform_mw_multires_real_test(B, L, J_min, N, seed);
    -
    3017  printf("===========================================================================\n");
    -
    3018  printf("> Testing directional harmonic-to-wavelet transform...\n");
    -
    3019  s2let_wav_transform_lm2wav_test(B, L, J_min, N, spin, seed);
    -
    3020  printf("---------------------------------------------------------------------------\n");
    -
    3021  printf("> Testing directional multiresolution harmonic-to-wavelet transform...\n");
    -
    3022  s2let_wav_transform_lm2wav_multires_test(B, L, J_min, N, spin, seed);
    -
    3023  printf("---------------------------------------------------------------------------\n");
    -
    3024  printf("> Testing real directional harmonic-to-wavelet transform...\n");
    -
    3025  s2let_wav_transform_lm2wav_real_test(B, L, J_min, N, seed);
    -
    3026  printf("---------------------------------------------------------------------------\n");
    -
    3027  printf("> Testing real directional multiresolution harmonic-to-wavelet transform...\n");
    -
    3028  s2let_wav_transform_lm2wav_multires_real_test(B, L, J_min, N, seed);
    -
    3029 
    -
    3030 
    -
    3031  printf("===========================================================================\n");
    -
    3032  printf("> Testing directional wavelet transform with MWSS...\n");
    -
    3033  s2let_wav_transform_mwss_test(B, L, J_min, N, spin, seed);
    -
    3034  printf("---------------------------------------------------------------------------\n");
    -
    3035  printf("> Testing directional multiresolution wavelet transform with MWSS...\n");
    -
    3036  s2let_wav_transform_mwss_multires_test(B, L, J_min, N, spin, seed);
    -
    3037  printf("---------------------------------------------------------------------------\n");
    -
    3038  printf("> Testing real directional wavelet transform with MWSS...\n");
    -
    3039  s2let_wav_transform_mwss_real_test(B, L, J_min, N, seed);
    -
    3040  printf("---------------------------------------------------------------------------\n");
    -
    3041  printf("> Testing real directional multiresolution wavelet transform with MWSS...\n");
    -
    3042  s2let_wav_transform_mwss_multires_real_test(B, L, J_min, N, seed);
    -
    3043 
    -
    3044  printf("---------------------------------------------------------------------------\n");
    -
    3045  printf("> Testing directional wavelet transform with manual setting...\n");
    -
    3046  s2let_wav_transform_wavlm_manual_test(B, L, J_min, N, spin, seed);
    -
    3047 
    -
    3048  /*
    -
    3049  const int NREPEAT = 50;
    -
    3050  const int NSCALE = 9;
    -
    3051  printf("==========================================================\n");
    -
    3052  printf("> Testing performances at full resolution...\n");
    -
    3053  s2let_transform_lm_performance_test(B, J_min, NREPEAT, NSCALE, seed);
    -
    3054  printf("----------------------------------------------------------\n");
    -
    3055  printf("> Testing performances with multiresolution...\n");
    -
    3056  s2let_transform_lm_performance_multires_test(B, J_min, NREPEAT, NSCALE, seed);
    -
    3057  printf("----------------------------------------------------------\n");
    -
    3058  printf("> Testing performances at full resolution...\n");
    -
    3059  //s2let_transform_performance_test(B, J_min, NREPEAT, NSCALE, seed);
    -
    3060  printf("----------------------------------------------------------\n");
    -
    3061  printf("> Testing performances with multiresolution...\n");
    -
    3062  //s2let_transform_performance_multires_test(B, J_min, NREPEAT, NSCALE, seed);
    -
    3063  */
    -
    3064  printf("===========================================================================\n");
    -
    3065 
    -
    3066 
    -
    3067 
    -
    3068  return 0;
    -
    3069 }
    -
    -
    s2let_transform_axisym_vs_directional_mw_test
    void s2let_transform_axisym_vs_directional_mw_test(B, L, J_min, seed)
    Definition: s2let_test.c:2496
    -
    s2let_transform_axisym_lm_wav
    void s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:98
    -
    s2let_analysis_lm2wav_manual
    void s2let_analysis_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    Definition: s2let_analysis.c:207
    -
    s2let_transform_axisym_lm_allocate_wav
    void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:79
    -
    s2let_transform_lm_performance_multires_test
    void s2let_transform_lm_performance_multires_test(int B, int J_min, int NREPEAT, int NSCALE, int seed)
    Definition: s2let_test.c:2836
    -
    s2let_tiling_axisym_allocate
    void s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:126
    -
    s2let_analysis_adjoint_wav2px_real
    void s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_analysis_adjoint.c:576
    -
    s2let_wav_transform_mwss_multires_real_test
    void s2let_wav_transform_mwss_multires_real_test(int B, int L, int J_min, int N, int seed)
    Definition: s2let_test.c:2176
    -
    s2let_allocate_mwss_real
    void s2let_allocate_mwss_real(double **f, int L)
    Definition: s2let_alloc.c:48
    -
    s2let_synthesis_wav2lm_real
    void s2let_synthesis_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:428
    -
    s2let_synthesis_wav2lm_manual
    void s2let_synthesis_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N)
    Definition: s2let_synthesis.c:225
    -
    s2let_allocate_f_wav_manual
    void s2let_allocate_f_wav_manual(complex double **f_wav, complex double **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:156
    -
    s2let_mw_map2alm
    void s2let_mw_map2alm(complex double *flm, const complex double *f, int L, int spin)
    Definition: s2let_mw.c:35
    -
    s2let_allocate_mw
    void s2let_allocate_mw(complex double **f, int L)
    Definition: s2let_alloc.c:18
    -
    s2let_allocate_f_wav_real
    void s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:128
    -
    s2let_transform_axisym_lm_wav_test
    void s2let_transform_axisym_lm_wav_test(int B, int L, int J_min, int seed)
    Definition: s2let_test.c:170
    -
    s2let_synthesis_wav2lm
    void s2let_synthesis_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:338
    -
    s2let_n_lm_scal
    int s2let_n_lm_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:31
    -
    s2let_transform_axisym_wav_analysis_mw_real
    void s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:660
    -
    s2let_analysis_px2wav
    void s2let_analysis_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:498
    -
    s2let_transform_axisym_wav_synthesis_mw_real
    void s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:789
    -
    s2let_analysis_lm2wav_real
    void s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:409
    -
    s2let_analysis_lm2lmn
    void s2let_analysis_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:27
    -
    s2let_transform_axisym_lm_wav_multires_test
    void s2let_transform_axisym_lm_wav_multires_test(int B, int L, int J_min, int seed)
    Definition: s2let_test.c:235
    -
    s2let_transform_axisym_allocate_mw_f_wav_multires
    void s2let_transform_axisym_allocate_mw_f_wav_multires(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:44
    -
    s2let_mw_alm2map
    void s2let_mw_alm2map(complex double *f, const complex double *flm, int L, int spin)
    Definition: s2let_mw.c:20
    -
    s2let_wav_analysis_adjoint_lm_lmn_test
    void s2let_wav_analysis_adjoint_lm_lmn_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:947
    -
    s2let_transform_axisym_allocate_mw_f_wav
    void s2let_transform_axisym_allocate_mw_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:21
    -
    s2let_transform_axisym_wav_analysis_mw_multires_real
    void s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:918
    -
    s2let_wav_transform_mw_multires_test
    void s2let_wav_transform_mw_multires_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:1808
    -
    s2let_synthesis_wav2px_real
    void s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:563
    -
    s2let_transform_axisym_wav_multires_test
    void s2let_transform_axisym_wav_multires_test(int B, int L, int J_min, int seed)
    Definition: s2let_test.c:704
    -
    s2let_tiling_wavelet_allocate
    void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:339
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_analysis_adjoint_wav2px
    void s2let_analysis_adjoint_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_analysis_adjoint.c:532
    -
    s2let_transform_axisym_allocate_mw_f_wav_real
    void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:74
    -
    s2let_n_wav
    int s2let_n_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:88
    -
    s2let_transform_axisym_lm_wav_synthesis_multires
    void s2let_transform_axisym_lm_wav_synthesis_multires(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:286
    -
    s2let_wav_analysis_adjoint_mw_real_test
    void s2let_wav_analysis_adjoint_mw_real_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:1228
    -
    s2let_wav_transform_lm2wav_real_test
    void s2let_wav_transform_lm2wav_real_test(int B, int L, int J_min, int N, int seed)
    Definition: s2let_test.c:2312
    -
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    -
    s2let_analysis_adjoint_lmn2lm
    void s2let_analysis_adjoint_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_analysis_adjoint.c:27
    - -
    s2let_parameters_t::verbosity
    int verbosity
    Definition: s2let_types.h:61
    -
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_wav_transform_mwss_real_test
    void s2let_wav_transform_mwss_real_test(int B, int L, int J_min, int N, int seed)
    Definition: s2let_test.c:2027
    -
    s2let_transform_axisym_wav_synthesis_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1053
    -
    s2let_wav_synthesis_adjoint_mw_real_test
    void s2let_wav_synthesis_adjoint_mw_real_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:1496
    -
    s2let_transform_lm_performance_test
    void s2let_transform_lm_performance_test(int B, int J_min, int NREPEAT, int NSCALE, int seed)
    Definition: s2let_test.c:2761
    -
    ABS
    #define ABS(a)
    Definition: s2let_math.h:13
    -
    s2let_transform_axisym_wav_synthesis_mw_multires
    void s2let_transform_axisym_wav_synthesis_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:524
    -
    s2let_binomial_coefficient_test
    void s2let_binomial_coefficient_test(int n_max)
    Definition: s2let_test.c:117
    -
    s2let_tiling_axisym
    void s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:217
    -
    s2let_lm_random_flm_real
    void s2let_lm_random_flm_real(complex double *flm, int L, int seed)
    Definition: s2let_lm.c:52
    -
    s2let_transform_axisym_vs_directional_mw_multires_test
    void s2let_transform_axisym_vs_directional_mw_multires_test(B, L, J_min, seed)
    Definition: s2let_test.c:2553
    -
    s2let_wav_transform_harmonic_test
    void s2let_wav_transform_harmonic_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:410
    -
    s2let_wav_transform_mwss_multires_test
    void s2let_wav_transform_mwss_multires_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:2102
    -
    s2let_wav_synthesis_adjoint_lm_lmn_test
    void s2let_wav_synthesis_adjoint_lm_lmn_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:1047
    -
    s2let_wav_so3_forward_adjoint_test
    void s2let_wav_so3_forward_adjoint_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:1638
    -
    s2let_transform_axisym_wav_analysis_mw_multires
    void s2let_transform_axisym_wav_analysis_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:389
    -
    s2let_transform_axisym_wav_analysis_mw
    void s2let_transform_axisym_wav_analysis_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:124
    -
    s2let_dot_product_complex
    complex double s2let_dot_product_complex(complex double *v1, complex double *v2, int N_length)
    Definition: s2let_test.c:900
    -
    s2let_allocate_lmn_f_wav
    void s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:82
    -
    s2let_transform_axisym_wav_synthesis_mw
    void s2let_transform_axisym_wav_synthesis_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:255
    -
    maxerr_cplx
    double maxerr_cplx(complex double *a, complex double *b, int size)
    Definition: s2let_math.c:141
    -
    s2let_wav_analysis_adjoint_mw_test
    void s2let_wav_analysis_adjoint_mw_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:1139
    -
    s2let_transform_axisym_lm_allocate_f_wav
    void s2let_transform_axisym_lm_allocate_f_wav(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:27
    -
    s2let_allocate_mw_real
    void s2let_allocate_mw_real(double **f, int L)
    Definition: s2let_alloc.c:28
    -
    NREPEAT
    #define NREPEAT
    Definition: s2let_test_csv.c:47
    -
    s2let_transform_axisym_lm_wav_analysis
    void s2let_transform_axisym_lm_wav_analysis(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:141
    -
    s2let_wav_transform_mw_test
    void s2let_wav_transform_mw_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:838
    -
    S2LET_SAMPLING_MW_SS
    @ S2LET_SAMPLING_MW_SS
    Definition: s2let_types.h:32
    -
    s2let_transform_performance_multires_test
    void s2let_transform_performance_multires_test(int B, int J_min, int NREPEAT, int NSCALE, int seed)
    Definition: s2let_test.c:2685
    -
    s2let_n_scal
    int s2let_n_scal(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:74
    -
    s2let_wav_synthesis_adjoint_mw_test
    void s2let_wav_synthesis_adjoint_mw_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:1407
    -
    s2let_transform_axisym_wav_multires_real_test
    void s2let_transform_axisym_wav_multires_real_test(int B, int L, int J_min, int seed)
    Definition: s2let_test.c:770
    -
    s2let_transform_axisym_lm_allocate_f_wav_multires
    void s2let_transform_axisym_lm_allocate_f_wav_multires(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:50
    -
    s2let_tiling_wavelet_test
    void s2let_tiling_wavelet_test(int B, int L, int J_min, int N, int spin)
    Definition: s2let_test.c:88
    -
    s2let_tiling_wavelet_check_identity
    double s2let_tiling_wavelet_check_identity(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:529
    -
    s2let_wav_transform_mw_multires_real_test
    void s2let_wav_transform_mw_multires_real_test(int B, int L, int J_min, int N, int seed)
    Definition: s2let_test.c:1881
    -
    s2let_transform_axisym_lm_wav_synthesis
    void s2let_transform_axisym_lm_wav_synthesis(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:189
    -
    binomial_coefficient
    unsigned long binomial_coefficient(int n, int k, int exact)
    Definition: s2let_math.c:248
    -
    s2let_tiling_direction_allocate
    void s2let_tiling_direction_allocate(complex double **s_elm, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:265
    -
    s2let_tiling_direction_check_identity
    double s2let_tiling_direction_check_identity(complex double *s_elm, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:490
    -
    so3_test_gen_flmn_complex
    void so3_test_gen_flmn_complex(complex double *flmn, const so3_parameters_t *parameters, int seed)
    Definition: s2let_test.c:1585
    -
    s2let_parameters_t::original_spin
    int original_spin
    Definition: s2let_types.h:122
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_test.c:2910
    -
    s2let_wav_synthesis_adjoint_lm2wav_test
    void s2let_wav_synthesis_adjoint_lm2wav_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:1318
    -
    s2let_transform_axisym_lm_wav_analysis_multires
    void s2let_transform_axisym_lm_wav_analysis_multires(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:237
    -
    s2let_tiling_wavelet
    void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:388
    -
    s2let_wav_transform_lm2wav_test
    void s2let_wav_transform_lm2wav_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:2250
    -
    s2let_transform_performance_test
    void s2let_transform_performance_test(int B, int J_min, int NREPEAT, int NSCALE, int seed)
    Definition: s2let_test.c:2610
    -
    s2let_wav_transform_mwss_test
    void s2let_wav_transform_mwss_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:1953
    -
    s2let_transform_axisym_wav_real_test
    void s2let_transform_axisym_wav_real_test(int B, int L, int J_min, int seed)
    Definition: s2let_test.c:638
    -
    s2let_tiling_direction
    void s2let_tiling_direction(complex double *s_elm, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:286
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_transform_axisym_wav_test
    void s2let_transform_axisym_wav_test(int B, int L, int J_min, int seed)
    Definition: s2let_test.c:573
    -
    s2let_n_lmn_wav
    int s2let_n_lmn_wav(const s2let_parameters_t *parameters)
    Definition: s2let_helper.c:42
    -
    s2let_dot_product_real
    complex double s2let_dot_product_real(double *v1, double *v2, int N_length)
    Definition: s2let_test.c:921
    -
    s2let_wav_transform_lm2wav_multires_test
    void s2let_wav_transform_lm2wav_multires_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:2375
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_tiling_direction_test
    void s2let_tiling_direction_test(int L, int N)
    Definition: s2let_test.c:54
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_L0
    int s2let_L0(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:83
    -
    s2let_allocate_f_wav
    void s2let_allocate_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:105
    -
    s2let_analysis_px2wav_real
    void s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:541
    -
    s2let_wav_transform_wavlm_manual_test
    void s2let_wav_transform_wavlm_manual_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:304
    -
    ran2_dp
    double ran2_dp(int idum)
    Definition: s2let_math.c:104
    -
    s2let_synthesis_adjoint_px2wav_real
    void s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Definition: s2let_synthesis_adjoint.c:547
    -
    s2let_synthesis_adjoint_lm2wav
    void s2let_synthesis_adjoint_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis_adjoint.c:325
    -
    s2let_lm_random_flm
    void s2let_lm_random_flm(complex double *flm, int L, int spin, int seed)
    Definition: s2let_lm.c:34
    -
    s2let_synthesis_lmn2lm
    void s2let_synthesis_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:27
    -
    MAX
    #define MAX(a, b)
    Definition: s2let_math.h:12
    -
    s2let_wav_transform_harmonic_multires_test
    void s2let_wav_transform_harmonic_multires_test(int B, int L, int J_min, int N, int spin, int seed)
    Definition: s2let_test.c:483
    -
    s2let_synthesis_wav2px
    void s2let_synthesis_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:520
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_synthesis_adjoint_lm2lmn
    void s2let_synthesis_adjoint_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis_adjoint.c:27
    -
    s2let_synthesis_adjoint_px2wav
    void s2let_synthesis_adjoint_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis_adjoint.c:504
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    s2let_wav_transform_mw_real_test
    void s2let_wav_transform_mw_real_test(int B, int L, int J_min, int N, int seed)
    Definition: s2let_test.c:1734
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_allocate_mwss
    void s2let_allocate_mwss(complex double **f, int L)
    Definition: s2let_alloc.c:38
    -
    s2let_tiling_axisym_test
    void s2let_tiling_axisym_test(int B, int L, int J_min)
    Definition: s2let_test.c:22
    -
    s2let_transform_axisym_allocate_mw_f_wav_multires_real
    void s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:94
    -
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    -
    S2LET_SAMPLING_MW
    @ S2LET_SAMPLING_MW
    Definition: s2let_types.h:25
    -
    s2let_wav_transform_lm2wav_multires_real_test
    void s2let_wav_transform_lm2wav_multires_real_test(int B, int L, int J_min, int N, int seed)
    Definition: s2let_test.c:2437
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    -
    s2let_analysis_lm2wav
    void s2let_analysis_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:321
    -
    s2let_tiling_axisym_check_identity
    double s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:452
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__test__csv_8c.html b/docs/c/s2let__test__csv_8c.html index b628ef5b..25b49797 100644 --- a/docs/c/s2let__test__csv_8c.html +++ b/docs/c/s2let__test__csv_8c.html @@ -5,7 +5,7 @@ -S2LET: src/test/c/s2let_test_csv.c File Reference +s2let: src/test/c/s2let_test_csv.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -81,9 +81,43 @@ #include <time.h>
    #include <ssht.h>
    #include <s2let.h>
    +
    +Include dependency graph for s2let_test_csv.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -111,8 +145,6 @@

    -

    Definition at line 47 of file s2let_test_csv.c.

    -

    Function Documentation

    @@ -148,8 +180,6 @@

    -

    Definition at line 195 of file s2let_test_csv.c.

    - @@ -178,8 +208,6 @@

    -

    Definition at line 52 of file s2let_test_csv.c.

    - @@ -199,14 +227,12 @@

    Random number from seed (Numerical Recipes).

    -

    Definition at line 104 of file s2let_math.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__test__csv_8c__incl.map b/docs/c/s2let__test__csv_8c__incl.map new file mode 100644 index 00000000..f334014d --- /dev/null +++ b/docs/c/s2let__test__csv_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__test__csv_8c__incl.md5 b/docs/c/s2let__test__csv_8c__incl.md5 new file mode 100644 index 00000000..f2ccb682 --- /dev/null +++ b/docs/c/s2let__test__csv_8c__incl.md5 @@ -0,0 +1 @@ +f63454905f8897bf4fe03d693965a69e \ No newline at end of file diff --git a/docs/c/s2let__test__csv_8c_source.html b/docs/c/s2let__test__csv_8c_source.html deleted file mode 100644 index 0558268a..00000000 --- a/docs/c/s2let__test__csv_8c_source.html +++ /dev/null @@ -1,277 +0,0 @@ - - - - - - - -S2LET: src/test/c/s2let_test_csv.c Source File - - - - - - - - - -
    -
    -

    Macros

    #define NREPEAT   10
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_test_csv.c
    -
    -
    -Go to the documentation of this file.
    1 // S03 package to perform Wigner transform on the rotation group SO(3)
    -
    2 // Copyright (C) 2013 Martin Büttner and Jason McEwen
    -
    3 // See LICENSE.txt for license details
    -
    4 
    -
    39 #include <stdio.h>
    -
    40 #include <stdlib.h>
    -
    41 #include <complex.h>
    -
    42 #include <time.h>
    -
    43 
    -
    44 #include <ssht.h>
    -
    45 #include <s2let.h>
    -
    46 
    -
    47 #define NREPEAT 10
    -
    48 
    -
    49 double get_max_error(complex double *expected, complex double *actual, int n);
    -
    50 double ran2_dp(int idum);
    -
    51 
    -
    52 int main(int argc, char **argv)
    -
    53 {
    -
    54  s2let_parameters_t parameters = {};
    -
    55  int verbosity = parameters.verbosity = 0;
    -
    56  int Lmax, L, useLasN, N, L0, B, J_min, spin;
    -
    57  complex *flm, *flm_rec, *f, *f_rec;;
    -
    58  complex *f_wav, *f_scal;
    -
    59  int seed;
    -
    60  clock_t time_start, time_end;
    -
    61  int i, multires;
    -
    62 
    -
    63  ssht_dl_method_t dl_method = parameters.dl_method = SSHT_DL_RISBO;
    -
    64 
    -
    65  double min_duration_inverse;
    -
    66  double min_duration_forward;
    -
    67  double avg_duration_inverse;
    -
    68  double avg_duration_forward;
    -
    69  double avg_error;
    -
    70 
    -
    71  // Parse command line arguments
    -
    72  parameters.N = N = Lmax = 64;
    -
    73  useLasN = 1; // true
    -
    74  L0 = 0;
    -
    75  parameters.spin = spin = 0;
    -
    76  parameters.J_min = J_min = 0;
    -
    77  seed = 1;
    -
    78  parameters.B = B = 2;
    -
    79  if (argc > 1)
    -
    80  Lmax = atoi(argv[1]);
    -
    81  if (argc > 2)
    -
    82  parameters.spin = spin = atoi(argv[2]);
    -
    83  if (argc > 3)
    -
    84  parameters.B = B = atoi(argv[3]);
    -
    85  if (argc > 4)
    -
    86  {
    -
    87  useLasN = 0; // false
    -
    88  parameters.N = N = atoi(argv[4]);
    -
    89  }
    -
    90 
    -
    91  parameters.original_spin = 0;
    -
    92 
    -
    93  // Output header row
    -
    94  printf("multires;spin;L;N;B;J_min;J;min_duration_inverse;min_duration_forward;avg_duration_inverse;avg_duration_forward;avg_error\n");
    -
    95 
    -
    96  // multires == 0 --> full resolution transform
    -
    97  // multires == 1 --> multiresolution transform
    -
    98  for (multires = 0; multires < 2; ++multires)
    -
    99  {
    -
    100  parameters.upsample = 1-multires;
    -
    101  L = 1024;
    -
    102  while(L <= Lmax)
    -
    103  {
    -
    104  if (L <= L0 || (!useLasN && L < N))
    -
    105  {
    -
    106  L *= 2;
    -
    107  continue;
    -
    108  }
    -
    109 
    -
    110  if (useLasN)
    -
    111  {
    -
    112  parameters.N = N = L;
    -
    113  }
    -
    114 
    -
    115  parameters.L = L;
    -
    116 
    -
    117  s2let_allocate_lm(&flm, L);
    -
    118  s2let_allocate_lm(&flm_rec, L);
    -
    119  s2let_allocate_mw(&f, L);
    -
    120  s2let_allocate_mw(&f_rec, L);
    -
    121  s2let_allocate_f_wav(&f_wav, &f_scal, &parameters);
    -
    122 
    -
    123  min_duration_inverse = 0.0;
    -
    124  min_duration_forward = 0.0;
    -
    125  avg_duration_inverse = 0.0;
    -
    126  avg_duration_forward = 0.0;
    -
    127  avg_error = 0.0;
    -
    128  int J = s2let_j_max(&parameters);
    -
    129 
    -
    130  for (i = 0; i < NREPEAT; ++i)
    -
    131  {
    -
    132  int j;
    -
    133  double duration;
    -
    134 
    -
    135  // Reset output array
    -
    136  for (j = 0; j < L*L; ++j)
    -
    137  flm_rec[j] = 0.0;
    -
    138 
    -
    139  s2let_lm_random_flm(flm, L, spin, seed);
    -
    140  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    141 
    -
    142  time_start = clock();
    -
    143  s2let_analysis_px2wav(f_wav, f_scal, f, &parameters);
    -
    144  time_end = clock();
    -
    145 
    -
    146  duration = (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    147  avg_duration_inverse += duration / NREPEAT;
    -
    148  if (!i || duration < min_duration_inverse)
    -
    149  min_duration_inverse = duration;
    -
    150 
    -
    151  time_start = clock();
    -
    152  s2let_synthesis_wav2px(f_rec, f_wav, f_scal, &parameters);
    -
    153  time_end = clock();
    -
    154 
    -
    155  ssht_core_mw_forward_sov_conv_sym(flm_rec, f_rec, L, spin, dl_method, verbosity);
    -
    156 
    -
    157  duration = (time_end - time_start) / (double)CLOCKS_PER_SEC;
    -
    158  avg_duration_forward += duration / NREPEAT;
    -
    159  if (!i || duration < min_duration_forward)
    -
    160  min_duration_forward = duration;
    -
    161 
    -
    162  avg_error += get_max_error(flm, flm_rec, L*L)/NREPEAT;
    -
    163  }
    -
    164 
    -
    165  printf("%d;%d;%d;%d;%d;%d;%d;%f;%f;%f;%f;%e\n",
    -
    166  multires,
    -
    167  spin,
    -
    168  L,
    -
    169  N,
    -
    170  B,
    -
    171  J_min,
    -
    172  J,
    -
    173  min_duration_inverse,
    -
    174  min_duration_forward,
    -
    175  avg_duration_inverse,
    -
    176  avg_duration_forward,
    -
    177  avg_error);
    -
    178 
    -
    179  L *= 2;
    -
    180 
    -
    181  free(f);
    -
    182  free(f_rec);
    -
    183  free(flm);
    -
    184  free(flm_rec);
    -
    185  free(f_wav);
    -
    186  free(f_scal);
    -
    187  }
    -
    188 
    -
    189  }
    -
    190 
    -
    191 
    -
    192  return 0;
    -
    193 }
    -
    194 
    -
    195 double get_max_error(complex double *expected, complex double *actual, int n)
    -
    196 {
    -
    197  int i;
    -
    198  double error, maxError = 0;
    -
    199 
    -
    200  for (i = 0; i < n; ++i)
    -
    201  {
    -
    202  error = cabs(expected[i] - actual[i]);
    -
    203  maxError = MAX(error, maxError);
    -
    204  }
    -
    205 
    -
    206  return maxError;
    -
    207 }
    -
    -
    s2let_allocate_mw
    void s2let_allocate_mw(complex double **f, int L)
    Definition: s2let_alloc.c:18
    -
    s2let_analysis_px2wav
    void s2let_analysis_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_analysis.c:498
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    - -
    s2let_parameters_t::verbosity
    int verbosity
    Definition: s2let_types.h:61
    -
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    get_max_error
    double get_max_error(complex double *expected, complex double *actual, int n)
    Definition: s2let_test_csv.c:195
    -
    NREPEAT
    #define NREPEAT
    Definition: s2let_test_csv.c:47
    -
    main
    int main(int argc, char **argv)
    Definition: s2let_test_csv.c:52
    -
    s2let_parameters_t::original_spin
    int original_spin
    Definition: s2let_types.h:122
    -
    ran2_dp
    double ran2_dp(int idum)
    Definition: s2let_math.c:104
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_allocate_f_wav
    void s2let_allocate_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_alloc.c:105
    -
    s2let_lm_random_flm
    void s2let_lm_random_flm(complex double *flm, int L, int spin, int seed)
    Definition: s2let_lm.c:34
    -
    MAX
    #define MAX(a, b)
    Definition: s2let_math.h:12
    -
    s2let_synthesis_wav2px
    void s2let_synthesis_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_synthesis.c:520
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_allocate_lm
    void s2let_allocate_lm(complex double **flm, int L)
    Definition: s2let_alloc.c:62
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__tiling_8c.html b/docs/c/s2let__tiling_8c.html index b2bd0fcd..a914b3a7 100644 --- a/docs/c/s2let__tiling_8c.html +++ b/docs/c/s2let__tiling_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_tiling.c File Reference +s2let: src/main/c/s2let_tiling.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -76,13 +76,47 @@
    s2let_tiling.c File Reference
    -
    #include "s2let.h"
    -#include <math.h>
    -#include <stdlib.h>
    +
    #include <math.h>
    #include <stdio.h>
    -
    -

    Go to the source code of this file.

    - +#include <stdlib.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_tiling.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +

    Enumerations

    enum  s2let_kernel_type { S2DW, @@ -149,8 +183,6 @@

    SPLINE 

    -

    Definition at line 12 of file s2let_tiling.c.

    -

    Function Documentation

    @@ -194,8 +226,6 @@

    Definition at line 51 of file s2let_tiling.c.

    - @@ -227,8 +257,6 @@

    Definition at line 108 of file s2let_tiling.c.

    - @@ -271,8 +299,6 @@

    Definition at line 83 of file s2let_tiling.c.

    - @@ -293,7 +319,7 @@

    Parameters
    - +
    [in]typenumInteger: 1 for scale-discretised, 2 for needlets and 3 for spline wavelets.
    [in]typenumInteger: 1 for scale-discretised, 2 for needlets and 3 for spline wavelets.
    @@ -304,8 +330,6 @@

    Definition at line 23 of file s2let_tiling.c.

    - @@ -355,8 +379,6 @@

    Definition at line 217 of file s2let_tiling.c.

    - @@ -406,8 +428,6 @@

    Definition at line 126 of file s2let_tiling.c.

    - @@ -457,8 +477,6 @@

    Definition at line 452 of file s2let_tiling.c.

    - @@ -495,8 +513,6 @@

    Definition at line 286 of file s2let_tiling.c.

    - @@ -539,8 +555,6 @@

    Definition at line 265 of file s2let_tiling.c.

    - @@ -583,8 +597,6 @@

    Definition at line 490 of file s2let_tiling.c.

    - @@ -613,8 +625,6 @@

    -

    Definition at line 158 of file s2let_tiling.c.

    - @@ -643,8 +653,6 @@

    -

    Definition at line 135 of file s2let_tiling.c.

    - @@ -673,8 +681,6 @@

    -

    Definition at line 183 of file s2let_tiling.c.

    - @@ -718,8 +724,6 @@

    Definition at line 388 of file s2let_tiling.c.

    - @@ -769,8 +773,6 @@

    Definition at line 339 of file s2let_tiling.c.

    - @@ -820,8 +822,6 @@

    Definition at line 529 of file s2let_tiling.c.

    -

    Variable Documentation

    @@ -837,14 +837,12 @@

    -

    Definition at line 13 of file s2let_tiling.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__tiling_8c__incl.map b/docs/c/s2let__tiling_8c__incl.map new file mode 100644 index 00000000..7fe169ec --- /dev/null +++ b/docs/c/s2let__tiling_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__tiling_8c__incl.md5 b/docs/c/s2let__tiling_8c__incl.md5 new file mode 100644 index 00000000..1ebdc2d8 --- /dev/null +++ b/docs/c/s2let__tiling_8c__incl.md5 @@ -0,0 +1 @@ +6dea279a0f9b20ca2ceacaa6187ea6a0 \ No newline at end of file diff --git a/docs/c/s2let__tiling_8c_source.html b/docs/c/s2let__tiling_8c_source.html deleted file mode 100644 index d1b8293a..00000000 --- a/docs/c/s2let__tiling_8c_source.html +++ /dev/null @@ -1,531 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_tiling.c Source File - - - - - - - - - -
    -
    - - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_tiling.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <math.h>
    -
    7 #include <stdlib.h>
    -
    8 #include <stdio.h>
    -
    9 
    -
    10 //
    -
    11 //
    -
    12 typedef enum { S2DW, NEEDLET, SPLINE } s2let_kernel_type ;
    -
    13 s2let_kernel_type s2let_kernel = S2DW;
    -
    14 //
    -
    15 //
    -
    16 
    -
    23 void s2let_switch_wavtype(int typenum)
    -
    24 {
    -
    25  //printf("Input wavelet type : %i\n",typenum);
    -
    26  if (typenum == 1){
    -
    27  //printf("Kernel switch 1: using scale-discretised wavelets.\n");
    -
    28  s2let_kernel = S2DW;
    -
    29  } else if (typenum == 2){
    -
    30  //printf("Kernel switch 2: using needlets.\n");
    -
    31  s2let_kernel = NEEDLET;
    -
    32  } else if (typenum == 3){
    -
    33  //printf("Kernel switch 3: using cubic splines wavelets.\n");
    -
    34  s2let_kernel = SPLINE;
    -
    35  } else {
    -
    36  printf("Kernel number should be 1, 2 or 3. Default is 1.\n");
    -
    37  s2let_kernel = S2DW;
    -
    38  }
    -
    39 }
    -
    40 
    -
    51 int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    -
    52 {
    -
    53  double B = parameters->B;
    -
    54  int L = parameters->L;
    -
    55  // int J_min = parameters->J_min;
    -
    56 
    -
    57  int Jmax;
    -
    58  switch (s2let_kernel)
    -
    59  {
    -
    60  case S2DW:
    -
    61  case NEEDLET:
    -
    62  return ceil(pow(B, j+1));
    -
    63  case SPLINE:
    -
    64  Jmax = s2let_j_max(parameters);
    -
    65  if (j == Jmax) return L;
    -
    66  //if (j < J_min) return ceil(L / (double) pow(B, Jmax-J_min-1));
    -
    67  return ceil(L / pow(B, Jmax-j-2));
    -
    68  default:
    -
    69  // This should never happen
    -
    70  return -1;
    -
    71  }
    -
    72 }
    -
    73 
    -
    83 int s2let_L0(int j, const s2let_parameters_t *parameters)
    -
    84 {
    -
    85  double B = parameters->B;
    -
    86 
    -
    87  switch (s2let_kernel)
    -
    88  {
    -
    89  case S2DW:
    -
    90  case NEEDLET:
    -
    91  return ceil(pow(B, j-1));
    -
    92  case SPLINE:
    -
    93  return 0;
    -
    94  default:
    -
    95  // This should never happen
    -
    96  return -1;
    -
    97  }
    -
    98 }
    -
    99 
    -
    108 int s2let_j_max(const s2let_parameters_t *parameters)
    -
    109 {
    -
    110  double B = parameters->B;
    -
    111  int L = parameters->L;
    -
    112 
    -
    113  return ceil(log(L) / log(B));
    -
    114 }
    -
    115 
    -
    126 void s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters)
    -
    127 {
    -
    128  int L = parameters->L;
    -
    129 
    -
    130  int J = s2let_j_max(parameters);
    -
    131  *kappa = calloc((J+1) * L, sizeof **kappa);
    -
    132  *kappa0 = calloc(L, sizeof **kappa0);
    -
    133 }
    -
    134 
    -
    135 void s2let_tiling_phi2_s2dw(double *phi2, const s2let_parameters_t *parameters)
    -
    136 {
    -
    137  int L = parameters->L;
    -
    138  double B = parameters->B;
    -
    139 
    -
    140  int j, l;
    -
    141  int J = s2let_j_max(parameters);
    -
    142  int n = 300;
    -
    143 
    -
    144  double kappanorm = s2let_math_kappa0_quadtrap_s2dw(1.0 / B, 1.0, n, B);
    -
    145  for (j = 0; j <= J+1; j++){
    -
    146  for (l = 0; l < L; l++){
    -
    147  if (l < pow(B,j-1)) {
    -
    148  phi2[l+j*L] = 1;
    -
    149  } else if (l > pow(B,j)) {
    -
    150  phi2[l+j*L] = 0;
    -
    151  } else {
    -
    152  phi2[l+j*L] = s2let_math_kappa0_quadtrap_s2dw((double)l / pow(B, j), 1.0, n, B) / kappanorm;
    -
    153  }
    -
    154  }
    -
    155  }
    -
    156 }
    -
    157 
    -
    158 void s2let_tiling_phi2_needlet(double *phi2, const s2let_parameters_t *parameters)
    -
    159 {
    -
    160  int L = parameters->L;
    -
    161  double B = parameters->B;
    -
    162 
    -
    163  int j, l;
    -
    164  int J = s2let_j_max(parameters);
    -
    165  int n = 300;
    -
    166  double u;
    -
    167 
    -
    168  double kappanorm = s2let_math_kappa0_quadtrap_needlet(-1.0, 1.0, n);
    -
    169  for (j = 0; j <= J+1; j++){
    -
    170  for (l = 0; l < L; l++){
    -
    171  if (l < pow(B,j-1)) {
    -
    172  phi2[l+j*L] = 1;
    -
    173  } else if (l > pow(B,j)) {
    -
    174  phi2[l+j*L] = 0;
    -
    175  } else {
    -
    176  u = 1.0 - 2.0 * B / (B - 1.0) * ( l * pow(B, -j) - 1.0 / B );
    -
    177  phi2[l+j*L] = s2let_math_kappa0_quadtrap_needlet(-1.0, u, n) / kappanorm;
    -
    178  }
    -
    179  }
    -
    180  }
    -
    181 }
    -
    182 
    -
    183 void s2let_tiling_phi2_spline(double *phi2, const s2let_parameters_t *parameters)
    -
    184 {
    -
    185  int L = parameters->L;
    -
    186  double B = parameters->B;
    -
    187 
    -
    188  int j = 0, l;
    -
    189  int J = s2let_j_max(parameters);
    -
    190  phi2[(J+1-j)*L] = 1.0;
    -
    191  for (l = 1; l < L; l++){
    -
    192  phi2[l+(J+1-j)*L] = 1.0;
    -
    193  }
    -
    194  for (j = 1; j <= J+1; j++){
    -
    195  double bl = (double) L / (double) pow(B, j-2);
    -
    196  phi2[(J+1-j)*L] = 1.0;
    -
    197  for (l = 1; l < L; l++){
    -
    198  if (l > bl)
    -
    199  phi2[l+(J+1-j)*L] = 0.0;
    -
    200  else
    -
    201  phi2[l+(J+1-j)*L] = s2let_math_spline_scalingfct((double) l, bl);
    -
    202  }
    -
    203  }
    -
    204 }
    -
    205 
    -
    217 void s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    -
    218 {
    -
    219  int L = parameters->L;
    -
    220  int J_min = parameters->J_min;
    -
    221 
    -
    222  int j, l;
    -
    223  int J = s2let_j_max(parameters);
    -
    224 
    -
    225  double previoustemp = 0.0, temp;
    -
    226  double *phi2 = (double*)calloc((J+2) * L, sizeof(double));
    -
    227 
    -
    228  if(s2let_kernel == SPLINE)
    -
    229  s2let_tiling_phi2_spline(phi2, parameters); // SPLINE tiling
    -
    230  if(s2let_kernel == S2DW)
    -
    231  s2let_tiling_phi2_s2dw(phi2, parameters); // S2DW tiling
    -
    232  if(s2let_kernel == NEEDLET)
    -
    233  s2let_tiling_phi2_needlet(phi2, parameters); // Needlet tiling
    -
    234 
    -
    235  for (l = 0; l < L; l++)
    -
    236  kappa0[l] = sqrt(phi2[l+J_min*L]);
    -
    237 
    -
    238  for (j = J_min; j <= J; j++){
    -
    239  for (l = 0; l < L; l++){
    -
    240  temp = sqrt(phi2[l+(j+1)*L] - phi2[l+j*L]);
    -
    241  if( isnan(temp) || isinf(temp) )
    -
    242  kappa[l+j*L] = previoustemp;
    -
    243  else
    -
    244  kappa[l+j*L] = temp;
    -
    245  previoustemp = temp;
    -
    246  }
    -
    247  for (l = 0; l < L; l++)
    -
    248  if( !isfinite(kappa[l+j*L]) )
    -
    249  kappa[l+j*L] = kappa[l+j*L-1];
    -
    250  }
    -
    251  free(phi2);
    -
    252 }
    -
    253 
    -
    265 void s2let_tiling_direction_allocate(complex double **s_elm, const s2let_parameters_t *parameters)
    -
    266 {
    -
    267  int L = parameters->L;
    -
    268  // TODO: This could be reduced by not storing s_elm with |m| >= N
    -
    269  *s_elm = calloc(L*L, sizeof **s_elm);
    -
    270 }
    -
    271 
    -
    286 void s2let_tiling_direction(complex double *s_elm, const s2let_parameters_t *parameters)
    -
    287 {
    -
    288  int L = parameters->L;
    -
    289  int N = parameters->N;
    -
    290 
    -
    291  // TODO: Add spin parameter to avoid computation of el < |s|
    -
    292  complex double nu;
    -
    293  int el, m, ind;
    -
    294 
    -
    295  if (N % 2)
    -
    296  nu = 1;
    -
    297  else
    -
    298  nu = I;
    -
    299 
    -
    300  // Skip the s_00 component, as it is zero.
    -
    301  ind = 1;
    -
    302 
    -
    303  for (el = 1; el < L; ++el)
    -
    304  {
    -
    305  int gamma;
    -
    306  // This if else replaces the -1^(N+l)
    -
    307  if ((N+el) % 2)
    -
    308  gamma = MIN(N-1, el);
    -
    309  else
    -
    310  gamma = MIN(N-1, el-1);
    -
    311 
    -
    312  for (m = -el; m <= el; ++m)
    -
    313  {
    -
    314  // This if/else takes care of the azimuthal
    -
    315  // band-limit and replaces the beta factor.
    -
    316  if (ABS(m) < N && (N+m) % 2)
    -
    317  s_elm[ind] = nu*sqrt(binomial_coefficient(gamma, (gamma - m)/2UL, 1)/pow(2, gamma));
    -
    318  else
    -
    319  s_elm[ind] = 0.0;
    -
    320 
    -
    321  ++ind;
    -
    322  }
    -
    323  }
    -
    324 }
    -
    325 
    -
    339 void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters)
    -
    340 {
    -
    341  int L = parameters->L;
    -
    342 
    -
    343  // TODO: This could be reduced by not storing psi_j_elm with |m| >= N
    -
    344  int J = s2let_j_max(parameters);
    -
    345  *psi = calloc((J+1) * L*L, sizeof **psi);
    -
    346  *phi = calloc(L, sizeof **phi);
    -
    347 }
    -
    348 
    -
    356 static double s2let_spin_normalization(int el, int spin)
    -
    357 {
    -
    358  double factor = 1;
    -
    359  int s;
    -
    360 
    -
    361  for (s = -ABS(spin)+1; s <= ABS(spin); ++s)
    -
    362  {
    -
    363  factor *= el+s;
    -
    364  }
    -
    365 
    -
    366  if (spin > 0)
    -
    367  return sqrt(factor);
    -
    368  else
    -
    369  return sqrt(1.0/factor);
    -
    370 }
    -
    371 
    -
    388 void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters) {
    -
    389  int L = parameters->L;
    -
    390  int J_min = parameters->J_min;
    -
    391  int spin = parameters->spin;
    -
    392  int original_spin = parameters->original_spin;
    -
    393 
    -
    394  // TODO: Add spin parameter to avoid computation of el < |s|
    -
    395  // TODO: Correctly compute spin scaling functions
    -
    396  double *kappa;
    -
    397  double *kappa0;
    -
    398  complex double *s_elm;
    -
    399  int j, el, m, el_min;
    -
    400  int J = s2let_j_max(parameters);
    -
    401 
    -
    402  // TODO: Allocate kappa0 directly inside phi. For this, we should probably
    -
    403  // separate the allocation functions to do only one allocation per
    -
    404  // function.
    -
    405  s2let_tiling_axisym_allocate(&kappa, &kappa0, parameters);
    -
    406  s2let_tiling_axisym(kappa, kappa0, parameters);
    -
    407  s2let_tiling_direction_allocate(&s_elm, parameters);
    -
    408  s2let_tiling_direction(s_elm, parameters);
    -
    409 
    -
    410  el_min = MAX(ABS(spin), ABS(original_spin));
    -
    411 
    -
    412  for (el = el_min; el < L; ++el)
    -
    413  {
    -
    414  phi[el] = sqrt((2*el+1)/(4.0*PI)) * kappa0[el];
    -
    415  if (original_spin != 0)
    -
    416  phi[el] *= s2let_spin_normalization(el, original_spin) * pow(-1, original_spin);
    -
    417  }
    -
    418 
    -
    419  for (j = J_min; j <= J; ++j)
    -
    420  {
    -
    421  int ind = el_min*el_min;
    -
    422  for (el = el_min; el < L; ++el)
    -
    423  {
    -
    424  for (m = -el; m <= el; ++m)
    -
    425  {
    -
    426  psi[j*L*L + ind] = sqrt((2*el+1)/(8.0*PI*PI)) * kappa[j*L + el] * s_elm[ind];
    -
    427  if (original_spin != 0)
    -
    428  psi[j*L*L + ind] *= s2let_spin_normalization(el, original_spin) * pow(-1, original_spin);
    -
    429  ++ind;
    -
    430  }
    -
    431  }
    -
    432  }
    -
    433 
    -
    434  free(kappa);
    -
    435  free(kappa0);
    -
    436  free(s_elm);
    -
    437 }
    -
    438 
    -
    452 double s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    -
    453 {
    -
    454  int L = parameters->L;
    -
    455 
    -
    456  int l, j;
    -
    457  int J = s2let_j_max(parameters);
    -
    458  //int l_min = s2let_el_min(B, J_min);
    -
    459  double error = 0;
    -
    460 
    -
    461  double *ident;
    -
    462  ident = calloc(L, sizeof *ident);
    -
    463 
    -
    464  for (l = 0; l < L; l++)
    -
    465  ident[l] = pow(kappa0[l], 2.0);
    -
    466 
    -
    467  for (l = 0; l < L; l++) {
    -
    468  for (j = 0; j <= J; j++) {
    -
    469  ident[l] += pow(kappa[l+j*L], 2.0);
    -
    470  }
    -
    471 
    -
    472  error = MAX(error, fabs(ident[l] - 1.0));
    -
    473  }
    -
    474 
    -
    475  free(ident);
    -
    476  return error;
    -
    477 }
    -
    478 
    -
    490 double s2let_tiling_direction_check_identity(complex double *s_elm, const s2let_parameters_t *parameters)
    -
    491 {
    -
    492  int L = parameters->L;
    -
    493 
    -
    494  int el, m, ind;
    -
    495  double error = 0.0; // maximum error for all el
    -
    496 
    -
    497  // Skip the s_00 component, as it is zero.
    -
    498  ind = 1;
    -
    499 
    -
    500  for (el = 1; el < L; ++el)
    -
    501  {
    -
    502  double sum = 0.0; // sum for each el
    -
    503  for (m = -el; m <= el; ++m)
    -
    504  {
    -
    505  sum += s_elm[ind] * conj(s_elm[ind]);
    -
    506  ++ind;
    -
    507  }
    -
    508 
    -
    509  error = MAX(error, fabs(sum - 1.0));
    -
    510  }
    -
    511 
    -
    512  return error;
    -
    513 }
    -
    514 
    -
    529 double s2let_tiling_wavelet_check_identity(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    -
    530 {
    -
    531  int L = parameters->L;
    -
    532  int spin = parameters->spin;
    -
    533 
    -
    534  int j, el, m, ind;
    -
    535  int J = s2let_j_max(parameters);
    -
    536  double error = 0.0; // maximum error for all el
    -
    537 
    -
    538  double *ident;
    -
    539  ident = calloc(L, sizeof *ident);
    -
    540 
    -
    541  for (el = ABS(spin); el < L; ++el)
    -
    542  {
    -
    543  ident[el] += 4.0*PI/(2*el+1) * phi[el] * phi[el];
    -
    544  }
    -
    545 
    -
    546  for (j = 0; j <= J; ++j)
    -
    547  {
    -
    548  ind = spin*spin;
    -
    549  for (el = ABS(spin); el < L; ++el)
    -
    550  {
    -
    551  for (m = -el; m <= el; ++m)
    -
    552  {
    -
    553  ident[el] += 8.0*PI*PI/(2*el+1) *
    -
    554  psi[j*L*L + ind] * conj(psi[j*L*L + ind]);
    -
    555  ++ind;
    -
    556  }
    -
    557  }
    -
    558  }
    -
    559 
    -
    560  for (el = ABS(spin); el < L; ++el)
    -
    561  {
    -
    562  error = MAX(error, fabs(ident[el] - 1.0));
    -
    563  }
    -
    564 
    -
    565  return error;
    -
    566 }
    -
    -
    s2let_tiling_axisym_allocate
    void s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:126
    -
    SPLINE
    @ SPLINE
    Definition: s2let_tiling.c:12
    -
    s2let_math_kappa0_quadtrap_s2dw
    double s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B)
    Definition: s2let_math.c:57
    -
    s2let_tiling_wavelet_allocate
    void s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:339
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    ABS
    #define ABS(a)
    Definition: s2let_math.h:13
    -
    s2let_math_kappa0_quadtrap_needlet
    double s2let_math_kappa0_quadtrap_needlet(double a, double b, int n)
    Definition: s2let_math.c:80
    -
    s2let_tiling_axisym
    void s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:217
    -
    s2let_kernel
    s2let_kernel_type s2let_kernel
    Definition: s2let_tiling.c:13
    -
    s2let_switch_wavtype
    void s2let_switch_wavtype(int typenum)
    Definition: s2let_tiling.c:23
    -
    s2let_tiling_wavelet_check_identity
    double s2let_tiling_wavelet_check_identity(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:529
    -
    S2DW
    @ S2DW
    Definition: s2let_tiling.c:12
    -
    binomial_coefficient
    unsigned long binomial_coefficient(int n, int k, int exact)
    Definition: s2let_math.c:248
    -
    s2let_tiling_direction_allocate
    void s2let_tiling_direction_allocate(complex double **s_elm, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:265
    -
    s2let_tiling_direction_check_identity
    double s2let_tiling_direction_check_identity(complex double *s_elm, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:490
    -
    s2let_parameters_t::original_spin
    int original_spin
    Definition: s2let_types.h:122
    -
    s2let_tiling_wavelet
    void s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:388
    -
    NEEDLET
    @ NEEDLET
    Definition: s2let_tiling.c:12
    -
    s2let_tiling_direction
    void s2let_tiling_direction(complex double *s_elm, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:286
    -
    PI
    #define PI
    Definition: s2let_math.h:9
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_tiling_phi2_s2dw
    void s2let_tiling_phi2_s2dw(double *phi2, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:135
    -
    s2let_kernel_type
    s2let_kernel_type
    Definition: s2let_tiling.c:12
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_tiling_phi2_needlet
    void s2let_tiling_phi2_needlet(double *phi2, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:158
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_L0
    int s2let_L0(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:83
    -
    MAX
    #define MAX(a, b)
    Definition: s2let_math.h:12
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_math_spline_scalingfct
    double s2let_math_spline_scalingfct(double x, double y)
    Definition: s2let_math.c:49
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_tiling_axisym_check_identity
    double s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:452
    -
    s2let_tiling_phi2_spline
    void s2let_tiling_phi2_spline(double *phi2, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:183
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__tiling_8h.html b/docs/c/s2let__tiling_8h.html index ff65e39d..32ad9d37 100644 --- a/docs/c/s2let__tiling_8h.html +++ b/docs/c/s2let__tiling_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_tiling.h File Reference +s2let: include/s2let_tiling.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -76,6 +76,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_tiling.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -126,8 +176,6 @@

    -

    Definition at line 9 of file s2let_tiling.h.

    -

    Function Documentation

    @@ -171,8 +219,6 @@

    Definition at line 51 of file s2let_tiling.c.

    - @@ -204,8 +250,6 @@

    Definition at line 108 of file s2let_tiling.c.

    - @@ -248,8 +292,6 @@

    Definition at line 83 of file s2let_tiling.c.

    - @@ -270,7 +312,7 @@

    Parameters

    - +
    [in]typenumInteger: 1 for scale-discretised, 2 for needlets and 3 for spline wavelets.
    [in]typenumInteger: 1 for scale-discretised, 2 for needlets and 3 for spline wavelets.
    @@ -281,8 +323,6 @@

    Definition at line 23 of file s2let_tiling.c.

    -

    @@ -332,8 +372,6 @@

    Definition at line 217 of file s2let_tiling.c.

    - @@ -383,8 +421,6 @@

    Definition at line 126 of file s2let_tiling.c.

    - @@ -434,8 +470,6 @@

    Definition at line 452 of file s2let_tiling.c.

    - @@ -627,7 +661,7 @@

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__tiling_8h__dep__incl.map b/docs/c/s2let__tiling_8h__dep__incl.map new file mode 100644 index 00000000..b9d9778f --- /dev/null +++ b/docs/c/s2let__tiling_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__tiling_8h__dep__incl.md5 b/docs/c/s2let__tiling_8h__dep__incl.md5 new file mode 100644 index 00000000..e9236098 --- /dev/null +++ b/docs/c/s2let__tiling_8h__dep__incl.md5 @@ -0,0 +1 @@ +592510ae5e70cf3171716d06f91d7870 \ No newline at end of file diff --git a/docs/c/s2let__tiling_8h__incl.map b/docs/c/s2let__tiling_8h__incl.map new file mode 100644 index 00000000..e716f32a --- /dev/null +++ b/docs/c/s2let__tiling_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__tiling_8h__incl.md5 b/docs/c/s2let__tiling_8h__incl.md5 new file mode 100644 index 00000000..39a3aefe --- /dev/null +++ b/docs/c/s2let__tiling_8h__incl.md5 @@ -0,0 +1 @@ +0500042c2da34eab0682f3d369119017 \ No newline at end of file diff --git a/docs/c/s2let__tiling_8h_source.html b/docs/c/s2let__tiling_8h_source.html index c02a04a6..86f5246a 100644 --- a/docs/c/s2let__tiling_8h_source.html +++ b/docs/c/s2let__tiling_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_tiling.h Source File +s2let: include/s2let_tiling.h Source File @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -116,24 +116,24 @@
    42 #endif
    43 #endif
    -
    s2let_tiling_axisym_allocate
    void s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:126
    -
    s2let_tiling_axisym
    void s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:217
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    s2let_tiling_axisym_allocate
    void s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:122
    +
    s2let_tiling_axisym
    void s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:212
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    s2let_tiling_direction_allocate
    void s2let_tiling_direction_allocate(S2LET_COMPLEX(double) **s_elm, const s2let_parameters_t *parameters)
    s2let_tiling_direction_check_identity
    double s2let_tiling_direction_check_identity(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters)
    s2let_tiling_direction
    void s2let_tiling_direction(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters)
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_switch_wavtype
    void s2let_switch_wavtype(int typenum)
    Definition: s2let_tiling.c:23
    -
    s2let_tiling_axisym_check_identity
    double s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:452
    +
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    +
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:105
    +
    s2let_switch_wavtype
    void s2let_switch_wavtype(int typenum)
    Definition: s2let_tiling.c:24
    +
    s2let_tiling_axisym_check_identity
    double s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:444
    s2let_tiling_wavelet_check_identity
    double s2let_tiling_wavelet_check_identity(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters)
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    s2let_tiling_wavelet
    void s2let_tiling_wavelet(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters)
    s2let_tiling_wavelet_allocate
    void s2let_tiling_wavelet_allocate(S2LET_COMPLEX(double) **psi, double **phi, const s2let_parameters_t *parameters)
    -
    s2let_L0
    int s2let_L0(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:83
    +
    s2let_L0
    int s2let_L0(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:82
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__analysis__hpx__real_8c.html b/docs/c/s2let__transform__axisym__analysis__hpx__real_8c.html index 2472b565..5d7c44c7 100644 --- a/docs/c/s2let__transform__axisym__analysis__hpx__real_8c.html +++ b/docs/c/s2let__transform__axisym__analysis__hpx__real_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_transform_axisym_analysis_hpx_real.c File Reference +s2let: src/main/c/s2let_transform_axisym_analysis_hpx_real.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,17 +74,53 @@
    s2let_transform_axisym_analysis_hpx_real.c File Reference
    -
    #include "s2let.h"
    -#include <assert.h>
    +
    #include <assert.h>
    #include <complex.h>
    +#include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    -#include <math.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_transform_axisym_analysis_hpx_real.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -123,14 +159,12 @@

    Definition at line 24 of file s2let_transform_axisym_analysis_hpx_real.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__analysis__hpx__real_8c__incl.map b/docs/c/s2let__transform__axisym__analysis__hpx__real_8c__incl.map new file mode 100644 index 00000000..92f8c31c --- /dev/null +++ b/docs/c/s2let__transform__axisym__analysis__hpx__real_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__analysis__hpx__real_8c__incl.md5 b/docs/c/s2let__transform__axisym__analysis__hpx__real_8c__incl.md5 new file mode 100644 index 00000000..fedbeaeb --- /dev/null +++ b/docs/c/s2let__transform__axisym__analysis__hpx__real_8c__incl.md5 @@ -0,0 +1 @@ +918569133937e12e0b7af8a5c2fb845d \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__analysis__hpx__real_8c_source.html b/docs/c/s2let__transform__axisym__analysis__hpx__real_8c_source.html deleted file mode 100644 index e218f600..00000000 --- a/docs/c/s2let__transform__axisym__analysis__hpx__real_8c_source.html +++ /dev/null @@ -1,180 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_transform_axisym_analysis_hpx_real.c Source File - - - - - - - - - -
    -
    -

    Functions

    int main (int argc, char *argv[])
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_transform_axisym_analysis_hpx_real.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <assert.h>
    -
    7 #include <complex.h>
    -
    8 #include <stdio.h>
    -
    9 #include <stdlib.h>
    -
    10 #include <string.h>
    -
    11 #include <math.h>
    -
    12 #include <time.h>
    -
    13 
    -
    24 int main(int argc, char *argv[])
    -
    25 {
    -
    26  printf("--------------------------------------------------\n");
    -
    27  printf("S2LET library : axisymmetric wavelet transform\n");
    -
    28  printf("Real signal, HEALPIX sampling\n");
    -
    29  printf("--------------------------------------------------\n");
    -
    30 
    -
    31  char file[100];
    -
    32  if (sscanf(argv[1], "%s", file) != 1)
    -
    33  exit(-2);
    -
    34  printf("Input HEALPIX map : %s\n",file);
    -
    35  const int nside = s2let_fits_hpx_read_nside(file);
    -
    36  printf("- Detected bandlimit nside = %i\n",nside);
    -
    37  int L, J_min;
    -
    38  double B;
    -
    39  if (sscanf(argv[2], "%i", &B) != 1)
    -
    40  exit(-2);
    -
    41  if (sscanf(argv[3], "%i", &J_min) != 1)
    -
    42  exit(-2);
    -
    43  if (sscanf(argv[4], "%i", &L) != 1)
    -
    44  exit(-2);
    -
    45 
    -
    46  s2let_parameters_t parameters = {};
    -
    47  parameters.B = B;
    -
    48  parameters.L = L;
    -
    49  parameters.J_min = J_min;
    -
    50 
    -
    51  printf("Parameters for wavelet transform :\n");
    -
    52  printf("- Wavelet parameter : %i\n", L);
    -
    53  int J = s2let_j_max(&parameters);
    -
    54  printf("- Wavelet parameter : %i\n", B);
    -
    55  printf("- Total number of wavelets : %i\n", J);
    -
    56  printf("- First wavelet scale to be used : %i\n", J_min);
    -
    57 
    -
    58  // Read MW map from file
    -
    59  double *f = (double*)calloc(12*nside*nside, sizeof(double));
    -
    60  s2let_hpx_read_map(f, file, nside);
    -
    61  printf("File successfully read from file\n");
    -
    62 
    -
    63  printf("Performing wavelet decomposition...");fflush(NULL);
    -
    64  double *f_wav, *f_scal;
    -
    65  s2let_transform_axisym_allocate_hpx_f_wav_real(&f_wav, &f_scal, nside, &parameters);
    -
    66  s2let_transform_axisym_wav_analysis_hpx_real(f_wav, f_scal, f, nside, &parameters);
    -
    67  printf("done\n");
    -
    68 
    -
    69  // Output the wavelets to FITS files
    -
    70  printf("Writing wavelet maps to FITS files\n");
    -
    71  char outfile[100];
    -
    72  char params[100];
    -
    73  sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min);
    -
    74  int j; // Explicitly compute the maximum wavelet scale
    -
    75  int offset = 0; // Start with the first wavelet
    -
    76  char fileroot[100];
    -
    77  sscanf(file, "%[^.]", fileroot);
    -
    78  printf("File root = %s\n",fileroot);
    -
    79  for(j = J_min; j <= J; j++){
    -
    80  sprintf(outfile, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits");
    -
    81  printf("- Outfile_wav[j=%i] = %s\n",j,outfile);
    -
    82  remove(outfile); // In case the file exists
    -
    83  s2let_hpx_write_map(outfile, f_wav + offset, nside); // Now write the map to fits file
    -
    84  offset += 12*nside*nside; // Go to the next wavelet
    -
    85  }
    -
    86  // Finally write the scaling function
    -
    87  sprintf(outfile, "%s%s%s%s", fileroot, "_scal_", params, ".fits");
    -
    88  printf("- Outfile_scal = %s\n",outfile);
    -
    89  remove(outfile); // In case the file exists
    -
    90  s2let_hpx_write_map(outfile, f_scal, nside); // Now write the map to fits file
    -
    91 
    -
    92  printf("--------------------------------------------------\n");
    -
    93 
    -
    94  return 0;
    -
    95 }
    -
    96 
    -
    97 
    -
    -
    s2let_transform_axisym_allocate_hpx_f_wav_real
    void s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:9
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_hpx_write_map
    void s2let_hpx_write_map(char *file, const double *f, int nside)
    Definition: s2let_hpx.c:50
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_fits_hpx_read_nside
    int s2let_fits_hpx_read_nside(char *filename)
    Definition: s2let_fits.c:59
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_transform_axisym_analysis_hpx_real.c:24
    -
    s2let_transform_axisym_wav_analysis_hpx_real
    void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:18
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_hpx_read_map
    void s2let_hpx_read_map(double *f, char *file, int nside)
    Definition: s2let_hpx.c:45
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__transform__axisym__analysis__mw__real_8c.html b/docs/c/s2let__transform__axisym__analysis__mw__real_8c.html index 2b22787a..803f8f8f 100644 --- a/docs/c/s2let__transform__axisym__analysis__mw__real_8c.html +++ b/docs/c/s2let__transform__axisym__analysis__mw__real_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_transform_axisym_analysis_mw_real.c File Reference +s2let: src/main/c/s2let_transform_axisym_analysis_mw_real.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,17 +74,53 @@
    s2let_transform_axisym_analysis_mw_real.c File Reference
    -
    #include "s2let.h"
    -#include <assert.h>
    +
    #include <assert.h>
    #include <complex.h>
    +#include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    -#include <math.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_transform_axisym_analysis_mw_real.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -123,14 +159,12 @@

    Definition at line 24 of file s2let_transform_axisym_analysis_mw_real.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__analysis__mw__real_8c__incl.map b/docs/c/s2let__transform__axisym__analysis__mw__real_8c__incl.map new file mode 100644 index 00000000..80fac0f1 --- /dev/null +++ b/docs/c/s2let__transform__axisym__analysis__mw__real_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__analysis__mw__real_8c__incl.md5 b/docs/c/s2let__transform__axisym__analysis__mw__real_8c__incl.md5 new file mode 100644 index 00000000..05388e72 --- /dev/null +++ b/docs/c/s2let__transform__axisym__analysis__mw__real_8c__incl.md5 @@ -0,0 +1 @@ +b4b031547ad1ec344ba88002d182cc84 \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__analysis__mw__real_8c_source.html b/docs/c/s2let__transform__axisym__analysis__mw__real_8c_source.html deleted file mode 100644 index c9d0ba93..00000000 --- a/docs/c/s2let__transform__axisym__analysis__mw__real_8c_source.html +++ /dev/null @@ -1,197 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_transform_axisym_analysis_mw_real.c Source File - - - - - - - - - -
    -
    -

    Functions

    int main (int argc, char *argv[])
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_transform_axisym_analysis_mw_real.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <assert.h>
    -
    7 #include <complex.h>
    -
    8 #include <stdio.h>
    -
    9 #include <stdlib.h>
    -
    10 #include <string.h>
    -
    11 #include <math.h>
    -
    12 #include <time.h>
    -
    13 
    -
    24 int main(int argc, char *argv[])
    -
    25 {
    -
    26  printf("--------------------------------------------------\n");
    -
    27  printf("S2LET library : axisymmetric wavelet transform\n");
    -
    28  printf("Real signal, MW sampling\n");
    -
    29  printf("--------------------------------------------------\n");
    -
    30 
    -
    31  char file[100];
    -
    32  if (sscanf(argv[1], "%s", file) != 1)
    -
    33  exit(-2);
    -
    34  printf("Input MW map : %s\n",file);
    -
    35  const int L = s2let_fits_mw_read_bandlimit(file);
    -
    36  printf("- Detected bandlimit L = %i\n",L);
    -
    37  int B, J_min, multires;
    -
    38  if (sscanf(argv[2], "%i", &B) != 1)
    -
    39  exit(-2);
    -
    40  if (sscanf(argv[3], "%i", &J_min) != 1)
    -
    41  exit(-2);
    -
    42  if (sscanf(argv[4], "%i", &multires) != 1)
    -
    43  exit(-2);
    -
    44 
    -
    45  s2let_parameters_t parameters = {};
    -
    46 
    -
    47  parameters.B = B;
    -
    48  parameters.L = L;
    -
    49  parameters.J_min = J_min;
    -
    50 
    -
    51  printf("Parameters for wavelet transform :\n");
    -
    52  int J = s2let_j_max(&parameters);
    -
    53  printf("- Multiresolution flag : %i\n", multires);
    -
    54  printf("- Wavelet parameter : %i\n", B);
    -
    55  printf("- Total number of wavelets : %i\n", J);
    -
    56  printf("- First wavelet scale to be used : %i\n", J_min);
    -
    57 
    -
    58  // Read MW map from file
    -
    59  double *f = (double*)calloc(L * (2 * L - 1), sizeof(double));
    -
    60  s2let_fits_mw_read_map(f, file, L);
    -
    61  printf("File successfully read from file\n");
    -
    62 
    -
    63  printf("Performing wavelet decomposition...");fflush(NULL);
    -
    64  double *f_wav, *f_scal;
    -
    65  if(multires){
    -
    66  s2let_transform_axisym_allocate_mw_f_wav_multires_real(&f_wav, &f_scal, &parameters);
    -
    67  s2let_transform_axisym_wav_analysis_mw_multires_real(f_wav, f_scal, f, &parameters);
    -
    68  }else{
    -
    69  s2let_transform_axisym_allocate_mw_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    70  s2let_transform_axisym_wav_analysis_mw_real(f_wav, f_scal, f, &parameters);
    -
    71  }
    -
    72  printf("done\n");
    -
    73 
    -
    74  // Output the wavelets to FITS files
    -
    75  printf("Writing wavelet maps to FITS files\n");
    -
    76  char outfile[100];
    -
    77  char params[100];
    -
    78  sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min);
    -
    79  int j, bl; // Explicitly compute the maximum wavelet scale
    -
    80  int offset = 0; // Start with the first wavelet
    -
    81  char fileroot[100];
    -
    82  sscanf(file, "%[^.]", fileroot);
    -
    83  printf("File root = %s\n",fileroot);
    -
    84  for(j = J_min; j <= J; j++){
    -
    85  sprintf(outfile, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits");
    -
    86  printf("- Outfile_wav[j=%i] = %s\n",j,outfile);
    -
    87  remove(outfile); // In case the file exists
    -
    88  if(multires)
    -
    89  bl = MIN(s2let_bandlimit(j, &parameters), L);
    -
    90  else
    -
    91  bl = L;
    -
    92  s2let_fits_mw_write_map(outfile, f_wav + offset, bl); // Now write the map to fits file
    -
    93  offset += (2*bl-1) * bl; // Go to the next wavelet
    -
    94  }
    -
    95  // Finally write the scaling function
    -
    96  sprintf(outfile, "%s%s%s%s", fileroot, "_scal_", params, ".fits");
    -
    97  printf("- Outfile_scal = %s\n",outfile);
    -
    98  remove(outfile); // In case the file exists
    -
    99  if(multires)
    -
    100  bl = MIN(s2let_bandlimit(J_min-1, &parameters), L);
    -
    101  else
    -
    102  bl = L;
    -
    103  s2let_fits_mw_write_map(outfile, f_scal, bl); // Now write the map to fits file
    -
    104 
    -
    105  printf("--------------------------------------------------\n");
    -
    106 
    -
    107  return 0;
    -
    108 }
    -
    109 
    -
    110 
    -
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_transform_axisym_analysis_mw_real.c:24
    -
    s2let_transform_axisym_wav_analysis_mw_real
    void s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:660
    -
    s2let_transform_axisym_wav_analysis_mw_multires_real
    void s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:918
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_transform_axisym_allocate_mw_f_wav_real
    void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:74
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_fits_mw_read_bandlimit
    int s2let_fits_mw_read_bandlimit(char *filename)
    Definition: s2let_fits.c:18
    -
    s2let_fits_mw_write_map
    void s2let_fits_mw_write_map(char *filename, double *f, int L)
    Definition: s2let_fits.c:98
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_fits_mw_read_map
    void s2let_fits_mw_read_map(double *f, char *filename, int L)
    Definition: s2let_fits.c:207
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_transform_axisym_allocate_mw_f_wav_multires_real
    void s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:94
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__transform__axisym__hpx_8c.html b/docs/c/s2let__transform__axisym__hpx_8c.html index 3098f1b8..242f50f4 100644 --- a/docs/c/s2let__transform__axisym__hpx_8c.html +++ b/docs/c/s2let__transform__axisym__hpx_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_transform_axisym_hpx.c File Reference +s2let: src/main/c/s2let_transform_axisym_hpx.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,12 +74,45 @@
    s2let_transform_axisym_hpx.c File Reference
    -
    #include "s2let.h"
    -#include <complex.h>
    +
    #include <complex.h>
    #include <stdlib.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_transform_axisym_hpx.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -146,8 +179,6 @@

    Definition at line 9 of file s2let_transform_axisym_hpx.c.

    - @@ -213,8 +244,6 @@

    Definition at line 18 of file s2let_transform_axisym_hpx.c.

    - @@ -280,14 +309,12 @@

    Definition at line 55 of file s2let_transform_axisym_hpx.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__hpx_8c__incl.map b/docs/c/s2let__transform__axisym__hpx_8c__incl.map new file mode 100644 index 00000000..99e10ad0 --- /dev/null +++ b/docs/c/s2let__transform__axisym__hpx_8c__incl.map @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__hpx_8c__incl.md5 b/docs/c/s2let__transform__axisym__hpx_8c__incl.md5 new file mode 100644 index 00000000..24c60538 --- /dev/null +++ b/docs/c/s2let__transform__axisym__hpx_8c__incl.md5 @@ -0,0 +1 @@ +e16b666048cf07192f890437d42ebaeb \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__hpx_8c_source.html b/docs/c/s2let__transform__axisym__hpx_8c_source.html deleted file mode 100644 index c123c0a9..00000000 --- a/docs/c/s2let__transform__axisym__hpx_8c_source.html +++ /dev/null @@ -1,187 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_transform_axisym_hpx.c Source File - - - - - - - - - -
    -
    -

    Functions

    void s2let_transform_axisym_allocate_hpx_f_wav_real (double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters)
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_transform_axisym_hpx.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <complex.h>
    -
    7 #include <stdlib.h>
    -
    8 
    -
    9 void s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters)
    -
    10 {
    -
    11  int J_min = parameters->J_min;
    -
    12 
    -
    13  int J = s2let_j_max(parameters);
    -
    14  *f_wav = (double*)calloc((J+1-J_min) * 12*nside*nside, sizeof(double));
    -
    15  *f_scal = (double*)calloc(12*nside*nside, sizeof(double));
    -
    16 }
    -
    17 
    -
    18 void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters)
    -
    19 {
    -
    20  int L = parameters->L;
    -
    21  int J_min = parameters->J_min;
    -
    22 
    -
    23  int bandlimit, j, offset, offset_lm;
    -
    24  int J = s2let_j_max(parameters);
    -
    25 
    -
    26  double *wav_lm, *scal_lm;
    -
    27  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    28  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    29 
    -
    30  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    31  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    32  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    33 
    -
    34  s2let_hpx_map2alm_real(flm, f, nside, L);
    -
    35 
    -
    36  s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters);
    -
    37 
    -
    38  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    39  s2let_hpx_alm2map_real(f_scal, f_scal_lm, nside, bandlimit);
    -
    40 
    -
    41  offset = 0;
    -
    42  offset_lm = 0;
    -
    43  for(j = J_min; j <= J; j++){
    -
    44  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    45  s2let_hpx_alm2map_real(f_wav + offset, f_wav_lm + offset_lm, nside, bandlimit);
    -
    46  offset_lm += bandlimit * bandlimit;
    -
    47  offset += 12 * nside * nside;
    -
    48  }
    -
    49 
    -
    50  free(flm);
    -
    51  free(f_scal_lm);
    -
    52  free(f_wav_lm);
    -
    53 }
    -
    54 
    -
    55 void s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters)
    -
    56 {
    -
    57  int L = parameters->L;
    -
    58  int J_min = parameters->J_min;
    -
    59 
    -
    60  int bandlimit, j, offset, offset_lm;
    -
    61  int J = s2let_j_max(parameters);
    -
    62 
    -
    63  double *wav_lm, *scal_lm;
    -
    64  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    65  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    66 
    -
    67  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    68  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    69  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    70 
    -
    71  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    72  s2let_hpx_map2alm_real(f_scal_lm, f_scal, nside, bandlimit);
    -
    73  offset = 0;
    -
    74  offset_lm = 0;
    -
    75  for(j = J_min; j <= J; j++){
    -
    76  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    77  s2let_hpx_map2alm_real(f_wav_lm + offset_lm, f_wav + offset, nside, bandlimit);
    -
    78  offset_lm += bandlimit * bandlimit;
    -
    79  offset += 12 * nside * nside;
    -
    80  }
    -
    81 
    -
    82  s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters);
    -
    83 
    -
    84  s2let_hpx_alm2map_real(f, flm, nside, L);
    -
    85 
    -
    86  free(flm);
    -
    87  free(f_scal_lm);
    -
    88  free(f_wav_lm);
    -
    89 }
    -
    -
    s2let_transform_axisym_lm_wav
    void s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:98
    -
    s2let_transform_axisym_lm_allocate_wav
    void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:79
    -
    s2let_transform_axisym_allocate_hpx_f_wav_real
    void s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:9
    -
    s2let_hpx_map2alm_real
    void s2let_hpx_map2alm_real(complex double *flm, const double *f, int nside, int L)
    Definition: s2let_hpx.c:25
    -
    s2let_transform_axisym_lm_wav_synthesis_multires
    void s2let_transform_axisym_lm_wav_synthesis_multires(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:286
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_transform_axisym_lm_allocate_f_wav_multires
    void s2let_transform_axisym_lm_allocate_f_wav_multires(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:50
    -
    s2let_transform_axisym_wav_synthesis_hpx_real
    void s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:55
    -
    s2let_transform_axisym_wav_analysis_hpx_real
    void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:18
    -
    s2let_transform_axisym_lm_wav_analysis_multires
    void s2let_transform_axisym_lm_wav_analysis_multires(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:237
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    s2let_hpx_alm2map_real
    void s2let_hpx_alm2map_real(double *f, const complex double *flm, int nside, int L)
    Definition: s2let_hpx.c:20
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__transform__axisym__hpx_8h.html b/docs/c/s2let__transform__axisym__hpx_8h.html index c57dabf4..d1ab8f9c 100644 --- a/docs/c/s2let__transform__axisym__hpx_8h.html +++ b/docs/c/s2let__transform__axisym__hpx_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_transform_axisym_hpx.h File Reference +s2let: include/s2let_transform_axisym_hpx.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,7 +74,48 @@
    s2let_transform_axisym_hpx.h File Reference
    - +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +

    Go to the source code of this file.

    @@ -96,13 +96,13 @@
    65 #endif
    66 #endif
    -
    s2let_transform_axisym_wav_synthesis_hpx_real
    void s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:55
    -
    s2let_transform_axisym_allocate_hpx_f_wav_real
    void s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:9
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_transform_axisym_wav_analysis_hpx_real
    void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:18
    +
    s2let_transform_axisym_wav_synthesis_hpx_real
    void s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:61
    +
    s2let_transform_axisym_allocate_hpx_f_wav_real
    void s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:10
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_transform_axisym_wav_analysis_hpx_real
    void s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:19
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__lm_8c.html b/docs/c/s2let__transform__axisym__lm_8c.html index 87398fd1..cafd3ecf 100644 --- a/docs/c/s2let__transform__axisym__lm_8c.html +++ b/docs/c/s2let__transform__axisym__lm_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_transform_axisym_lm.c File Reference +s2let: src/main/c/s2let_transform_axisym_lm.c File Reference @@ -22,10 +22,10 @@ @@ -74,13 +74,47 @@
    s2let_transform_axisym_lm.c File Reference
    -
    #include "s2let.h"
    -#include <complex.h>
    +
    #include <complex.h>
    #include <math.h>
    #include <stdlib.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_transform_axisym_lm.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -

    @@ -143,8 +184,6 @@

    Definition at line 9 of file s2let_transform_axisym_hpx.c.

    - @@ -210,8 +249,6 @@

    Definition at line 18 of file s2let_transform_axisym_hpx.c.

    - @@ -277,14 +314,12 @@

    Definition at line 55 of file s2let_transform_axisym_hpx.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__hpx_8h__dep__incl.map b/docs/c/s2let__transform__axisym__hpx_8h__dep__incl.map new file mode 100644 index 00000000..4ed22b2e --- /dev/null +++ b/docs/c/s2let__transform__axisym__hpx_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__hpx_8h__dep__incl.md5 b/docs/c/s2let__transform__axisym__hpx_8h__dep__incl.md5 new file mode 100644 index 00000000..3a637550 --- /dev/null +++ b/docs/c/s2let__transform__axisym__hpx_8h__dep__incl.md5 @@ -0,0 +1 @@ +2639b99d38ac5aa2a224148e6e6c4126 \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__hpx_8h_source.html b/docs/c/s2let__transform__axisym__hpx_8h_source.html index 5256f3d0..f8c270cf 100644 --- a/docs/c/s2let__transform__axisym__hpx_8h_source.html +++ b/docs/c/s2let__transform__axisym__hpx_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_transform_axisym_hpx.h Source File +s2let: include/s2let_transform_axisym_hpx.h Source File @@ -22,10 +22,10 @@

    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    @@ -150,8 +184,6 @@

    Definition at line 27 of file s2let_transform_axisym_lm.c.

    - @@ -188,11 +220,11 @@

    Parameters

    Functions

    void s2let_transform_axisym_lm_allocate_f_wav (complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    - - - - - + + + + +
    [out]f_wav_lmHarmonic coefficients of the wavelet contributions. The size of each wavelet depends on its band-limit.
    [out]f_scal_lmHarmonic coefficients of the scaling contribution.
    [in]BWavelet parameter.
    [in]LAngular harmonic band-limit.
    [in]J_minFirst wavelet scale to be used.
    [out]f_wav_lmHarmonic coefficients of the wavelet contributions. The size of each wavelet depends on its band-limit.
    [out]f_scal_lmHarmonic coefficients of the scaling contribution.
    [in]BWavelet parameter.
    [in]LAngular harmonic band-limit.
    [in]J_minFirst wavelet scale to be used.
    @@ -203,8 +235,6 @@

    Definition at line 50 of file s2let_transform_axisym_lm.c.

    -

    @@ -255,8 +285,6 @@

    Definition at line 79 of file s2let_transform_axisym_lm.c.

    - @@ -308,8 +336,6 @@

    Definition at line 98 of file s2let_transform_axisym_lm.c.

    - @@ -364,12 +390,12 @@

    Parameters
    - - - - - - + + + + + +
    [out]f_wav_lmWavelet transform (harmonic coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic decomposition of input function.
    [in]wav_lmWavelet kernels.
    [in]scal_lmScaling function kernels.
    [in]BWavelet parameter.
    [out]f_wav_lmWavelet transform (harmonic coefficients of wavelet contribution).
    [out]f_scal_lmWavelet transform (harmonic coefficients of scaling contribution).
    [in]flmSpherical harmonic decomposition of input function.
    [in]wav_lmWavelet kernels.
    [in]scal_lmScaling function kernels.
    [in]BWavelet parameter.
    [in]LAngular harmonic band-limit.
    [in]J_minFirst wavelet scale to be used.
    @@ -382,8 +408,6 @@

    Definition at line 141 of file s2let_transform_axisym_lm.c.

    - @@ -456,8 +480,6 @@

    Definition at line 237 of file s2let_transform_axisym_lm.c.

    - @@ -513,13 +535,13 @@

    Parameters
    - - - - - - - + + + + + + +
    [out]flmSpherical harmonic decomposition of input function.
    [in]f_wav_lmWavelet transform (harmonic coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lmScaling function kernels.
    [in]BWavelet parameter.
    [in]LAngular harmonic band-limit.
    [in]J_minFirst wavelet scale to be used.
    [in]f_wav_lmWavelet transform (harmonic coefficients of wavelet contribution).
    [in]f_scal_lmWavelet transform (harmonic coefficients of scaling contribution).
    [in]wav_lmWavelet kernels.
    [in]scal_lmScaling function kernels.
    [in]BWavelet parameter.
    [in]LAngular harmonic band-limit.
    [in]J_minFirst wavelet scale to be used.
    @@ -530,8 +552,6 @@

    Definition at line 189 of file s2let_transform_axisym_lm.c.

    - @@ -604,14 +624,12 @@

    Definition at line 286 of file s2let_transform_axisym_lm.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__lm_8c__incl.map b/docs/c/s2let__transform__axisym__lm_8c__incl.map new file mode 100644 index 00000000..5884eccd --- /dev/null +++ b/docs/c/s2let__transform__axisym__lm_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__lm_8c__incl.md5 b/docs/c/s2let__transform__axisym__lm_8c__incl.md5 new file mode 100644 index 00000000..0048dac4 --- /dev/null +++ b/docs/c/s2let__transform__axisym__lm_8c__incl.md5 @@ -0,0 +1 @@ +19d6a6e1e828a816fba7bc62deb60f80 \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__lm_8c_source.html b/docs/c/s2let__transform__axisym__lm_8c_source.html deleted file mode 100644 index f49e11f5..00000000 --- a/docs/c/s2let__transform__axisym__lm_8c_source.html +++ /dev/null @@ -1,322 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_transform_axisym_lm.c Source File - - - - - - - - - -
    -
    - - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_transform_axisym_lm.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <complex.h>
    -
    7 #include <math.h>
    -
    8 #include <stdlib.h>
    -
    9 
    -
    10 static inline int lm2ind(int el, int m)
    -
    11 {
    -
    12  return el*el + el + m;
    -
    13 }
    -
    14 
    -
    27 void s2let_transform_axisym_lm_allocate_f_wav(
    -
    28  complex double **f_wav_lm,
    -
    29  complex double **f_scal_lm,
    -
    30  const s2let_parameters_t *parameters
    -
    31 ) {
    -
    32  int L = parameters->L;
    -
    33  int J_min = parameters->J_min;
    -
    34 
    -
    35  int J = s2let_j_max(parameters);
    -
    36  *f_wav_lm = calloc((J+1-J_min) * L * L, sizeof **f_wav_lm);
    -
    37  *f_scal_lm = calloc(L * L, sizeof **f_scal_lm);
    -
    38 }
    -
    39 
    -
    50 void s2let_transform_axisym_lm_allocate_f_wav_multires(
    -
    51  complex double **f_wav_lm,
    -
    52  complex double **f_scal_lm,
    -
    53  const s2let_parameters_t *parameters
    -
    54 ) {
    -
    55  int L = parameters->L;
    -
    56  int J_min = parameters->J_min;
    -
    57 
    -
    58  int J = s2let_j_max(parameters);
    -
    59  int j, bandlimit, total = 0;
    -
    60  for (j = J_min; j <= J; ++j)
    -
    61  {
    -
    62  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    63  total += bandlimit * bandlimit;
    -
    64  }
    -
    65  *f_wav_lm = calloc(total, sizeof **f_wav_lm);
    -
    66  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    67  *f_scal_lm = calloc(bandlimit * bandlimit, sizeof **f_scal_lm);
    -
    68 }
    -
    69 
    -
    79 void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters)
    -
    80 {
    -
    81  int L = parameters->L;
    -
    82 
    -
    83  int J = s2let_j_max(parameters);
    -
    84  *wav_lm = (double*)calloc((J+1) * L, sizeof(double));
    -
    85  *scal_lm = (double*)calloc(L, sizeof(double));
    -
    86 }
    -
    87 
    -
    98 void s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters)
    -
    99 {
    -
    100  int L = parameters->L;
    -
    101  int J_min = parameters->J_min;
    -
    102 
    -
    103  int j, l;
    -
    104  int J = s2let_j_max(parameters);
    -
    105  //int J_min = 0;
    -
    106  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    107  double k0;
    -
    108  double *kappa, *kappa0;
    -
    109  s2let_tiling_axisym_allocate(&kappa, &kappa0, parameters);
    -
    110  s2let_tiling_axisym(kappa, kappa0, parameters);
    -
    111 
    -
    112  for (j = J_min; j <= J; j++){
    -
    113  for (l = 0; l < L; l++){
    -
    114  k0 = sqrt( (2 * l + 1) / (4.0 * PI) ) * kappa[l+j*L];
    -
    115  wav_lm[j*L+l] = k0;
    -
    116  }
    -
    117  }
    -
    118  for (l = 0; l < L; l++){
    -
    119  k0 = sqrt( (2 * l + 1) / (4.0 * PI) ) * kappa0[l];
    -
    120  scal_lm[l] = k0;
    -
    121  }
    -
    122 
    -
    123  free(kappa);
    -
    124  free(kappa0);
    -
    125 }
    -
    126 
    -
    141 void s2let_transform_axisym_lm_wav_analysis(
    -
    142  complex double *f_wav_lm,
    -
    143  complex double *f_scal_lm,
    -
    144  const complex double *flm,
    -
    145  const double *wav_lm,
    -
    146  const double *scal_lm,
    -
    147  const s2let_parameters_t *parameters
    -
    148 ) {
    -
    149  int L = parameters->L;
    -
    150  int J_min = parameters->J_min;
    -
    151 
    -
    152  int offset, j, l, m;
    -
    153  int J = s2let_j_max(parameters);
    -
    154  double wav0, scal0;
    -
    155  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    156 
    -
    157  offset = 0;
    -
    158  for (j = J_min; j <= J; j++) {
    -
    159  for (l = 0; l < L; l++) {
    -
    160  wav0 = sqrt((4.0*PI)/(2.0*l+1.0)) * wav_lm[j*L+l];
    -
    161  for (m = -l; m <= l; m++) {
    -
    162  f_wav_lm[offset + l*l + l + m] = flm[lm2ind(l,m)] * wav0 ;
    -
    163  }
    -
    164  }
    -
    165  offset += L * L;
    -
    166  }
    -
    167  for (l = 0; l < L; l++) {
    -
    168  scal0 = sqrt((4.0*PI)/(2.0*l+1.0)) * scal_lm[l];
    -
    169  for (m = -l; m <= l; m++) {
    -
    170  f_scal_lm[lm2ind(l,m)] = flm[lm2ind(l,m)] * scal0 ;
    -
    171  }
    -
    172  }
    -
    173 }
    -
    174 
    -
    189 void s2let_transform_axisym_lm_wav_synthesis(
    -
    190  complex double *flm,
    -
    191  const complex double *f_wav_lm,
    -
    192  const complex double *f_scal_lm,
    -
    193  const double *wav_lm,
    -
    194  const double *scal_lm,
    -
    195  const s2let_parameters_t *parameters
    -
    196 ) {
    -
    197  int L = parameters->L;
    -
    198  int J_min = parameters->J_min;
    -
    199 
    -
    200  int offset, j, l, m;
    -
    201  int J = s2let_j_max(parameters);
    -
    202  double wav0, scal0;
    -
    203  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    204 
    -
    205  offset = 0;
    -
    206  for (j = J_min; j <= J; j++) {
    -
    207  for (l = 0; l < L; l++) {
    -
    208  wav0 = sqrt((4.0*PI)/(2.0*l+1.0)) * wav_lm[j*L+l];
    -
    209  for (m = -l; m <= l; m++) {
    -
    210  flm[lm2ind(l,m)] += f_wav_lm[offset + l*l + l + m] * wav0 ;
    -
    211  }
    -
    212  }
    -
    213  offset += L * L;
    -
    214  }
    -
    215  for (l = 0; l < L; l++) {
    -
    216  scal0 = sqrt((4.0*PI)/(2.0*l+1.0)) * scal_lm[l];
    -
    217  for (m = -l; m <= l; m++) {
    -
    218  flm[lm2ind(l,m)] += f_scal_lm[lm2ind(l,m)] * scal0 ;
    -
    219  }
    -
    220  }
    -
    221 }
    -
    222 
    -
    237 void s2let_transform_axisym_lm_wav_analysis_multires(
    -
    238  complex double *f_wav_lm,
    -
    239  complex double *f_scal_lm,
    -
    240  const complex double *flm,
    -
    241  const double *wav_lm,
    -
    242  const double *scal_lm,
    -
    243  const s2let_parameters_t *parameters
    -
    244 ) {
    -
    245  int L = parameters->L;
    -
    246  int J_min = parameters->J_min;
    -
    247 
    -
    248  int bandlimit, offset, j, l, m;
    -
    249  int J = s2let_j_max(parameters);
    -
    250  double wav0, scal0;
    -
    251 
    -
    252  offset = 0;
    -
    253  for (j = J_min; j <= J; j++){
    -
    254  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    255  for (l = 0; l < bandlimit; l++){
    -
    256  wav0 = sqrt((4.0*PI)/(2.0*l+1.0)) * wav_lm[j*L+l];
    -
    257  for (m = -l; m <= l; m++){
    -
    258  f_wav_lm[offset + l*l + l + m] = flm[lm2ind(l,m)] * wav0 ;
    -
    259  }
    -
    260  }
    -
    261  offset += bandlimit * bandlimit;
    -
    262  }
    -
    263  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    264  for (l = 0; l < bandlimit; l++){
    -
    265  scal0 = sqrt((4.0*PI)/(2.0*l+1.0)) * scal_lm[l];
    -
    266  for (m = -l; m <= l; m++){
    -
    267  f_scal_lm[lm2ind(l,m)] = flm[lm2ind(l,m)] * scal0 ;
    -
    268  }
    -
    269  }
    -
    270 }
    -
    271 
    -
    286 void s2let_transform_axisym_lm_wav_synthesis_multires(
    -
    287  complex double *flm,
    -
    288  const complex double *f_wav_lm,
    -
    289  const complex double *f_scal_lm,
    -
    290  const double *wav_lm,
    -
    291  const double *scal_lm,
    -
    292  const s2let_parameters_t *parameters
    -
    293 ) {
    -
    294  int L = parameters->L;
    -
    295  int J_min = parameters->J_min;
    -
    296 
    -
    297  int bandlimit, offset, j, l, m;
    -
    298  int J = s2let_j_max(parameters);
    -
    299  double wav0, scal0;
    -
    300  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    301 
    -
    302  offset = 0;
    -
    303  for (j = J_min; j <= J; j++){
    -
    304  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    305  for (l = 0; l < bandlimit; l++){
    -
    306  wav0 = sqrt((4.0*PI)/(2.0*l+1.0)) * wav_lm[j*L+l];
    -
    307  for (m = -l; m <= l; m++){
    -
    308  flm[lm2ind(l,m)] += f_wav_lm[offset + l*l + l + m] * wav0 ;
    -
    309  }
    -
    310  }
    -
    311  offset += bandlimit * bandlimit;
    -
    312  }
    -
    313  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    314  for (l = 0; l < bandlimit; l++){
    -
    315  scal0 = sqrt((4.0*PI)/(2.0*l+1.0)) * scal_lm[l];
    -
    316  for (m = -l; m <= l; m++){
    -
    317  flm[lm2ind(l,m)] += f_scal_lm[lm2ind(l,m)] * scal0 ;
    -
    318  }
    -
    319  }
    -
    320 }
    -
    -
    s2let_transform_axisym_lm_wav
    void s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:98
    -
    s2let_transform_axisym_lm_allocate_wav
    void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:79
    -
    s2let_tiling_axisym_allocate
    void s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:126
    -
    s2let_transform_axisym_lm_wav_synthesis_multires
    void s2let_transform_axisym_lm_wav_synthesis_multires(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:286
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_tiling_axisym
    void s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:217
    -
    s2let_transform_axisym_lm_allocate_f_wav
    void s2let_transform_axisym_lm_allocate_f_wav(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:27
    -
    s2let_transform_axisym_lm_wav_analysis
    void s2let_transform_axisym_lm_wav_analysis(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:141
    -
    s2let_transform_axisym_lm_allocate_f_wav_multires
    void s2let_transform_axisym_lm_allocate_f_wav_multires(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:50
    -
    s2let_transform_axisym_lm_wav_synthesis
    void s2let_transform_axisym_lm_wav_synthesis(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:189
    -
    s2let_transform_axisym_lm_wav_analysis_multires
    void s2let_transform_axisym_lm_wav_analysis_multires(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:237
    -
    PI
    #define PI
    Definition: s2let_math.h:9
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__transform__axisym__lm_8h.html b/docs/c/s2let__transform__axisym__lm_8h.html index 977e767d..6c18897d 100644 --- a/docs/c/s2let__transform__axisym__lm_8h.html +++ b/docs/c/s2let__transform__axisym__lm_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_transform_axisym_lm.h File Reference +s2let: include/s2let_transform_axisym_lm.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_transform_axisym_lm.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -214,8 +264,6 @@

    Definition at line 79 of file s2let_transform_axisym_lm.c.

    - @@ -267,8 +315,6 @@

    Definition at line 98 of file s2let_transform_axisym_lm.c.

    - @@ -482,7 +528,7 @@

    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__lm_8h__dep__incl.map b/docs/c/s2let__transform__axisym__lm_8h__dep__incl.map new file mode 100644 index 00000000..c4f93f18 --- /dev/null +++ b/docs/c/s2let__transform__axisym__lm_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__lm_8h__dep__incl.md5 b/docs/c/s2let__transform__axisym__lm_8h__dep__incl.md5 new file mode 100644 index 00000000..5a603524 --- /dev/null +++ b/docs/c/s2let__transform__axisym__lm_8h__dep__incl.md5 @@ -0,0 +1 @@ +1c28cfeff722d0aacc65ec332e826f5a \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__lm_8h__incl.map b/docs/c/s2let__transform__axisym__lm_8h__incl.map new file mode 100644 index 00000000..13c06c01 --- /dev/null +++ b/docs/c/s2let__transform__axisym__lm_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__transform__axisym__lm_8h__incl.md5 b/docs/c/s2let__transform__axisym__lm_8h__incl.md5 new file mode 100644 index 00000000..74c2a3ae --- /dev/null +++ b/docs/c/s2let__transform__axisym__lm_8h__incl.md5 @@ -0,0 +1 @@ +a6452a607f40a511e59d5548c7d969ce \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__lm_8h_source.html b/docs/c/s2let__transform__axisym__lm_8h_source.html index 9a738d06..fdd06487 100644 --- a/docs/c/s2let__transform__axisym__lm_8h_source.html +++ b/docs/c/s2let__transform__axisym__lm_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_transform_axisym_lm.h Source File +s2let: include/s2let_transform_axisym_lm.h Source File @@ -22,10 +22,10 @@

    @@ -134,18 +134,18 @@
    60 #endif
    s2let_transform_axisym_lm_allocate_f_wav_multires
    void s2let_transform_axisym_lm_allocate_f_wav_multires(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters)
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    s2let_transform_axisym_lm_allocate_f_wav
    void s2let_transform_axisym_lm_allocate_f_wav(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters)
    -
    s2let_transform_axisym_lm_wav
    void s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:98
    +
    s2let_transform_axisym_lm_wav
    void s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:91
    s2let_transform_axisym_lm_wav_analysis
    void s2let_transform_axisym_lm_wav_analysis(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    -
    s2let_transform_axisym_lm_allocate_wav
    void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:79
    +
    s2let_transform_axisym_lm_allocate_wav
    void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:72
    s2let_transform_axisym_lm_wav_synthesis
    void s2let_transform_axisym_lm_wav_synthesis(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    s2let_transform_axisym_lm_wav_synthesis_multires
    void s2let_transform_axisym_lm_wav_synthesis_multires(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    s2let_transform_axisym_lm_wav_analysis_multires
    void s2let_transform_axisym_lm_wav_analysis_multires(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__mw_8c.html b/docs/c/s2let__transform__axisym__mw_8c.html index 3f688817..1e9b2694 100644 --- a/docs/c/s2let__transform__axisym__mw_8c.html +++ b/docs/c/s2let__transform__axisym__mw_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_transform_axisym_mw.c File Reference +s2let: src/main/c/s2let_transform_axisym_mw.c File Reference @@ -22,10 +22,10 @@ @@ -74,14 +74,48 @@
    s2let_transform_axisym_mw.c File Reference
    -
    #include "s2let.h"
    +
    #include <complex.h>
    #include <math.h>
    -#include <complex.h>
    #include <ssht/ssht.h>
    #include <stdlib.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_transform_axisym_mw.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    @@ -179,8 +213,6 @@

    Definition at line 21 of file s2let_transform_axisym_mw.c.

    - @@ -232,8 +264,6 @@

    Definition at line 44 of file s2let_transform_axisym_mw.c.

    - @@ -285,8 +315,6 @@

    Definition at line 94 of file s2let_transform_axisym_mw.c.

    - @@ -338,8 +366,6 @@

    Definition at line 74 of file s2let_transform_axisym_mw.c.

    - @@ -398,8 +424,6 @@

    Definition at line 189 of file s2let_transform_axisym_mw.c.

    - @@ -458,8 +482,6 @@

    Definition at line 455 of file s2let_transform_axisym_mw.c.

    - @@ -518,8 +540,6 @@

    Definition at line 984 of file s2let_transform_axisym_mw.c.

    - @@ -578,8 +598,6 @@

    Definition at line 724 of file s2let_transform_axisym_mw.c.

    - @@ -638,8 +656,6 @@

    Definition at line 124 of file s2let_transform_axisym_mw.c.

    - @@ -698,8 +714,6 @@

    Definition at line 389 of file s2let_transform_axisym_mw.c.

    - @@ -758,8 +772,6 @@

    Definition at line 918 of file s2let_transform_axisym_mw.c.

    - @@ -818,8 +830,6 @@

    Definition at line 660 of file s2let_transform_axisym_mw.c.

    - @@ -871,8 +881,6 @@

    Definition at line 1214 of file s2let_transform_axisym_mw.c.

    - @@ -924,8 +932,6 @@

    Definition at line 1184 of file s2let_transform_axisym_mw.c.

    - @@ -984,8 +990,6 @@

    Definition at line 323 of file s2let_transform_axisym_mw.c.

    - @@ -1044,8 +1048,6 @@

    Definition at line 593 of file s2let_transform_axisym_mw.c.

    - @@ -1104,8 +1106,6 @@

    Definition at line 1122 of file s2let_transform_axisym_mw.c.

    - @@ -1164,8 +1164,6 @@

    Definition at line 854 of file s2let_transform_axisym_mw.c.

    - @@ -1224,8 +1222,6 @@

    Definition at line 255 of file s2let_transform_axisym_mw.c.

    - @@ -1284,8 +1280,6 @@

    Definition at line 524 of file s2let_transform_axisym_mw.c.

    - @@ -1344,8 +1338,6 @@

    Definition at line 1053 of file s2let_transform_axisym_mw.c.

    - @@ -1404,14 +1396,12 @@

    Definition at line 789 of file s2let_transform_axisym_mw.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__mw_8c__incl.map b/docs/c/s2let__transform__axisym__mw_8c__incl.map new file mode 100644 index 00000000..6ac6a397 --- /dev/null +++ b/docs/c/s2let__transform__axisym__mw_8c__incl.map @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__mw_8c__incl.md5 b/docs/c/s2let__transform__axisym__mw_8c__incl.md5 new file mode 100644 index 00000000..5fea1ffb --- /dev/null +++ b/docs/c/s2let__transform__axisym__mw_8c__incl.md5 @@ -0,0 +1 @@ +efa660c767019736dd2eb54dde8401e2 \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__mw_8c_source.html b/docs/c/s2let__transform__axisym__mw_8c_source.html deleted file mode 100644 index 5ab44835..00000000 --- a/docs/c/s2let__transform__axisym__mw_8c_source.html +++ /dev/null @@ -1,1077 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_transform_axisym_mw.c Source File - - - - - - - - - -
    -
    -

    Functions

    void s2let_transform_axisym_allocate_mw_f_wav (complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters)
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_transform_axisym_mw.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <math.h>
    -
    7 #include <complex.h>
    -
    8 #include <ssht/ssht.h>
    -
    9 #include <stdlib.h>
    -
    10 
    -
    21 void s2let_transform_axisym_allocate_mw_f_wav(
    -
    22  complex double **f_wav,
    -
    23  complex double **f_scal,
    -
    24  const s2let_parameters_t *parameters
    -
    25 ) {
    -
    26  int L = parameters->L;
    -
    27  int J_min = parameters->J_min;
    -
    28 
    -
    29  int J = s2let_j_max(parameters);
    -
    30  *f_wav = calloc((J+1-J_min) * L *(2*L-1), sizeof **f_wav);
    -
    31  *f_scal = calloc(L * (2*L-1), sizeof **f_scal);
    -
    32 }
    -
    33 
    -
    44 void s2let_transform_axisym_allocate_mw_f_wav_multires(
    -
    45  complex double **f_wav,
    -
    46  complex double **f_scal,
    -
    47  const s2let_parameters_t *parameters
    -
    48 ) {
    -
    49  int L = parameters->L;
    -
    50  int J_min = parameters->J_min;
    -
    51 
    -
    52  int J = s2let_j_max(parameters);
    -
    53  int j, bandlimit, total = 0;
    -
    54  for (j = J_min; j <= J; ++j)
    -
    55  {
    -
    56  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    57  total += bandlimit * (2 * bandlimit - 1);
    -
    58  }
    -
    59  *f_wav = calloc(total, sizeof **f_wav);
    -
    60  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    61  *f_scal = calloc(bandlimit * (2*bandlimit-1), sizeof **f_scal);
    -
    62 }
    -
    63 
    -
    74 void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    -
    75 {
    -
    76  int L = parameters->L;
    -
    77  int J_min = parameters->J_min;
    -
    78 
    -
    79  int J = s2let_j_max(parameters);
    -
    80  *f_wav = calloc((J+1-J_min) * L *(2*L-1), sizeof **f_wav);
    -
    81  *f_scal = calloc(L * (2*L-1), sizeof **f_scal);
    -
    82 }
    -
    83 
    -
    94 void s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    -
    95 {
    -
    96  int L = parameters->L;
    -
    97  int J_min = parameters->J_min;
    -
    98 
    -
    99  int J = s2let_j_max(parameters);
    -
    100  int j, bandlimit, total = 0;
    -
    101  for (j = J_min; j <= J; ++j)
    -
    102  {
    -
    103  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    104  total += bandlimit * (2 * bandlimit - 1);
    -
    105  }
    -
    106  *f_wav = calloc(total, sizeof **f_wav);
    -
    107  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    108  *f_scal = calloc(bandlimit * (2*bandlimit-1), sizeof **f_scal);
    -
    109 }
    -
    110 
    -
    124 void s2let_transform_axisym_wav_analysis_mw(
    -
    125  complex double *f_wav,
    -
    126  complex double *f_scal,
    -
    127  const complex double *f,
    -
    128  const s2let_parameters_t *parameters
    -
    129 ) {
    -
    130  int L = parameters->L;
    -
    131  int J_min = parameters->J_min;
    -
    132 
    -
    133  int spin = 0;
    -
    134  int verbosity = 0;
    -
    135  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    136 
    -
    137  int j, offset, offset_lm;
    -
    138  int J = s2let_j_max(parameters);
    -
    139  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    140 
    -
    141  double *wav_lm, *scal_lm;
    -
    142  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    143  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    144 
    -
    145  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    146  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    147  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters);
    -
    148 
    -
    149  ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity);
    -
    150 
    -
    151  s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters);
    -
    152 
    -
    153  ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, L, spin, dl_method, verbosity);
    -
    154  offset = 0;
    -
    155  offset_lm = 0;
    -
    156  for (j = J_min; j <= J; ++j)
    -
    157  {
    -
    158  int i;
    -
    159 
    -
    160  ssht_core_mw_inverse_sov_sym(f_wav + offset, f_wav_lm + offset_lm, L, spin, dl_method, verbosity);
    -
    161 
    -
    162  for (i = 0; i < L*(2*L-1); ++i)
    -
    163  {
    -
    164  f_wav[offset+i] /= sqrt(2*PI);
    -
    165  }
    -
    166 
    -
    167  offset_lm += L * L;
    -
    168  offset += L * (2 * L - 1);
    -
    169  }
    -
    170 
    -
    171  free(flm);
    -
    172  free(f_scal_lm);
    -
    173  free(f_wav_lm);
    -
    174 }
    -
    175 
    -
    189 void s2let_transform_axisym_wav_analysis_adjoint_mw(
    -
    190  complex double *f,
    -
    191  const complex double *f_wav,
    -
    192  const complex double *f_scal,
    -
    193  const s2let_parameters_t *parameters
    -
    194 ) {
    -
    195  int L = parameters->L;
    -
    196  int J_min = parameters->J_min;
    -
    197 
    -
    198  int spin = 0;
    -
    199  int verbosity = 0;
    -
    200  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    201 
    -
    202  int j, offset, offset_lm;
    -
    203  int J = s2let_j_max(parameters);
    -
    204  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    205 
    -
    206  double *wav_lm, *scal_lm;
    -
    207  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    208  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    209 
    -
    210  complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm;
    -
    211  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    212  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters);
    -
    213 
    -
    214  ssht_adjoint_mw_inverse_sov_sym(f_scal_lm, f_scal, L, spin, dl_method, verbosity);
    -
    215  offset = 0;
    -
    216  offset_lm = 0;
    -
    217 
    -
    218  f_wav_norm = malloc(L*(2*L-1) * sizeof *f_wav_norm);
    -
    219  for(j = J_min; j <= J; j++){
    -
    220  int i;
    -
    221 
    -
    222  for (i = 0; i < L*(2*L-1); ++i)
    -
    223  {
    -
    224  f_wav_norm[i] = f_wav[offset+i] / sqrt(2*PI);
    -
    225  }
    -
    226 
    -
    227  ssht_adjoint_mw_inverse_sov_sym(f_wav_lm + offset_lm, f_wav_norm, L, spin, dl_method, verbosity);
    -
    228  offset_lm += L * L;
    -
    229  offset += L * (2 * L - 1);
    -
    230  }
    -
    231  free(f_wav_norm);
    -
    232 
    -
    233  s2let_transform_axisym_lm_wav_synthesis(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters);
    -
    234 
    -
    235  ssht_adjoint_mw_forward_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    236 
    -
    237  free(flm);
    -
    238  free(f_scal_lm);
    -
    239  free(f_wav_lm);
    -
    240 }
    -
    241 
    -
    255 void s2let_transform_axisym_wav_synthesis_mw(
    -
    256  complex double *f,
    -
    257  const complex double *f_wav,
    -
    258  const complex double *f_scal,
    -
    259  const s2let_parameters_t *parameters
    -
    260 ) {
    -
    261  int L = parameters->L;
    -
    262  int J_min = parameters->J_min;
    -
    263 
    -
    264  int spin = 0;
    -
    265  int verbosity = 0;
    -
    266  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    267 
    -
    268  int j, offset, offset_lm;
    -
    269  int J = s2let_j_max(parameters);
    -
    270  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    271 
    -
    272  double *wav_lm, *scal_lm;
    -
    273  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    274  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    275 
    -
    276  complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm;
    -
    277  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    278  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters);
    -
    279 
    -
    280  ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, L, spin, dl_method, verbosity);
    -
    281  offset = 0;
    -
    282  offset_lm = 0;
    -
    283 
    -
    284  f_wav_norm = malloc(L*(2*L-1) * sizeof *f_wav_norm);
    -
    285  for(j = J_min; j <= J; j++){
    -
    286  int i;
    -
    287 
    -
    288  for (i = 0; i < L*(2*L-1); ++i)
    -
    289  {
    -
    290  f_wav_norm[i] = f_wav[offset+i] * sqrt(2*PI);
    -
    291  }
    -
    292 
    -
    293  ssht_core_mw_forward_sov_conv_sym(f_wav_lm + offset_lm, f_wav_norm, L, spin, dl_method, verbosity);
    -
    294  offset_lm += L * L;
    -
    295  offset += L * (2 * L - 1);
    -
    296  }
    -
    297  free(f_wav_norm);
    -
    298 
    -
    299  s2let_transform_axisym_lm_wav_synthesis(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters);
    -
    300 
    -
    301  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    302 
    -
    303  free(flm);
    -
    304  free(f_scal_lm);
    -
    305  free(f_wav_lm);
    -
    306 }
    -
    307 
    -
    308 
    -
    309 
    -
    323 void s2let_transform_axisym_wav_synthesis_adjoint_mw(
    -
    324  complex double *f_wav,
    -
    325  complex double *f_scal,
    -
    326  const complex double *f,
    -
    327  const s2let_parameters_t *parameters
    -
    328 ) {
    -
    329  int L = parameters->L;
    -
    330  int J_min = parameters->J_min;
    -
    331 
    -
    332  int spin = 0;
    -
    333  int verbosity = 0;
    -
    334  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    335 
    -
    336  int j, offset, offset_lm;
    -
    337  int J = s2let_j_max(parameters);
    -
    338  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    339 
    -
    340  double *wav_lm, *scal_lm;
    -
    341  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    342  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    343 
    -
    344  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    345  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    346  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters);
    -
    347 
    -
    348  ssht_adjoint_mw_inverse_sov_sym(flm, f, L, spin, dl_method, verbosity);
    -
    349 
    -
    350  s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters);
    -
    351 
    -
    352  ssht_adjoint_mw_forward_sov_sym(f_scal, f_scal_lm, L, spin, dl_method, verbosity);
    -
    353  offset = 0;
    -
    354  offset_lm = 0;
    -
    355  for (j = J_min; j <= J; ++j)
    -
    356  {
    -
    357  int i;
    -
    358 
    -
    359  ssht_adjoint_mw_forward_sov_sym(f_wav + offset, f_wav_lm + offset_lm, L, spin, dl_method, verbosity);
    -
    360 
    -
    361  for (i = 0; i < L*(2*L-1); ++i)
    -
    362  {
    -
    363  f_wav[offset+i] *= sqrt(2*PI);
    -
    364  }
    -
    365 
    -
    366  offset_lm += L * L;
    -
    367  offset += L * (2 * L - 1);
    -
    368  }
    -
    369 
    -
    370  free(flm);
    -
    371  free(f_scal_lm);
    -
    372  free(f_wav_lm);
    -
    373 }
    -
    374 
    -
    375 
    -
    389 void s2let_transform_axisym_wav_analysis_mw_multires(
    -
    390  complex double *f_wav,
    -
    391  complex double *f_scal,
    -
    392  const complex double *f,
    -
    393  const s2let_parameters_t *parameters
    -
    394 ) {
    -
    395  int L = parameters->L;
    -
    396  int J_min = parameters->J_min;
    -
    397 
    -
    398  int spin = 0;
    -
    399  int verbosity = 0;
    -
    400  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    401 
    -
    402  int bandlimit, j, offset, offset_lm;
    -
    403  int J = s2let_j_max(parameters);
    -
    404  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    405 
    -
    406  double *wav_lm, *scal_lm;
    -
    407  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    408  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    409 
    -
    410  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    411  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    412  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    413 
    -
    414  ssht_core_mw_forward_sov_conv_sym(flm, f, L, spin, dl_method, verbosity);
    -
    415 
    -
    416  s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters);
    -
    417 
    -
    418  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    419  ssht_core_mw_inverse_sov_sym(f_scal, f_scal_lm, bandlimit, spin, dl_method, verbosity);
    -
    420  offset = 0;
    -
    421  offset_lm = 0;
    -
    422  for(j = J_min; j <= J; j++){
    -
    423  int i;
    -
    424 
    -
    425  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    426  ssht_core_mw_inverse_sov_sym(f_wav + offset, f_wav_lm + offset_lm, bandlimit, spin, dl_method, verbosity);
    -
    427 
    -
    428  for (i = 0; i < bandlimit*(2*bandlimit-1); ++i)
    -
    429  {
    -
    430  f_wav[offset+i] /= sqrt(2*PI);
    -
    431  }
    -
    432 
    -
    433  offset_lm += bandlimit * bandlimit;
    -
    434  offset += bandlimit * (2 * bandlimit - 1);
    -
    435  }
    -
    436 
    -
    437  free(flm);
    -
    438  free(f_scal_lm);
    -
    439  free(f_wav_lm);
    -
    440 }
    -
    441 
    -
    455 void s2let_transform_axisym_wav_analysis_adjoint_mw_multires(
    -
    456  complex double *f,
    -
    457  const complex double *f_wav,
    -
    458  const complex double *f_scal,
    -
    459  const s2let_parameters_t *parameters
    -
    460 ) {
    -
    461  int L = parameters->L;
    -
    462  int J_min = parameters->J_min;
    -
    463 
    -
    464  int spin = 0;
    -
    465  int verbosity = 0;
    -
    466  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    467 
    -
    468  int bandlimit, j, offset, offset_lm;
    -
    469  int J = s2let_j_max(parameters);
    -
    470  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    471 
    -
    472  double *wav_lm, *scal_lm;
    -
    473  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    474  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    475 
    -
    476  complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm;
    -
    477  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    478  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    479 
    -
    480  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    481  ssht_adjoint_mw_inverse_sov_sym(f_scal_lm, f_scal, bandlimit, spin, dl_method, verbosity);
    -
    482  offset = 0;
    -
    483  offset_lm = 0;
    -
    484  for(j = J_min; j <= J; j++){
    -
    485  int i;
    -
    486  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    487 
    -
    488  f_wav_norm = malloc(bandlimit*(2*bandlimit-1) * sizeof *f_wav_norm);
    -
    489 
    -
    490  for (i = 0; i < bandlimit*(2*bandlimit-1); ++i)
    -
    491  {
    -
    492  f_wav_norm[i] = f_wav[offset+i] / sqrt(2*PI);
    -
    493  }
    -
    494 
    -
    495  ssht_adjoint_mw_inverse_sov_sym(f_wav_lm + offset_lm, f_wav_norm, bandlimit, spin, dl_method, verbosity);
    -
    496  offset_lm += bandlimit * bandlimit;
    -
    497  offset += bandlimit * (2 * bandlimit - 1);
    -
    498 
    -
    499  free(f_wav_norm);
    -
    500  }
    -
    501 
    -
    502  s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters);
    -
    503 
    -
    504  ssht_adjoint_mw_forward_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    505 
    -
    506  free(flm);
    -
    507  free(f_scal_lm);
    -
    508  free(f_wav_lm);
    -
    509 }
    -
    510 
    -
    524 void s2let_transform_axisym_wav_synthesis_mw_multires(
    -
    525  complex double *f,
    -
    526  const complex double *f_wav,
    -
    527  const complex double *f_scal,
    -
    528  const s2let_parameters_t *parameters
    -
    529 ) {
    -
    530  int L = parameters->L;
    -
    531  int J_min = parameters->J_min;
    -
    532 
    -
    533  int spin = 0;
    -
    534  int verbosity = 0;
    -
    535  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    536 
    -
    537  int bandlimit, j, offset, offset_lm;
    -
    538  int J = s2let_j_max(parameters);
    -
    539  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    540 
    -
    541  double *wav_lm, *scal_lm;
    -
    542  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    543  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    544 
    -
    545  complex double *flm, *f_wav_norm, *f_wav_lm, *f_scal_lm;
    -
    546  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    547  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    548 
    -
    549  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    550  ssht_core_mw_forward_sov_conv_sym(f_scal_lm, f_scal, bandlimit, spin, dl_method, verbosity);
    -
    551  offset = 0;
    -
    552  offset_lm = 0;
    -
    553  for(j = J_min; j <= J; j++){
    -
    554  int i;
    -
    555  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    556 
    -
    557  f_wav_norm = malloc(bandlimit*(2*bandlimit-1) * sizeof *f_wav_norm);
    -
    558 
    -
    559  for (i = 0; i < bandlimit*(2*bandlimit-1); ++i)
    -
    560  {
    -
    561  f_wav_norm[i] = f_wav[offset+i] * sqrt(2*PI);
    -
    562  }
    -
    563 
    -
    564  ssht_core_mw_forward_sov_conv_sym(f_wav_lm + offset_lm, f_wav_norm, bandlimit, spin, dl_method, verbosity);
    -
    565  offset_lm += bandlimit * bandlimit;
    -
    566  offset += bandlimit * (2 * bandlimit - 1);
    -
    567 
    -
    568  free(f_wav_norm);
    -
    569  }
    -
    570 
    -
    571  s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters);
    -
    572 
    -
    573  ssht_core_mw_inverse_sov_sym(f, flm, L, spin, dl_method, verbosity);
    -
    574 
    -
    575  free(flm);
    -
    576  free(f_scal_lm);
    -
    577  free(f_wav_lm);
    -
    578 }
    -
    579 
    -
    593 void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(
    -
    594  complex double *f_wav,
    -
    595  complex double *f_scal,
    -
    596  const complex double *f,
    -
    597  const s2let_parameters_t *parameters
    -
    598 ) {
    -
    599  int L = parameters->L;
    -
    600  int J_min = parameters->J_min;
    -
    601 
    -
    602  int spin = 0;
    -
    603  int verbosity = 0;
    -
    604  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    605 
    -
    606  int bandlimit, j, offset, offset_lm;
    -
    607  int J = s2let_j_max(parameters);
    -
    608  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    609 
    -
    610  double *wav_lm, *scal_lm;
    -
    611  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    612  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    613 
    -
    614  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    615  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    616  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    617 
    -
    618  ssht_adjoint_mw_inverse_sov_sym(flm, f, L, spin, dl_method, verbosity);
    -
    619 
    -
    620  s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters);
    -
    621 
    -
    622  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    623  ssht_adjoint_mw_forward_sov_sym(f_scal, f_scal_lm, bandlimit, spin, dl_method, verbosity);
    -
    624  offset = 0;
    -
    625  offset_lm = 0;
    -
    626  for(j = J_min; j <= J; j++){
    -
    627  int i;
    -
    628 
    -
    629  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    630  ssht_adjoint_mw_forward_sov_sym(f_wav + offset, f_wav_lm + offset_lm, bandlimit, spin, dl_method, verbosity);
    -
    631 
    -
    632  for (i = 0; i < bandlimit*(2*bandlimit-1); ++i)
    -
    633  {
    -
    634  f_wav[offset+i] *= sqrt(2*PI);
    -
    635  }
    -
    636 
    -
    637  offset_lm += bandlimit * bandlimit;
    -
    638  offset += bandlimit * (2 * bandlimit - 1);
    -
    639  }
    -
    640 
    -
    641  free(flm);
    -
    642  free(f_scal_lm);
    -
    643  free(f_wav_lm);
    -
    644 }
    -
    645 
    -
    660 void s2let_transform_axisym_wav_analysis_mw_real(
    -
    661  double *f_wav,
    -
    662  double *f_scal,
    -
    663  const double *f,
    -
    664  const s2let_parameters_t *parameters
    -
    665 ) {
    -
    666  int L = parameters->L;
    -
    667  int J_min = parameters->J_min;
    -
    668 
    -
    669  int verbosity = 0;
    -
    670  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    671 
    -
    672  int j, offset, offset_lm;
    -
    673  int J = s2let_j_max(parameters);
    -
    674  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    675 
    -
    676  double *wav_lm, *scal_lm;
    -
    677  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    678  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    679 
    -
    680  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    681  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    682  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters);
    -
    683 
    -
    684  ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity);
    -
    685 
    -
    686  s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters);
    -
    687 
    -
    688  ssht_core_mw_inverse_sov_sym_real(f_scal, f_scal_lm, L, dl_method, verbosity);
    -
    689  offset = 0;
    -
    690  offset_lm = 0;
    -
    691  for(j = J_min; j <= J; j++){
    -
    692  int i;
    -
    693 
    -
    694  ssht_core_mw_inverse_sov_sym_real(f_wav + offset, f_wav_lm + offset_lm, L, dl_method, verbosity);
    -
    695 
    -
    696  for (i = 0; i < L*(2*L-1); ++i)
    -
    697  {
    -
    698  f_wav[offset+i] /= sqrt(2*PI);
    -
    699  }
    -
    700 
    -
    701  offset_lm += L * L;
    -
    702  offset += L * (2 * L - 1);
    -
    703  }
    -
    704 
    -
    705  free(flm);
    -
    706  free(f_scal_lm);
    -
    707  free(f_wav_lm);
    -
    708 }
    -
    709 
    -
    724 void s2let_transform_axisym_wav_analysis_adjoint_mw_real(
    -
    725  double *f,
    -
    726  const double *f_wav,
    -
    727  const double *f_scal,
    -
    728  const s2let_parameters_t *parameters
    -
    729 ) {
    -
    730  int L = parameters->L;
    -
    731  int J_min = parameters->J_min;
    -
    732 
    -
    733  int verbosity = 0;
    -
    734  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    735 
    -
    736  int j, offset, offset_lm;
    -
    737  int J = s2let_j_max(parameters);
    -
    738  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    739 
    -
    740  double *f_wav_norm, *wav_lm, *scal_lm;
    -
    741  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    742  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    743 
    -
    744  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    745  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    746  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters);
    -
    747 
    -
    748  ssht_adjoint_mw_inverse_sov_sym_real(f_scal_lm, f_scal, L, dl_method, verbosity);
    -
    749  offset = 0;
    -
    750  offset_lm = 0;
    -
    751  f_wav_norm = malloc(L*(2*L-1) * sizeof *f_wav_norm);
    -
    752  for(j = J_min; j <= J; j++){
    -
    753  int i;
    -
    754 
    -
    755  for (i = 0; i < L*(2*L-1); ++i)
    -
    756  {
    -
    757  f_wav_norm[i] = f_wav[offset+i] / sqrt(2*PI);
    -
    758  }
    -
    759 
    -
    760  ssht_adjoint_mw_inverse_sov_sym_real(f_wav_lm + offset_lm, f_wav_norm, L, dl_method, verbosity);
    -
    761  offset_lm += L * L;
    -
    762  offset += L * (2 * L - 1);
    -
    763  }
    -
    764  free(f_wav_norm);
    -
    765 
    -
    766  s2let_transform_axisym_lm_wav_synthesis(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters);
    -
    767 
    -
    768  ssht_adjoint_mw_forward_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    769 
    -
    770  free(flm);
    -
    771  free(f_scal_lm);
    -
    772  free(f_wav_lm);
    -
    773 }
    -
    774 
    -
    789 void s2let_transform_axisym_wav_synthesis_mw_real(
    -
    790  double *f,
    -
    791  const double *f_wav,
    -
    792  const double *f_scal,
    -
    793  const s2let_parameters_t *parameters
    -
    794 ) {
    -
    795  int L = parameters->L;
    -
    796  int J_min = parameters->J_min;
    -
    797 
    -
    798  int verbosity = 0;
    -
    799  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    800 
    -
    801  int j, offset, offset_lm;
    -
    802  int J = s2let_j_max(parameters);
    -
    803  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    804 
    -
    805  double *f_wav_norm, *wav_lm, *scal_lm;
    -
    806  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    807  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    808 
    -
    809  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    810  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    811  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters);
    -
    812 
    -
    813  ssht_core_mw_forward_sov_conv_sym_real(f_scal_lm, f_scal, L, dl_method, verbosity);
    -
    814  offset = 0;
    -
    815  offset_lm = 0;
    -
    816  f_wav_norm = malloc(L*(2*L-1) * sizeof *f_wav_norm);
    -
    817  for(j = J_min; j <= J; j++){
    -
    818  int i;
    -
    819 
    -
    820  for (i = 0; i < L*(2*L-1); ++i)
    -
    821  {
    -
    822  f_wav_norm[i] = f_wav[offset+i] * sqrt(2*PI);
    -
    823  }
    -
    824 
    -
    825  ssht_core_mw_forward_sov_conv_sym_real(f_wav_lm + offset_lm, f_wav_norm, L, dl_method, verbosity);
    -
    826  offset_lm += L * L;
    -
    827  offset += L * (2 * L - 1);
    -
    828  }
    -
    829  free(f_wav_norm);
    -
    830 
    -
    831  s2let_transform_axisym_lm_wav_synthesis(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters);
    -
    832 
    -
    833  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    834 
    -
    835  free(flm);
    -
    836  free(f_scal_lm);
    -
    837  free(f_wav_lm);
    -
    838 }
    -
    839 
    -
    854 void s2let_transform_axisym_wav_synthesis_adjoint_mw_real(
    -
    855  double *f_wav,
    -
    856  double *f_scal,
    -
    857  const double *f,
    -
    858  const s2let_parameters_t *parameters
    -
    859 ) {
    -
    860  int L = parameters->L;
    -
    861  int J_min = parameters->J_min;
    -
    862 
    -
    863  int verbosity = 0;
    -
    864  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    865 
    -
    866  int j, offset, offset_lm;
    -
    867  int J = s2let_j_max(parameters);
    -
    868  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    869 
    -
    870  double *wav_lm, *scal_lm;
    -
    871  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    872  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    873 
    -
    874  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    875  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    876  s2let_transform_axisym_lm_allocate_f_wav(&f_wav_lm, &f_scal_lm, parameters);
    -
    877 
    -
    878  ssht_adjoint_mw_inverse_sov_sym_real(flm, f, L, dl_method, verbosity);
    -
    879 
    -
    880  s2let_transform_axisym_lm_wav_analysis(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters);
    -
    881 
    -
    882  ssht_adjoint_mw_forward_sov_sym_real(f_scal, f_scal_lm, L, dl_method, verbosity);
    -
    883  offset = 0;
    -
    884  offset_lm = 0;
    -
    885  for(j = J_min; j <= J; j++){
    -
    886  int i;
    -
    887 
    -
    888  ssht_adjoint_mw_forward_sov_sym_real(f_wav + offset, f_wav_lm + offset_lm, L, dl_method, verbosity);
    -
    889 
    -
    890  for (i = 0; i < L*(2*L-1); ++i)
    -
    891  {
    -
    892  f_wav[offset+i] *= sqrt(2*PI);
    -
    893  }
    -
    894 
    -
    895  offset_lm += L * L;
    -
    896  offset += L * (2 * L - 1);
    -
    897  }
    -
    898 
    -
    899  free(flm);
    -
    900  free(f_scal_lm);
    -
    901  free(f_wav_lm);
    -
    902 }
    -
    903 
    -
    918 void s2let_transform_axisym_wav_analysis_mw_multires_real(
    -
    919  double *f_wav,
    -
    920  double *f_scal,
    -
    921  const double *f,
    -
    922  const s2let_parameters_t *parameters
    -
    923 ) {
    -
    924  int L = parameters->L;
    -
    925  int J_min = parameters->J_min;
    -
    926 
    -
    927  int verbosity = 0;
    -
    928  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    929 
    -
    930  int bandlimit, j, offset, offset_lm;
    -
    931  int J = s2let_j_max(parameters);
    -
    932  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    933 
    -
    934  double *wav_lm, *scal_lm;
    -
    935  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    936  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    937 
    -
    938  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    939  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    940  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    941 
    -
    942  ssht_core_mw_forward_sov_conv_sym_real(flm, f, L, dl_method, verbosity);
    -
    943 
    -
    944  s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters);
    -
    945 
    -
    946  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    947  ssht_core_mw_inverse_sov_sym_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity);
    -
    948  offset = 0;
    -
    949  offset_lm = 0;
    -
    950  for(j = J_min; j <= J; j++){
    -
    951  int i;
    -
    952 
    -
    953  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    954  ssht_core_mw_inverse_sov_sym_real(f_wav + offset, f_wav_lm + offset_lm, bandlimit, dl_method, verbosity);
    -
    955 
    -
    956  for (i = 0; i < bandlimit*(2*bandlimit-1); ++i)
    -
    957  {
    -
    958  f_wav[offset+i] /= sqrt(2*PI);
    -
    959  }
    -
    960 
    -
    961  offset_lm += bandlimit * bandlimit;
    -
    962  offset += bandlimit * (2 * bandlimit - 1);
    -
    963  }
    -
    964 
    -
    965  free(flm);
    -
    966  free(f_scal_lm);
    -
    967  free(f_wav_lm);
    -
    968 }
    -
    969 
    -
    984 void s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(
    -
    985  double *f,
    -
    986  const double *f_wav,
    -
    987  const double *f_scal,
    -
    988  const s2let_parameters_t *parameters
    -
    989 ) {
    -
    990  int L = parameters->L;
    -
    991  int J_min = parameters->J_min;
    -
    992 
    -
    993  int verbosity = 0;
    -
    994  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    995 
    -
    996  int bandlimit, j, offset, offset_lm;
    -
    997  int J = s2let_j_max(parameters);
    -
    998  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    999 
    -
    1000  double *f_wav_norm, *wav_lm, *scal_lm;
    -
    1001  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    1002  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    1003 
    -
    1004  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    1005  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    1006  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    1007 
    -
    1008  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    1009  ssht_adjoint_mw_inverse_sov_sym_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity);
    -
    1010  offset = 0;
    -
    1011  offset_lm = 0;
    -
    1012  for(j = J_min; j <= J; j++){
    -
    1013  int i;
    -
    1014  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    1015 
    -
    1016  f_wav_norm = malloc(bandlimit*(2*bandlimit-1) * sizeof *f_wav_norm);
    -
    1017 
    -
    1018  for (i = 0; i < bandlimit*(2*bandlimit-1); ++i)
    -
    1019  {
    -
    1020  f_wav_norm[i] = f_wav[offset+i] / sqrt(2*PI);
    -
    1021  }
    -
    1022 
    -
    1023  ssht_adjoint_mw_inverse_sov_sym_real(f_wav_lm + offset_lm, f_wav_norm, bandlimit, dl_method, verbosity);
    -
    1024  offset_lm += bandlimit * bandlimit;
    -
    1025  offset += bandlimit * (2 * bandlimit - 1);
    -
    1026 
    -
    1027  free(f_wav_norm);
    -
    1028  }
    -
    1029 
    -
    1030  s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters);
    -
    1031 
    -
    1032  ssht_adjoint_mw_forward_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    1033 
    -
    1034  free(flm);
    -
    1035  free(f_scal_lm);
    -
    1036  free(f_wav_lm);
    -
    1037 }
    -
    1038 
    -
    1053 void s2let_transform_axisym_wav_synthesis_mw_multires_real(
    -
    1054  double *f,
    -
    1055  const double *f_wav,
    -
    1056  const double *f_scal,
    -
    1057  const s2let_parameters_t *parameters
    -
    1058 ) {
    -
    1059  int L = parameters->L;
    -
    1060  int J_min = parameters->J_min;
    -
    1061 
    -
    1062  int verbosity = 0;
    -
    1063  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    1064 
    -
    1065  int bandlimit, j, offset, offset_lm;
    -
    1066  int J = s2let_j_max(parameters);
    -
    1067  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    1068 
    -
    1069  double *f_wav_norm, *wav_lm, *scal_lm;
    -
    1070  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    1071  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    1072 
    -
    1073  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    1074  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    1075  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    1076 
    -
    1077  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    1078  ssht_core_mw_forward_sov_conv_sym_real(f_scal_lm, f_scal, bandlimit, dl_method, verbosity);
    -
    1079  offset = 0;
    -
    1080  offset_lm = 0;
    -
    1081  for(j = J_min; j <= J; j++){
    -
    1082  int i;
    -
    1083  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    1084 
    -
    1085  f_wav_norm = malloc(bandlimit*(2*bandlimit-1) * sizeof *f_wav_norm);
    -
    1086 
    -
    1087  for (i = 0; i < bandlimit*(2*bandlimit-1); ++i)
    -
    1088  {
    -
    1089  f_wav_norm[i] = f_wav[offset+i] * sqrt(2*PI);
    -
    1090  }
    -
    1091 
    -
    1092  ssht_core_mw_forward_sov_conv_sym_real(f_wav_lm + offset_lm, f_wav_norm, bandlimit, dl_method, verbosity);
    -
    1093  offset_lm += bandlimit * bandlimit;
    -
    1094  offset += bandlimit * (2 * bandlimit - 1);
    -
    1095 
    -
    1096  free(f_wav_norm);
    -
    1097  }
    -
    1098 
    -
    1099  s2let_transform_axisym_lm_wav_synthesis_multires(flm, f_wav_lm, f_scal_lm, wav_lm, scal_lm, parameters);
    -
    1100 
    -
    1101  ssht_core_mw_inverse_sov_sym_real(f, flm, L, dl_method, verbosity);
    -
    1102 
    -
    1103  free(flm);
    -
    1104  free(f_scal_lm);
    -
    1105  free(f_wav_lm);
    -
    1106 }
    -
    1107 
    -
    1122 void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(
    -
    1123  double *f_wav,
    -
    1124  double *f_scal,
    -
    1125  const double *f,
    -
    1126  const s2let_parameters_t *parameters
    -
    1127 ) {
    -
    1128  int L = parameters->L;
    -
    1129  int J_min = parameters->J_min;
    -
    1130 
    -
    1131  int verbosity = 0;
    -
    1132  ssht_dl_method_t dl_method = SSHT_DL_RISBO;
    -
    1133 
    -
    1134  int bandlimit, j, offset, offset_lm;
    -
    1135  int J = s2let_j_max(parameters);
    -
    1136  //int l_min = s2let_transform_axisym_el_min(B, J_min);
    -
    1137 
    -
    1138  double *wav_lm, *scal_lm;
    -
    1139  s2let_transform_axisym_lm_allocate_wav(&wav_lm, &scal_lm, parameters);
    -
    1140  s2let_transform_axisym_lm_wav(wav_lm, scal_lm, parameters);
    -
    1141 
    -
    1142  complex double *flm, *f_wav_lm, *f_scal_lm;
    -
    1143  flm = (complex double*)calloc(L * L, sizeof(complex double));
    -
    1144  s2let_transform_axisym_lm_allocate_f_wav_multires(&f_wav_lm, &f_scal_lm, parameters);
    -
    1145 
    -
    1146  ssht_adjoint_mw_inverse_sov_sym_real(flm, f, L, dl_method, verbosity);
    -
    1147 
    -
    1148  s2let_transform_axisym_lm_wav_analysis_multires(f_wav_lm, f_scal_lm, flm, wav_lm, scal_lm, parameters);
    -
    1149 
    -
    1150  bandlimit = MIN(s2let_bandlimit(J_min-1, parameters), L);
    -
    1151  ssht_adjoint_mw_forward_sov_sym_real(f_scal, f_scal_lm, bandlimit, dl_method, verbosity);
    -
    1152  offset = 0;
    -
    1153  offset_lm = 0;
    -
    1154  for(j = J_min; j <= J; j++){
    -
    1155  int i;
    -
    1156 
    -
    1157  bandlimit = MIN(s2let_bandlimit(j, parameters), L);
    -
    1158  ssht_adjoint_mw_forward_sov_sym_real(f_wav + offset, f_wav_lm + offset_lm, bandlimit, dl_method, verbosity);
    -
    1159 
    -
    1160  for (i = 0; i < bandlimit*(2*bandlimit-1); ++i)
    -
    1161  {
    -
    1162  f_wav[offset+i] *= sqrt(2*PI);
    -
    1163  }
    -
    1164 
    -
    1165  offset_lm += bandlimit * bandlimit;
    -
    1166  offset += bandlimit * (2 * bandlimit - 1);
    -
    1167  }
    -
    1168 
    -
    1169  free(flm);
    -
    1170  free(f_scal_lm);
    -
    1171  free(f_wav_lm);
    -
    1172 }
    -
    1173 
    -
    1184 void s2let_transform_axisym_wav_hardthreshold_real(
    -
    1185  double *g_wav,
    -
    1186  const double *threshold,
    -
    1187  const s2let_parameters_t *parameters
    -
    1188 ) {
    -
    1189  int L = parameters->L;
    -
    1190  int J_min = parameters->J_min;
    -
    1191 
    -
    1192  int J = s2let_j_max(parameters);
    -
    1193  int i, j, offset = 0;
    -
    1194  for(j = J_min; j <= J; j++){
    -
    1195  int bl = L;
    -
    1196  for(i = 0; i < bl*(2*bl-1); i++){
    -
    1197  if( abs(g_wav[offset + i]) < threshold[j-J_min] )
    -
    1198  g_wav[offset + i] = 0;
    -
    1199  }
    -
    1200  offset += bl*(2*bl-1);
    -
    1201  }
    -
    1202 }
    -
    1203 
    -
    1214 void s2let_transform_axisym_wav_hardthreshold_multires_real(
    -
    1215  double *g_wav,
    -
    1216  const double *threshold,
    -
    1217  const s2let_parameters_t *parameters
    -
    1218 ) {
    -
    1219  int L = parameters->L;
    -
    1220  int J_min = parameters->J_min;
    -
    1221 
    -
    1222  int J = s2let_j_max(parameters);
    -
    1223  int i, j, offset = 0;
    -
    1224  for(j = J_min; j <= J; j++){
    -
    1225  int bl = MIN(s2let_bandlimit(j, parameters), L);
    -
    1226  for(i = 0; i < bl*(2*bl-1); i++){
    -
    1227  if( abs(g_wav[offset + i]) < threshold[j-J_min] )
    -
    1228  g_wav[offset + i] = 0;
    -
    1229  }
    -
    1230  offset += bl*(2*bl-1);
    -
    1231  }
    -
    1232 }
    -
    1233 
    -
    1234 
    -
    -
    s2let_transform_axisym_lm_wav
    void s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:98
    -
    s2let_transform_axisym_lm_allocate_wav
    void s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:79
    -
    s2let_transform_axisym_wav_analysis_mw_real
    void s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:660
    -
    s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real
    void s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:984
    -
    s2let_transform_axisym_wav_synthesis_mw_real
    void s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:789
    -
    s2let_transform_axisym_wav_synthesis_adjoint_mw
    void s2let_transform_axisym_wav_synthesis_adjoint_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:323
    -
    s2let_transform_axisym_allocate_mw_f_wav_multires
    void s2let_transform_axisym_allocate_mw_f_wav_multires(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:44
    -
    s2let_transform_axisym_allocate_mw_f_wav
    void s2let_transform_axisym_allocate_mw_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:21
    -
    s2let_transform_axisym_wav_analysis_mw_multires_real
    void s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:918
    -
    s2let_transform_axisym_wav_synthesis_adjoint_mw_real
    void s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:854
    -
    s2let_transform_axisym_allocate_mw_f_wav_real
    void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:74
    -
    s2let_transform_axisym_lm_wav_synthesis_multires
    void s2let_transform_axisym_lm_wav_synthesis_multires(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:286
    - -
    s2let_transform_axisym_wav_hardthreshold_real
    void s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1184
    -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_transform_axisym_wav_synthesis_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1053
    -
    s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1122
    -
    s2let_transform_axisym_wav_synthesis_mw_multires
    void s2let_transform_axisym_wav_synthesis_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:524
    -
    s2let_transform_axisym_wav_analysis_mw_multires
    void s2let_transform_axisym_wav_analysis_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:389
    -
    s2let_transform_axisym_wav_analysis_mw
    void s2let_transform_axisym_wav_analysis_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:124
    -
    s2let_transform_axisym_wav_analysis_adjoint_mw_real
    void s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:724
    -
    s2let_transform_axisym_wav_synthesis_mw
    void s2let_transform_axisym_wav_synthesis_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:255
    -
    s2let_transform_axisym_lm_allocate_f_wav
    void s2let_transform_axisym_lm_allocate_f_wav(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:27
    -
    s2let_transform_axisym_lm_wav_analysis
    void s2let_transform_axisym_lm_wav_analysis(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:141
    -
    s2let_transform_axisym_lm_allocate_f_wav_multires
    void s2let_transform_axisym_lm_allocate_f_wav_multires(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:50
    -
    s2let_transform_axisym_lm_wav_synthesis
    void s2let_transform_axisym_lm_wav_synthesis(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:189
    -
    s2let_transform_axisym_wav_analysis_adjoint_mw
    void s2let_transform_axisym_wav_analysis_adjoint_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:189
    -
    s2let_transform_axisym_wav_analysis_adjoint_mw_multires
    void s2let_transform_axisym_wav_analysis_adjoint_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:455
    -
    s2let_transform_axisym_lm_wav_analysis_multires
    void s2let_transform_axisym_lm_wav_analysis_multires(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_lm.c:237
    -
    s2let_transform_axisym_wav_hardthreshold_multires_real
    void s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1214
    -
    PI
    #define PI
    Definition: s2let_math.h:9
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_transform_axisym_allocate_mw_f_wav_multires_real
    void s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:94
    -
    s2let_transform_axisym_wav_synthesis_adjoint_mw_multires
    void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:593
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__transform__axisym__mw_8h.html b/docs/c/s2let__transform__axisym__mw_8h.html index f37ee5f0..0d167628 100644 --- a/docs/c/s2let__transform__axisym__mw_8h.html +++ b/docs/c/s2let__transform__axisym__mw_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_transform_axisym_mw.h File Reference +s2let: include/s2let_transform_axisym_mw.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -75,6 +75,56 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_transform_axisym_mw.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -243,8 +293,6 @@

    Definition at line 94 of file s2let_transform_axisym_mw.c.

    - @@ -296,8 +344,6 @@

    Definition at line 74 of file s2let_transform_axisym_mw.c.

    - @@ -436,8 +482,6 @@

    Definition at line 984 of file s2let_transform_axisym_mw.c.

    - @@ -496,8 +540,6 @@

    Definition at line 724 of file s2let_transform_axisym_mw.c.

    - @@ -636,8 +678,6 @@

    Definition at line 918 of file s2let_transform_axisym_mw.c.

    - @@ -696,8 +736,6 @@

    Definition at line 660 of file s2let_transform_axisym_mw.c.

    - @@ -749,8 +787,6 @@

    Definition at line 1214 of file s2let_transform_axisym_mw.c.

    - @@ -802,8 +838,6 @@

    Definition at line 1184 of file s2let_transform_axisym_mw.c.

    - @@ -942,8 +976,6 @@

    Definition at line 1122 of file s2let_transform_axisym_mw.c.

    - @@ -1002,8 +1034,6 @@

    Definition at line 854 of file s2let_transform_axisym_mw.c.

    - @@ -1142,8 +1172,6 @@

    Definition at line 1053 of file s2let_transform_axisym_mw.c.

    - @@ -1202,14 +1230,12 @@

    Definition at line 789 of file s2let_transform_axisym_mw.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__mw_8h__dep__incl.map b/docs/c/s2let__transform__axisym__mw_8h__dep__incl.map new file mode 100644 index 00000000..fd2d401c --- /dev/null +++ b/docs/c/s2let__transform__axisym__mw_8h__dep__incl.map @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__mw_8h__dep__incl.md5 b/docs/c/s2let__transform__axisym__mw_8h__dep__incl.md5 new file mode 100644 index 00000000..a790b24b --- /dev/null +++ b/docs/c/s2let__transform__axisym__mw_8h__dep__incl.md5 @@ -0,0 +1 @@ +794f7efadb28322e2c07956ba4c18bd2 \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__mw_8h__incl.map b/docs/c/s2let__transform__axisym__mw_8h__incl.map new file mode 100644 index 00000000..b6edba6c --- /dev/null +++ b/docs/c/s2let__transform__axisym__mw_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__transform__axisym__mw_8h__incl.md5 b/docs/c/s2let__transform__axisym__mw_8h__incl.md5 new file mode 100644 index 00000000..30b8aa34 --- /dev/null +++ b/docs/c/s2let__transform__axisym__mw_8h__incl.md5 @@ -0,0 +1 @@ +23bdf9aa1d2d634d9e85f61de2e4ef97 \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__mw_8h_source.html b/docs/c/s2let__transform__axisym__mw_8h_source.html index 0f280a61..6de06b34 100644 --- a/docs/c/s2let__transform__axisym__mw_8h_source.html +++ b/docs/c/s2let__transform__axisym__mw_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_transform_axisym_mw.h Source File +s2let: include/s2let_transform_axisym_mw.h Source File @@ -22,10 +22,10 @@

    @@ -120,30 +120,30 @@
    s2let_transform_axisym_wav_analysis_mw
    void s2let_transform_axisym_wav_analysis_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters)
    s2let_transform_axisym_wav_synthesis_adjoint_mw
    void s2let_transform_axisym_wav_synthesis_adjoint_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters)
    s2let_transform_axisym_wav_analysis_adjoint_mw_multires
    void s2let_transform_axisym_wav_analysis_adjoint_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters)
    -
    s2let_transform_axisym_wav_analysis_adjoint_mw_real
    void s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:724
    -
    s2let_transform_axisym_wav_hardthreshold_real
    void s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1184
    -
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    +
    s2let_transform_axisym_wav_analysis_adjoint_mw_real
    void s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:723
    +
    s2let_transform_axisym_wav_hardthreshold_real
    void s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1183
    +
    S2LET_COMPLEX
    #define S2LET_COMPLEX(TYPE)
    Definition: s2let_types.h:15
    s2let_transform_axisym_wav_synthesis_mw
    void s2let_transform_axisym_wav_synthesis_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters)
    -
    s2let_transform_axisym_wav_analysis_mw_multires_real
    void s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:918
    -
    s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real
    void s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:984
    -
    s2let_transform_axisym_allocate_mw_f_wav_real
    void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:74
    -
    s2let_transform_axisym_wav_synthesis_adjoint_mw_real
    void s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:854
    -
    s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1122
    -
    s2let_transform_axisym_wav_synthesis_mw_real
    void s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:789
    -
    s2let_transform_axisym_allocate_mw_f_wav_multires_real
    void s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:94
    +
    s2let_transform_axisym_wav_analysis_mw_multires_real
    void s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:915
    +
    s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real
    void s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:981
    +
    s2let_transform_axisym_allocate_mw_f_wav_real
    void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:74
    +
    s2let_transform_axisym_wav_synthesis_adjoint_mw_real
    void s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:852
    +
    s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1120
    +
    s2let_transform_axisym_wav_synthesis_mw_real
    void s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:788
    +
    s2let_transform_axisym_allocate_mw_f_wav_multires_real
    void s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:95
    s2let_transform_axisym_wav_analysis_mw_multires
    void s2let_transform_axisym_wav_analysis_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters)
    s2let_transform_axisym_wav_analysis_adjoint_mw
    void s2let_transform_axisym_wav_analysis_adjoint_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters)
    -
    s2let_transform_axisym_wav_hardthreshold_multires_real
    void s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1214
    +
    s2let_transform_axisym_wav_hardthreshold_multires_real
    void s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1210
    s2let_transform_axisym_wav_synthesis_adjoint_mw_multires
    void s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters)
    s2let_transform_axisym_allocate_mw_f_wav
    void s2let_transform_axisym_allocate_mw_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters)
    s2let_transform_axisym_allocate_mw_f_wav_multires
    void s2let_transform_axisym_allocate_mw_f_wav_multires(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters)
    s2let_transform_axisym_wav_synthesis_mw_multires
    void s2let_transform_axisym_wav_synthesis_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters)
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_transform_axisym_wav_analysis_mw_real
    void s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:660
    -
    s2let_transform_axisym_wav_synthesis_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1053
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_transform_axisym_wav_analysis_mw_real
    void s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:659
    +
    s2let_transform_axisym_wav_synthesis_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1051
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c.html b/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c.html index 3fdb68d9..3fd2e94a 100644 --- a/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c.html +++ b/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_transform_axisym_synthesis_hpx_real.c File Reference +s2let: src/main/c/s2let_transform_axisym_synthesis_hpx_real.c File Reference @@ -22,10 +22,10 @@ @@ -74,17 +74,53 @@
    s2let_transform_axisym_synthesis_hpx_real.c File Reference
    -
    #include "s2let.h"
    -#include <assert.h>
    +
    #include <assert.h>
    #include <complex.h>
    +#include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    -#include <math.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_transform_axisym_synthesis_hpx_real.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    -
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    +
    @@ -123,14 +159,12 @@

    Definition at line 24 of file s2let_transform_axisym_synthesis_hpx_real.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c__incl.map b/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c__incl.map new file mode 100644 index 00000000..b64762a8 --- /dev/null +++ b/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c__incl.md5 b/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c__incl.md5 new file mode 100644 index 00000000..84f32e6f --- /dev/null +++ b/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c__incl.md5 @@ -0,0 +1 @@ +23017f3c48cb9491a63b856c5b9a235f \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c_source.html b/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c_source.html deleted file mode 100644 index 5ba723a5..00000000 --- a/docs/c/s2let__transform__axisym__synthesis__hpx__real_8c_source.html +++ /dev/null @@ -1,182 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_transform_axisym_synthesis_hpx_real.c Source File - - - - - - - - - -
    -
    -

    Functions

    int main (int argc, char *argv[])
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - - -
    -
    -
    s2let_transform_axisym_synthesis_hpx_real.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <assert.h>
    -
    7 #include <complex.h>
    -
    8 #include <stdio.h>
    -
    9 #include <stdlib.h>
    -
    10 #include <string.h>
    -
    11 #include <math.h>
    -
    12 #include <time.h>
    -
    13 
    -
    24 int main(int argc, char *argv[])
    -
    25 {
    -
    26  printf("--------------------------------------------------\n");
    -
    27  printf("S2LET library : axisymmetric wavelet transform\n");
    -
    28  printf("Real signal, HEALPIX sampling\n");
    -
    29  printf("--------------------------------------------------\n");
    -
    30 
    -
    31  char fileroot[100];
    -
    32  int L, B, J_min;
    -
    33  if (sscanf(argv[1], "%s", fileroot) != 1)
    -
    34  exit(-2);
    -
    35  if (sscanf(argv[2], "%i", &B) != 1)
    -
    36  exit(-2);
    -
    37  if (sscanf(argv[3], "%i", &J_min) != 1)
    -
    38  exit(-2);
    -
    39  if (sscanf(argv[4], "%i", &L) != 1)
    -
    40  exit(-2);
    -
    41 
    -
    42  s2let_parameters_t parameters = {};
    -
    43  parameters.B = B;
    -
    44  parameters.L = L;
    -
    45  parameters.J_min = J_min;
    -
    46 
    -
    47  printf("Parameters for wavelet transform :\n");
    -
    48  printf("- Wavelet parameter : %i\n", L);
    -
    49  int J = s2let_j_max(&parameters);
    -
    50  printf("- Wavelet parameter : %i\n", B);
    -
    51  printf("- Total number of wavelets : %i\n", J);
    -
    52  printf("- First wavelet scale to be used : %i\n", J_min);
    -
    53 
    -
    54  char params[100];
    -
    55  char file[100];
    -
    56  sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min);
    -
    57  int j, offset = 0;
    -
    58  printf("File root = %s\n",fileroot);
    -
    59 
    -
    60  // Init read procedure, read nside
    -
    61  sprintf(file, "%s%s%s%s", fileroot, "_scal_", params, ".fits");
    -
    62  printf("- Infile_scal = %s\n",file);
    -
    63  const int nside = s2let_fits_hpx_read_nside(file);
    -
    64  printf("- Detected bandlimit nside = %i\n",nside);
    -
    65  // Allocate memory for wavelets
    -
    66  double *f_wav, *f_scal;
    -
    67  s2let_transform_axisym_allocate_hpx_f_wav_real(&f_wav, &f_scal, nside, &parameters);
    -
    68  // Read the scaling function
    -
    69  s2let_hpx_read_map(f_scal, file, nside); // Now write the map to fits file
    -
    70  // Read the wavelets
    -
    71  for(j = J_min; j <= J; j++){
    -
    72  sprintf(file, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits");
    -
    73  printf("- Infile_wav[j=%i] = %s\n",j,file);
    -
    74  s2let_hpx_read_map(f_wav + offset, file, nside); // Now write the map to fits file
    -
    75  offset += 12*nside*nside; // Go to the next wavelet
    -
    76  }
    -
    77 
    -
    78  // Allocate memory for reconstruction
    -
    79  double *f = (double*)calloc(12*nside*nside, sizeof(double));
    -
    80  printf("File successfully read from file\n");
    -
    81 
    -
    82  printf("Performing wavelet reconstruction...");fflush(NULL);
    -
    83  s2let_transform_axisym_wav_synthesis_hpx_real(f, f_wav, f_scal, nside, &parameters);
    -
    84  printf("done\n");
    -
    85 
    -
    86  // Output the wavelets to FITS files
    -
    87  printf("Writing reconsturcted map to FITS files\n");
    -
    88  char outfile[100];
    -
    89  sprintf(outfile, "%s%s%s%s", fileroot, "_recon_", params, ".fits");
    -
    90  printf("- Outfile = %s\n",outfile);
    -
    91  remove(outfile); // In case the file exists
    -
    92  s2let_hpx_write_map(outfile, f, nside); // Now write the map to fits file
    -
    93 
    -
    94  printf("--------------------------------------------------\n");
    -
    95 
    -
    96  return 0;
    -
    97 }
    -
    98 
    -
    99 
    -
    -
    s2let_transform_axisym_allocate_hpx_f_wav_real
    void s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:9
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_hpx_write_map
    void s2let_hpx_write_map(char *file, const double *f, int nside)
    Definition: s2let_hpx.c:50
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_fits_hpx_read_nside
    int s2let_fits_hpx_read_nside(char *filename)
    Definition: s2let_fits.c:59
    -
    s2let_transform_axisym_wav_synthesis_hpx_real
    void s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_hpx.c:55
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_hpx_read_map
    void s2let_hpx_read_map(double *f, char *file, int nside)
    Definition: s2let_hpx.c:45
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_transform_axisym_synthesis_hpx_real.c:24
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__transform__axisym__synthesis__mw__real_8c.html b/docs/c/s2let__transform__axisym__synthesis__mw__real_8c.html index a50381f5..4e79013c 100644 --- a/docs/c/s2let__transform__axisym__synthesis__mw__real_8c.html +++ b/docs/c/s2let__transform__axisym__synthesis__mw__real_8c.html @@ -5,7 +5,7 @@ -S2LET: src/main/c/s2let_transform_axisym_synthesis_mw_real.c File Reference +s2let: src/main/c/s2let_transform_axisym_synthesis_mw_real.c File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -74,17 +74,53 @@
    s2let_transform_axisym_synthesis_mw_real.c File Reference
    -
    #include "s2let.h"
    -#include <assert.h>
    +
    #include <assert.h>
    #include <complex.h>
    +#include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    -#include <math.h>
    #include <time.h>
    +#include "s2let.h"
    +
    +Include dependency graph for s2let_transform_axisym_synthesis_mw_real.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    -

    Go to the source code of this file.

    - +
    @@ -123,14 +159,12 @@

    Definition at line 24 of file s2let_transform_axisym_synthesis_mw_real.c.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__transform__axisym__synthesis__mw__real_8c__incl.map b/docs/c/s2let__transform__axisym__synthesis__mw__real_8c__incl.map new file mode 100644 index 00000000..0a55e8a7 --- /dev/null +++ b/docs/c/s2let__transform__axisym__synthesis__mw__real_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__transform__axisym__synthesis__mw__real_8c__incl.md5 b/docs/c/s2let__transform__axisym__synthesis__mw__real_8c__incl.md5 new file mode 100644 index 00000000..3899b1c5 --- /dev/null +++ b/docs/c/s2let__transform__axisym__synthesis__mw__real_8c__incl.md5 @@ -0,0 +1 @@ +c363915b5899747e979c13aaa45429b0 \ No newline at end of file diff --git a/docs/c/s2let__transform__axisym__synthesis__mw__real_8c_source.html b/docs/c/s2let__transform__axisym__synthesis__mw__real_8c_source.html deleted file mode 100644 index 96edba33..00000000 --- a/docs/c/s2let__transform__axisym__synthesis__mw__real_8c_source.html +++ /dev/null @@ -1,237 +0,0 @@ - - - - - - - -S2LET: src/main/c/s2let_transform_axisym_synthesis_mw_real.c Source File - - - - - - - - - -
    -
    -

    Functions

    int main (int argc, char *argv[])
    - - - - - - -
    -
    S2LET -  1.2.0 -
    -
    Exact wavelets on the sphere
    -
    -
    - - - - - - - - -
    -
    - - -
    - -
    - - -
    -
    -
    -
    s2let_transform_axisym_synthesis_mw_real.c
    -
    -
    -Go to the documentation of this file.
    1 // S2LET package
    -
    2 // Copyright (C) 2012
    -
    3 // Boris Leistedt & Jason McEwen
    -
    4 
    -
    5 #include "s2let.h"
    -
    6 #include <assert.h>
    -
    7 #include <complex.h>
    -
    8 #include <stdio.h>
    -
    9 #include <stdlib.h>
    -
    10 #include <string.h>
    -
    11 #include <math.h>
    -
    12 #include <time.h>
    -
    13 
    -
    24 int main(int argc, char *argv[])
    -
    25 {
    -
    26  printf("--------------------------------------------------\n");
    -
    27  printf("S2LET library : axisymmetric wavelet transform\n");
    -
    28  printf("Real signal, MW sampling\n");
    -
    29  printf("--------------------------------------------------\n");
    -
    30 
    -
    31  char fileroot[100];
    -
    32  if (sscanf(argv[1], "%s", fileroot) != 1)
    -
    33  exit(-2);
    -
    34  int multires, B, J_min, L;
    -
    35  if (sscanf(argv[2], "%i", &B) != 1)
    -
    36  exit(-2);
    -
    37  if (sscanf(argv[3], "%i", &J_min) != 1)
    -
    38  exit(-2);
    -
    39  if (sscanf(argv[4], "%i", &L) != 1)
    -
    40  exit(-2);
    -
    41 
    -
    42  s2let_parameters_t parameters = {};
    -
    43 
    -
    44  parameters.B = B;
    -
    45  parameters.L = L;
    -
    46  parameters.J_min = J_min;
    -
    47 
    -
    48  printf("Parameters for wavelet transform :\n");
    -
    49  int J = s2let_j_max(&parameters);
    -
    50  printf("- Wavelet parameter : %i\n", B);
    -
    51  printf("- Total number of wavelets : %i\n", J);
    -
    52  printf("- First wavelet scale to be used : %i\n", J_min);
    -
    53  printf("- Band-limit for the map : %i\n", L);
    -
    54 
    -
    55  // Input rootname for the FITS files
    -
    56  char file[100];
    -
    57  char params[100];
    -
    58  sprintf(params, "%d%s%d%s%d", L, "_", B, "_", J_min);
    -
    59  int j, bl, offset = 0;
    -
    60  printf("File root = %s\n",fileroot);
    -
    61 
    -
    62  // Read band-limits and see if multiresolution was activated
    -
    63  int multires_ok = 1, monores_ok = 1;
    -
    64  for(j = J; j >= J_min; j--){
    -
    65  sprintf(file, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits");
    -
    66  printf("- Infile_wav[j=%i] = %s\n",j,file);
    -
    67  bl = s2let_fits_mw_read_bandlimit(file);
    -
    68  printf(" Detected bandlimit bl = %i\n",bl);
    -
    69  if( bl != MIN(s2let_bandlimit(j, &parameters), L) )
    -
    70  multires_ok = 0;
    -
    71  if( bl != L )
    -
    72  monores_ok = 0;
    -
    73  }
    -
    74  // Read the scaling function
    -
    75  sprintf(file, "%s%s%s%s", fileroot, "_scal_", params, ".fits");
    -
    76  printf("- Infile_scal = %s\n",file);
    -
    77  bl = s2let_fits_mw_read_bandlimit(file);
    -
    78  printf(" Detected bandlimit bl = %i\n",bl);
    -
    79  if( bl != MIN(s2let_bandlimit(J_min-1, &parameters), L) )
    -
    80  multires_ok = 0;
    -
    81  if( bl != L )
    -
    82  monores_ok = 0;
    -
    83 
    -
    84  // Are the parameters and the maps all consistent ?
    -
    85  if( monores_ok == 0 && multires_ok == 0 ){
    -
    86  printf("The parameters don't match the bandlimits of the input maps");
    -
    87  printf("Neither the full or the multi-resolution algorithms are detected");
    -
    88  exit(-2);
    -
    89  }
    -
    90 
    -
    91  // Activate full or multi-resolution
    -
    92  if(multires_ok == 1){
    -
    93  multires = 1;
    -
    94  printf("Multiresolution activated\n");
    -
    95  }else{
    -
    96  multires = 0;
    -
    97  printf("Multiresolution not activated\n");
    -
    98  }
    -
    99 
    -
    100  // Allocating memory for the wavelets
    -
    101  double *f_wav, *f_scal;
    -
    102  if(multires){
    -
    103  s2let_transform_axisym_allocate_mw_f_wav_multires_real(&f_wav, &f_scal, &parameters);
    -
    104  }else{
    -
    105  s2let_transform_axisym_allocate_mw_f_wav_real(&f_wav, &f_scal, &parameters);
    -
    106  }
    -
    107 
    -
    108  // Read the wavelets
    -
    109  offset = 0;
    -
    110  for(j = J_min; j <= J; j++){
    -
    111  sprintf(file, "%s%s%s%s%d%s", fileroot, "_wav_", params, "_", j, ".fits");
    -
    112  if(multires)
    -
    113  bl = MIN(s2let_bandlimit(j, &parameters), L);
    -
    114  else
    -
    115  bl = L;
    -
    116  s2let_fits_mw_read_map(f_wav + offset, file, bl); // Now write the map to fits file
    -
    117  offset += (2*bl-1) * bl; // Go to the next wavelet
    -
    118  }
    -
    119  // Read the scaling function
    -
    120  sprintf(file, "%s%s%s%s", fileroot, "_scal_", params, ".fits");
    -
    121  if(multires)
    -
    122  bl = MIN(s2let_bandlimit(J_min-1, &parameters), L);
    -
    123  else
    -
    124  bl = L;
    -
    125  s2let_fits_mw_read_map(f_scal, file, bl);
    -
    126 
    -
    127 
    -
    128  printf("Performing wavelet decomposition...");fflush(NULL);
    -
    129  double *f = (double*)calloc(L * (2 * L - 1), sizeof(double));
    -
    130  if(multires){
    -
    131  s2let_transform_axisym_wav_synthesis_mw_multires_real(f, f_wav, f_scal, &parameters);
    -
    132  }else{
    -
    133  s2let_transform_axisym_wav_synthesis_mw_real(f, f_wav, f_scal, &parameters);
    -
    134  }
    -
    135  printf("done\n");
    -
    136 
    -
    137  // Output the reconstruction to FITS file
    -
    138  char outfile[100];
    -
    139  printf("Writing the reconstructed map to a FITS file\n");
    -
    140  sprintf(outfile, "%s%s%s%s", fileroot, "_recon_", params, ".fits");
    -
    141  printf("- Outfile = %s\n",outfile);
    -
    142  remove(outfile); // In case the file exists
    -
    143  s2let_fits_mw_write_map(outfile, f, L); // Now write the map to fits file
    -
    144 
    -
    145  printf("--------------------------------------------------\n");
    -
    146 
    -
    147  return 0;
    -
    148 }
    -
    149 
    -
    150 
    -
    -
    main
    int main(int argc, char *argv[])
    Definition: s2let_transform_axisym_synthesis_mw_real.c:24
    -
    s2let_transform_axisym_wav_synthesis_mw_real
    void s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:789
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_transform_axisym_allocate_mw_f_wav_real
    void s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:74
    - -
    s2let_j_max
    int s2let_j_max(const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:108
    -
    s2let_transform_axisym_wav_synthesis_mw_multires_real
    void s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:1053
    -
    s2let_fits_mw_read_bandlimit
    int s2let_fits_mw_read_bandlimit(char *filename)
    Definition: s2let_fits.c:18
    -
    s2let_fits_mw_write_map
    void s2let_fits_mw_write_map(char *filename, double *f, int L)
    Definition: s2let_fits.c:98
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_fits_mw_read_map
    void s2let_fits_mw_read_map(double *f, char *filename, int L)
    Definition: s2let_fits.c:207
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_bandlimit
    int s2let_bandlimit(int j, const s2let_parameters_t *parameters)
    Definition: s2let_tiling.c:51
    -
    MIN
    #define MIN(a, b)
    Definition: s2let_math.h:11
    -
    s2let_transform_axisym_allocate_mw_f_wav_multires_real
    void s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters)
    Definition: s2let_transform_axisym_mw.c:94
    - -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 -
    - - diff --git a/docs/c/s2let__types_8h.html b/docs/c/s2let__types_8h.html index d6caa76a..7cd232ac 100644 --- a/docs/c/s2let__types_8h.html +++ b/docs/c/s2let__types_8h.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_types.h File Reference +s2let: include/s2let_types.h File Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -77,6 +77,57 @@
    #include <ssht/ssht.h>
    +
    +Include dependency graph for s2let_types.h:
    +
    +
    + + + + +
    +
    +This graph shows which files directly or indirectly include this file:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    Go to the source code of this file.

    @@ -115,8 +166,6 @@

    -

    Definition at line 15 of file s2let_types.h.

    -

    Enumeration Type Documentation

    @@ -140,14 +189,12 @@

    Definition at line 18 of file s2let_types.h.

    -
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/s2let__types_8h__dep__incl.map b/docs/c/s2let__types_8h__dep__incl.map new file mode 100644 index 00000000..a115f393 --- /dev/null +++ b/docs/c/s2let__types_8h__dep__incl.map @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/s2let__types_8h__dep__incl.md5 b/docs/c/s2let__types_8h__dep__incl.md5 new file mode 100644 index 00000000..75fe35ed --- /dev/null +++ b/docs/c/s2let__types_8h__dep__incl.md5 @@ -0,0 +1 @@ +2ed62da257d3873d6b023c2bf2f83f76 \ No newline at end of file diff --git a/docs/c/s2let__types_8h__incl.map b/docs/c/s2let__types_8h__incl.map new file mode 100644 index 00000000..321b88f4 --- /dev/null +++ b/docs/c/s2let__types_8h__incl.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/c/s2let__types_8h__incl.md5 b/docs/c/s2let__types_8h__incl.md5 new file mode 100644 index 00000000..3dbae12f --- /dev/null +++ b/docs/c/s2let__types_8h__incl.md5 @@ -0,0 +1 @@ +47429b02eeeda652eb899160864f257b \ No newline at end of file diff --git a/docs/c/s2let__types_8h_source.html b/docs/c/s2let__types_8h_source.html index 57b9aa71..604cd834 100644 --- a/docs/c/s2let__types_8h_source.html +++ b/docs/c/s2let__types_8h_source.html @@ -5,7 +5,7 @@ -S2LET: include/s2let_types.h Source File +s2let: include/s2let_types.h Source File @@ -22,10 +22,10 @@

    @@ -124,25 +124,25 @@
    140 #endif
    141 #endif
    -
    S2LET_SAMPLING_SIZE
    @ S2LET_SAMPLING_SIZE
    Definition: s2let_types.h:37
    -
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    -
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    -
    s2let_parameters_t::verbosity
    int verbosity
    Definition: s2let_types.h:61
    -
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    -
    S2LET_SAMPLING_MW_SS
    @ S2LET_SAMPLING_MW_SS
    Definition: s2let_types.h:32
    -
    s2let_parameters_t::original_spin
    int original_spin
    Definition: s2let_types.h:122
    -
    s2let_parameters_t::reality
    int reality
    Definition: s2let_types.h:70
    -
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    -
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    -
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    -
    s2let_sampling_t
    s2let_sampling_t
    Definition: s2let_types.h:18
    -
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    -
    s2let_parameters_t
    Definition: s2let_types.h:56
    -
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    -
    S2LET_SAMPLING_MW
    @ S2LET_SAMPLING_MW
    Definition: s2let_types.h:25
    +
    S2LET_SAMPLING_SIZE
    @ S2LET_SAMPLING_SIZE
    Definition: s2let_types.h:37
    +
    s2let_parameters_t::B
    double B
    Definition: s2let_types.h:89
    +
    s2let_parameters_t::spin
    int spin
    Definition: s2let_types.h:115
    +
    s2let_parameters_t::verbosity
    int verbosity
    Definition: s2let_types.h:61
    +
    s2let_parameters_t::dl_method
    ssht_dl_method_t dl_method
    Definition: s2let_types.h:135
    +
    S2LET_SAMPLING_MW_SS
    @ S2LET_SAMPLING_MW_SS
    Definition: s2let_types.h:32
    +
    s2let_parameters_t::original_spin
    int original_spin
    Definition: s2let_types.h:122
    +
    s2let_parameters_t::reality
    int reality
    Definition: s2let_types.h:70
    +
    s2let_parameters_t::L
    int L
    Definition: s2let_types.h:96
    +
    s2let_parameters_t::J_min
    int J_min
    Definition: s2let_types.h:102
    +
    s2let_parameters_t::upsample
    int upsample
    Definition: s2let_types.h:82
    +
    s2let_sampling_t
    s2let_sampling_t
    Definition: s2let_types.h:18
    +
    s2let_parameters_t::N
    int N
    Definition: s2let_types.h:109
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_parameters_t::sampling_scheme
    s2let_sampling_t sampling_scheme
    Definition: s2let_types.h:129
    +
    S2LET_SAMPLING_MW
    @ S2LET_SAMPLING_MW
    Definition: s2let_types.h:25
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/search/all_10.js b/docs/c/search/all_10.js index 81805f60..3074739f 100644 --- a/docs/c/search/all_10.js +++ b/docs/c/search/all_10.js @@ -1,4 +1,4 @@ var searchData= [ - ['verbosity_309',['verbosity',['../structs2let__parameters__t.html#a6198529ad111be476461d3d249d3fa0a',1,'s2let_parameters_t']]] + ['upsample_343',['upsample',['../structs2let__parameters__t.html#aec567c0f2af65ec246fd92169ae66216',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/all_11.js b/docs/c/search/all_11.js index 529b9bcc..13f16428 100644 --- a/docs/c/search/all_11.js +++ b/docs/c/search/all_11.js @@ -1,5 +1,4 @@ var searchData= [ - ['waveletpower_310',['waveletpower',['../s2let__denoising__demo_8c.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_denoising_demo.c'],['../s2let__spin__denoising__demo_8c.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_spin_denoising_demo.c'],['../s2let__denoising__demo_8h.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_denoising_demo.c']]], - ['write_5fhealpix_5fmap_5f_311',['write_healpix_map_',['../s2let__hpx_8c.html#a8b5ed98a88a7f8a79c0d31338f972b19',1,'s2let_hpx.c']]] + ['verbosity_344',['verbosity',['../structs2let__parameters__t.html#a6198529ad111be476461d3d249d3fa0a',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/all_12.html b/docs/c/search/all_12.html new file mode 100644 index 00000000..37072621 --- /dev/null +++ b/docs/c/search/all_12.html @@ -0,0 +1,36 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/c/search/all_12.js b/docs/c/search/all_12.js new file mode 100644 index 00000000..ea9db0a8 --- /dev/null +++ b/docs/c/search/all_12.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['waveletpower_345',['waveletpower',['../s2let__denoising__demo_8c.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_denoising_demo.c'],['../s2let__spin__denoising__demo_8c.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_spin_denoising_demo.c'],['../s2let__denoising__demo_8h.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_denoising_demo.c']]], + ['write_5fhealpix_5fmap_5f_346',['write_healpix_map_',['../s2let__hpx_8c.html#a8b5ed98a88a7f8a79c0d31338f972b19',1,'s2let_hpx.c']]] +]; diff --git a/docs/c/search/all_4.js b/docs/c/search/all_4.js index 2e44377a..b154a16c 100644 --- a/docs/c/search/all_4.js +++ b/docs/c/search/all_4.js @@ -1,4 +1,5 @@ var searchData= [ - ['get_5fmax_5ferror_7',['get_max_error',['../s2let__test__csv_8c.html#a4d00c945ef5468ad68184f0bc1ada91a',1,'s2let_test_csv.c']]] + ['gen_5fflmn_5fcomplex_7',['gen_flmn_complex',['../test__adjoint_8c.html#a4905dad7b518bab34378cec6d748634c',1,'test_adjoint.c']]], + ['get_5fmax_5ferror_8',['get_max_error',['../s2let__test__csv_8c.html#a4d00c945ef5468ad68184f0bc1ada91a',1,'s2let_test_csv.c']]] ]; diff --git a/docs/c/search/all_5.js b/docs/c/search/all_5.js index ecb4fa30..9acfeca9 100644 --- a/docs/c/search/all_5.js +++ b/docs/c/search/all_5.js @@ -1,9 +1,9 @@ var searchData= [ - ['hard_5fthreshold_8',['hard_threshold',['../s2let__spin__denoising__demo_8c.html#a6efb36935c405dca5e9dd591164f79a0',1,'s2let_spin_denoising_demo.c']]], - ['hard_5fthreshold_5freal_9',['hard_threshold_real',['../s2let__denoising__demo_8c.html#a067d9bf357dbfd7a4986d3f62a9e8c45',1,'hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_denoising_demo.c'],['../s2let__denoising__demo_8h.html#a067d9bf357dbfd7a4986d3f62a9e8c45',1,'hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_denoising_demo.c']]], - ['healpix_5fforward_5freal_5f_10',['healpix_forward_real_',['../s2let__hpx_8c.html#ad1de3129addcea74634d9f809615948b',1,'s2let_hpx.c']]], - ['healpix_5fforward_5fspin_5freal_5f_11',['healpix_forward_spin_real_',['../s2let__hpx_8c.html#a3c1aa5d1d8986ea812c873bd8dd429fa',1,'s2let_hpx.c']]], - ['healpix_5finverse_5freal_5f_12',['healpix_inverse_real_',['../s2let__hpx_8c.html#aeb1da4714bc41184ec236de731756560',1,'s2let_hpx.c']]], - ['healpix_5finverse_5fspin_5freal_5f_13',['healpix_inverse_spin_real_',['../s2let__hpx_8c.html#a27eaaf7d94a6fa9c382fea95ad13d9a0',1,'s2let_hpx.c']]] + ['hard_5fthreshold_9',['hard_threshold',['../s2let__spin__denoising__demo_8c.html#a6efb36935c405dca5e9dd591164f79a0',1,'s2let_spin_denoising_demo.c']]], + ['hard_5fthreshold_5freal_10',['hard_threshold_real',['../s2let__denoising__demo_8c.html#a067d9bf357dbfd7a4986d3f62a9e8c45',1,'hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_denoising_demo.c'],['../s2let__denoising__demo_8h.html#a067d9bf357dbfd7a4986d3f62a9e8c45',1,'hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_denoising_demo.c']]], + ['healpix_5fforward_5freal_5f_11',['healpix_forward_real_',['../s2let__hpx_8c.html#ad1de3129addcea74634d9f809615948b',1,'s2let_hpx.c']]], + ['healpix_5fforward_5fspin_5freal_5f_12',['healpix_forward_spin_real_',['../s2let__hpx_8c.html#a3c1aa5d1d8986ea812c873bd8dd429fa',1,'s2let_hpx.c']]], + ['healpix_5finverse_5freal_5f_13',['healpix_inverse_real_',['../s2let__hpx_8c.html#aeb1da4714bc41184ec236de731756560',1,'s2let_hpx.c']]], + ['healpix_5finverse_5fspin_5freal_5f_14',['healpix_inverse_spin_real_',['../s2let__hpx_8c.html#a27eaaf7d94a6fa9c382fea95ad13d9a0',1,'s2let_hpx.c']]] ]; diff --git a/docs/c/search/all_6.js b/docs/c/search/all_6.js index e18c3d6e..79dfb4f2 100644 --- a/docs/c/search/all_6.js +++ b/docs/c/search/all_6.js @@ -1,9 +1,9 @@ var searchData= [ - ['idl_5fint_14',['IDL_INT',['../s2let__idl__hpx_8c.html#a02b9546523fe5ea064e9cc44ce4ad751',1,'IDL_INT(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a02b9546523fe5ea064e9cc44ce4ad751',1,'IDL_INT(): s2let_idl_mw.c']]], - ['idl_5flong_15',['IDL_LONG',['../s2let__idl__hpx_8c.html#a2d29aee49d7de2cb7d11978dd8dfe4a3',1,'IDL_LONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a2d29aee49d7de2cb7d11978dd8dfe4a3',1,'IDL_LONG(): s2let_idl_mw.c']]], - ['idl_5fsizeof_5fc_5flong_16',['IDL_SIZEOF_C_LONG',['../s2let__idl__hpx_8c.html#a313037b4edc7817a7a40c3a4615ebdfa',1,'IDL_SIZEOF_C_LONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a313037b4edc7817a7a40c3a4615ebdfa',1,'IDL_SIZEOF_C_LONG(): s2let_idl_mw.c']]], - ['idl_5fsizeof_5fc_5fptr_17',['IDL_SIZEOF_C_PTR',['../s2let__idl__hpx_8c.html#a40d088f282782bc6c35262aea13548c6',1,'IDL_SIZEOF_C_PTR(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a40d088f282782bc6c35262aea13548c6',1,'IDL_SIZEOF_C_PTR(): s2let_idl_mw.c']]], - ['idl_5fuint_18',['IDL_UINT',['../s2let__idl__hpx_8c.html#a5a626e989d3e813bd723db23edabbe08',1,'IDL_UINT(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a5a626e989d3e813bd723db23edabbe08',1,'IDL_UINT(): s2let_idl_mw.c']]], - ['idl_5fulong_19',['IDL_ULONG',['../s2let__idl__hpx_8c.html#abac63fddf94105cf1190b69730bb6a1c',1,'IDL_ULONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#abac63fddf94105cf1190b69730bb6a1c',1,'IDL_ULONG(): s2let_idl_mw.c']]] + ['idl_5fint_15',['IDL_INT',['../s2let__idl__hpx_8c.html#a02b9546523fe5ea064e9cc44ce4ad751',1,'IDL_INT(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a02b9546523fe5ea064e9cc44ce4ad751',1,'IDL_INT(): s2let_idl_mw.c']]], + ['idl_5flong_16',['IDL_LONG',['../s2let__idl__hpx_8c.html#a2d29aee49d7de2cb7d11978dd8dfe4a3',1,'IDL_LONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a2d29aee49d7de2cb7d11978dd8dfe4a3',1,'IDL_LONG(): s2let_idl_mw.c']]], + ['idl_5fsizeof_5fc_5flong_17',['IDL_SIZEOF_C_LONG',['../s2let__idl__hpx_8c.html#a313037b4edc7817a7a40c3a4615ebdfa',1,'IDL_SIZEOF_C_LONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a313037b4edc7817a7a40c3a4615ebdfa',1,'IDL_SIZEOF_C_LONG(): s2let_idl_mw.c']]], + ['idl_5fsizeof_5fc_5fptr_18',['IDL_SIZEOF_C_PTR',['../s2let__idl__hpx_8c.html#a40d088f282782bc6c35262aea13548c6',1,'IDL_SIZEOF_C_PTR(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a40d088f282782bc6c35262aea13548c6',1,'IDL_SIZEOF_C_PTR(): s2let_idl_mw.c']]], + ['idl_5fuint_19',['IDL_UINT',['../s2let__idl__hpx_8c.html#a5a626e989d3e813bd723db23edabbe08',1,'IDL_UINT(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a5a626e989d3e813bd723db23edabbe08',1,'IDL_UINT(): s2let_idl_mw.c']]], + ['idl_5fulong_20',['IDL_ULONG',['../s2let__idl__hpx_8c.html#abac63fddf94105cf1190b69730bb6a1c',1,'IDL_ULONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#abac63fddf94105cf1190b69730bb6a1c',1,'IDL_ULONG(): s2let_idl_mw.c']]] ]; diff --git a/docs/c/search/all_7.js b/docs/c/search/all_7.js index e2eeb2e9..0e50bf63 100644 --- a/docs/c/search/all_7.js +++ b/docs/c/search/all_7.js @@ -1,4 +1,4 @@ var searchData= [ - ['j_5fmin_20',['J_min',['../structs2let__parameters__t.html#a9146ca6b1dd496925173a0ab1feeccf7',1,'s2let_parameters_t']]] + ['j_5fmin_21',['J_min',['../structs2let__parameters__t.html#a9146ca6b1dd496925173a0ab1feeccf7',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/all_8.js b/docs/c/search/all_8.js index 02eb6ed4..cd7e9621 100644 --- a/docs/c/search/all_8.js +++ b/docs/c/search/all_8.js @@ -1,4 +1,4 @@ var searchData= [ - ['l_21',['L',['../structs2let__parameters__t.html#a018fcd55bd13a231c2c71f16cca5c53b',1,'s2let_parameters_t']]] + ['l_22',['L',['../structs2let__parameters__t.html#a018fcd55bd13a231c2c71f16cca5c53b',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/all_9.js b/docs/c/search/all_9.js index 3cae3d2f..723717e5 100644 --- a/docs/c/search/all_9.js +++ b/docs/c/search/all_9.js @@ -1,8 +1,8 @@ var searchData= [ - ['main_22',['main',['../s2let__about_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_about.c'],['../s2let__axisym__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_denoising_demo.c'],['../s2let__hpx__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_hpx_demo.c'],['../s2let__spin__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_spin_denoising_demo.c'],['../s2let__transform__axisym__analysis__hpx__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_analysis_hpx_real.c'],['../s2let__transform__axisym__analysis__mw__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_analysis_mw_real.c'],['../s2let__transform__axisym__synthesis__hpx__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_synthesis_hpx_real.c'],['../s2let__transform__axisym__synthesis__mw__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_synthesis_mw_real.c'],['../s2let__hpx__test_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_hpx_test.c'],['../s2let__test_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_test.c'],['../s2let__test__csv_8c.html#a3c04138a5bfe5d72780bb7e82a18e627',1,'main(int argc, char **argv): s2let_test_csv.c']]], - ['max_23',['MAX',['../s2let__math_8h.html#afa99ec4acc4ecb2dc3c2d05da15d0e3f',1,'s2let_math.h']]], - ['maxerr_24',['maxerr',['../s2let__math_8c.html#a4f5998b7b92ffac7fea15fee7ce645f0',1,'maxerr(double *a, double *b, int size): s2let_math.c'],['../s2let__math_8h.html#a4f5998b7b92ffac7fea15fee7ce645f0',1,'maxerr(double *a, double *b, int size): s2let_math.c']]], - ['maxerr_5fcplx_25',['maxerr_cplx',['../s2let__math_8c.html#a393b1deb6be62de0afa639a203b78b15',1,'maxerr_cplx(complex double *a, complex double *b, int size): s2let_math.c'],['../s2let__math_8h.html#af19ac104dc4577702838dcd24f99d2a0',1,'maxerr_cplx(S2LET_COMPLEX(double) *a, S2LET_COMPLEX(double) *b, int size): s2let_math.h']]], - ['min_26',['MIN',['../s2let__math_8h.html#a3acffbd305ee72dcd4593c0d8af64a4f',1,'s2let_math.h']]] + ['main_23',['main',['../s2let__about_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_about.c'],['../s2let__axisym__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_denoising_demo.c'],['../s2let__hpx__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_hpx_demo.c'],['../s2let__spin__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_spin_denoising_demo.c'],['../s2let__transform__axisym__analysis__hpx__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_analysis_hpx_real.c'],['../s2let__transform__axisym__analysis__mw__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_analysis_mw_real.c'],['../s2let__transform__axisym__synthesis__hpx__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_synthesis_hpx_real.c'],['../s2let__transform__axisym__synthesis__mw__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_synthesis_mw_real.c'],['../s2let__hpx__test_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_hpx_test.c'],['../s2let__test_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_test.c'],['../s2let__test__csv_8c.html#a3c04138a5bfe5d72780bb7e82a18e627',1,'main(int argc, char **argv): s2let_test_csv.c'],['../test__adjoint_8c.html#a840291bc02cba5474a4cb46a9b9566fe',1,'main(void): test_adjoint.c'],['../test__axisym__vs__directional_8c.html#a840291bc02cba5474a4cb46a9b9566fe',1,'main(void): test_axisym_vs_directional.c'],['../test__back__and__forth_8c.html#a840291bc02cba5474a4cb46a9b9566fe',1,'main(void): test_back_and_forth.c'],['../test__tiling_8c.html#a840291bc02cba5474a4cb46a9b9566fe',1,'main(void): test_tiling.c']]], + ['max_24',['MAX',['../s2let__math_8h.html#afa99ec4acc4ecb2dc3c2d05da15d0e3f',1,'s2let_math.h']]], + ['maxerr_25',['maxerr',['../s2let__math_8c.html#a4f5998b7b92ffac7fea15fee7ce645f0',1,'maxerr(double *a, double *b, int size): s2let_math.c'],['../s2let__math_8h.html#a4f5998b7b92ffac7fea15fee7ce645f0',1,'maxerr(double *a, double *b, int size): s2let_math.c']]], + ['maxerr_5fcplx_26',['maxerr_cplx',['../s2let__math_8c.html#a393b1deb6be62de0afa639a203b78b15',1,'maxerr_cplx(complex double *a, complex double *b, int size): s2let_math.c'],['../s2let__math_8h.html#af19ac104dc4577702838dcd24f99d2a0',1,'maxerr_cplx(S2LET_COMPLEX(double) *a, S2LET_COMPLEX(double) *b, int size): s2let_math.h']]], + ['min_27',['MIN',['../s2let__math_8h.html#a3acffbd305ee72dcd4593c0d8af64a4f',1,'MIN(): s2let_math.h'],['../test__axisym__vs__directional_8c.html#aafee2c9cc9a9d15d30b3c3189e2146d0',1,'min(int a, int b): test_axisym_vs_directional.c']]] ]; diff --git a/docs/c/search/all_a.js b/docs/c/search/all_a.js index ed6cbf69..5dd9eada 100644 --- a/docs/c/search/all_a.js +++ b/docs/c/search/all_a.js @@ -1,7 +1,7 @@ var searchData= [ - ['n_27',['N',['../structs2let__parameters__t.html#a93d528e7cc428bfc6783e9a01567b748',1,'s2let_parameters_t']]], - ['needlet_28',['NEEDLET',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aa1ab4d051220837ebef5b7bbc03e7f2ac',1,'s2let_tiling.c']]], - ['needletpower_29',['needletpower',['../s2let__axisym__denoising__demo_8c.html#a16c08eb6db78637aae2b6ffdfd13cfe2',1,'needletpower(double *wav_lm, int L): s2let_axisym_denoising_demo.c'],['../s2let__axisym__denoising__demo_8h.html#a16c08eb6db78637aae2b6ffdfd13cfe2',1,'needletpower(double *wav_lm, int L): s2let_axisym_denoising_demo.c']]], - ['nrepeat_30',['NREPEAT',['../s2let__test__csv_8c.html#a9fa6466347dd349266768c7f7f0b0e4e',1,'s2let_test_csv.c']]] + ['n_28',['N',['../structs2let__parameters__t.html#a93d528e7cc428bfc6783e9a01567b748',1,'s2let_parameters_t']]], + ['needlet_29',['NEEDLET',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aa1ab4d051220837ebef5b7bbc03e7f2ac',1,'s2let_tiling.c']]], + ['needletpower_30',['needletpower',['../s2let__axisym__denoising__demo_8c.html#a16c08eb6db78637aae2b6ffdfd13cfe2',1,'needletpower(double *wav_lm, int L): s2let_axisym_denoising_demo.c'],['../s2let__axisym__denoising__demo_8h.html#a16c08eb6db78637aae2b6ffdfd13cfe2',1,'needletpower(double *wav_lm, int L): s2let_axisym_denoising_demo.c']]], + ['nrepeat_31',['NREPEAT',['../s2let__test__csv_8c.html#a9fa6466347dd349266768c7f7f0b0e4e',1,'s2let_test_csv.c']]] ]; diff --git a/docs/c/search/all_b.js b/docs/c/search/all_b.js index 4db3ac3e..bc09573d 100644 --- a/docs/c/search/all_b.js +++ b/docs/c/search/all_b.js @@ -1,4 +1,4 @@ var searchData= [ - ['original_5fspin_31',['original_spin',['../structs2let__parameters__t.html#a9b083a6f2ac9139fbe25605685c97b4e',1,'s2let_parameters_t']]] + ['original_5fspin_32',['original_spin',['../structs2let__parameters__t.html#a9b083a6f2ac9139fbe25605685c97b4e',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/all_c.js b/docs/c/search/all_c.js index 4cff6765..8322db03 100644 --- a/docs/c/search/all_c.js +++ b/docs/c/search/all_c.js @@ -1,5 +1,5 @@ var searchData= [ - ['pi_32',['PI',['../s2let__math_8h.html#a598a3330b3c21701223ee0ca14316eca',1,'PI(): s2let_math.h'],['../s2let__tiling_8h.html#a598a3330b3c21701223ee0ca14316eca',1,'PI(): s2let_tiling.h']]], - ['printerror_33',['printerror',['../s2let__fits_8c.html#aca57f410eb9f3d6ec61c1c17d4aea3da',1,'s2let_fits.c']]] + ['pi_33',['PI',['../s2let__math_8h.html#a598a3330b3c21701223ee0ca14316eca',1,'PI(): s2let_math.h'],['../s2let__tiling_8h.html#a598a3330b3c21701223ee0ca14316eca',1,'PI(): s2let_tiling.h']]], + ['printerror_34',['printerror',['../s2let__fits_8c.html#aca57f410eb9f3d6ec61c1c17d4aea3da',1,'s2let_fits.c']]] ]; diff --git a/docs/c/search/all_d.js b/docs/c/search/all_d.js index 32dc3db1..750b5576 100644 --- a/docs/c/search/all_d.js +++ b/docs/c/search/all_d.js @@ -1,7 +1,7 @@ var searchData= [ - ['ran2_5fdp_34',['ran2_dp',['../s2let__math_8c.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c'],['../s2let__test__csv_8c.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c'],['../s2let__math_8h.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c']]], - ['read_5fhealpix_5fmap_5f_35',['read_healpix_map_',['../s2let__hpx_8c.html#ae43fcaf0a30b8979a329c9d8a639f9aa',1,'s2let_hpx.c']]], - ['read_5fhealpix_5fmaps_5f_36',['read_healpix_maps_',['../s2let__hpx_8c.html#a24812c14ec76f109d5dae58289353afd',1,'s2let_hpx.c']]], - ['reality_37',['reality',['../structs2let__parameters__t.html#a7718737039d19e05501792535b32ef6d',1,'s2let_parameters_t']]] + ['ran2_5fdp_35',['ran2_dp',['../s2let__math_8c.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c'],['../s2let__test__csv_8c.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c'],['../s2let__math_8h.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c']]], + ['read_5fhealpix_5fmap_5f_36',['read_healpix_map_',['../s2let__hpx_8c.html#ae43fcaf0a30b8979a329c9d8a639f9aa',1,'s2let_hpx.c']]], + ['read_5fhealpix_5fmaps_5f_37',['read_healpix_maps_',['../s2let__hpx_8c.html#a24812c14ec76f109d5dae58289353afd',1,'s2let_hpx.c']]], + ['reality_38',['reality',['../structs2let__parameters__t.html#a7718737039d19e05501792535b32ef6d',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/all_e.js b/docs/c/search/all_e.js index 6c7246c9..7b707294 100644 --- a/docs/c/search/all_e.js +++ b/docs/c/search/all_e.js @@ -1,273 +1,275 @@ var searchData= [ - ['s2dw_38',['S2DW',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aad2e1e459d07d91ca00e5f09caf8b4558',1,'s2let_tiling.c']]], - ['s2let_2eh_39',['s2let.h',['../s2let_8h.html',1,'']]], - ['s2let_5fabout_2ec_40',['s2let_about.c',['../s2let__about_8c.html',1,'']]], - ['s2let_5falloc_2ec_41',['s2let_alloc.c',['../s2let__alloc_8c.html',1,'']]], - ['s2let_5falloc_2eh_42',['s2let_alloc.h',['../s2let__alloc_8h.html',1,'']]], - ['s2let_5fallocate_5ff_5fwav_43',['s2let_allocate_f_wav',['../s2let__alloc_8c.html#a04372bb80be30ca4b5442c682c550866',1,'s2let_allocate_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a1e37dc2888e4d40c947e7c7727eb8ad7',1,'s2let_allocate_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_alloc.h']]], - ['s2let_5fallocate_5ff_5fwav_5fmanual_44',['s2let_allocate_f_wav_manual',['../s2let__alloc_8c.html#a2a547a089b006e1dda73b84cad4c085e',1,'s2let_allocate_f_wav_manual(complex double **f_wav, complex double **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#aa5c19adf92fef81e6e6481d445b481bb',1,'s2let_allocate_f_wav_manual(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, s2let_parameters_t *parameters): s2let_alloc.h']]], - ['s2let_5fallocate_5ff_5fwav_5freal_45',['s2let_allocate_f_wav_real',['../s2let__alloc_8c.html#a979f526f58f72c9c96e16e2ba46e0f63',1,'s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a979f526f58f72c9c96e16e2ba46e0f63',1,'s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c']]], - ['s2let_5fallocate_5flm_46',['s2let_allocate_lm',['../s2let__alloc_8c.html#a8b221a008760c8dbe1a655c74dc2d0d0',1,'s2let_allocate_lm(complex double **flm, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#aa7bc8a069c40873338f1e8c770f34424',1,'s2let_allocate_lm(S2LET_COMPLEX(double) **flm, int L): s2let_alloc.h']]], - ['s2let_5fallocate_5flmn_5ff_5fwav_47',['s2let_allocate_lmn_f_wav',['../s2let__alloc_8c.html#a9dcb24db0b9cd7dd522bead7d61f7960',1,'s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a8c43cc27f8f2450ae6ec9bb6165dfd8b',1,'s2let_allocate_lmn_f_wav(S2LET_COMPLEX(double) **f_wav_lmn, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_alloc.h']]], - ['s2let_5fallocate_5fmw_48',['s2let_allocate_mw',['../s2let__alloc_8c.html#a83fad2b470cea9f29d8fe104616236dc',1,'s2let_allocate_mw(complex double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#ac042b364686fc53225102c71fc10f797',1,'s2let_allocate_mw(S2LET_COMPLEX(double) **f, int L): s2let_alloc.h']]], - ['s2let_5fallocate_5fmw_5freal_49',['s2let_allocate_mw_real',['../s2let__alloc_8c.html#a22e7d6f3fdc037d975eaad03ef0ece23',1,'s2let_allocate_mw_real(double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#a22e7d6f3fdc037d975eaad03ef0ece23',1,'s2let_allocate_mw_real(double **f, int L): s2let_alloc.c']]], - ['s2let_5fallocate_5fmwss_50',['s2let_allocate_mwss',['../s2let__alloc_8c.html#a4569d2d2e8251c4e65494b1518ebe72e',1,'s2let_allocate_mwss(complex double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#ab914515792a062cc87662d8a6b028b7b',1,'s2let_allocate_mwss(S2LET_COMPLEX(double) **f, int L): s2let_alloc.h']]], - ['s2let_5fallocate_5fmwss_5freal_51',['s2let_allocate_mwss_real',['../s2let__alloc_8c.html#a562dc748f45b20b9791bbca68045c472',1,'s2let_allocate_mwss_real(double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#a562dc748f45b20b9791bbca68045c472',1,'s2let_allocate_mwss_real(double **f, int L): s2let_alloc.c']]], - ['s2let_5fanalysis_2ec_52',['s2let_analysis.c',['../s2let__analysis_8c.html',1,'']]], - ['s2let_5fanalysis_2eh_53',['s2let_analysis.h',['../s2let__analysis_8h.html',1,'']]], - ['s2let_5fanalysis_5fadjoint_2ec_54',['s2let_analysis_adjoint.c',['../s2let__analysis__adjoint_8c.html',1,'']]], - ['s2let_5fanalysis_5fadjoint_2eh_55',['s2let_analysis_adjoint.h',['../s2let__analysis__adjoint_8h.html',1,'']]], - ['s2let_5fanalysis_5fadjoint_5flmn2lm_56',['s2let_analysis_adjoint_lmn2lm',['../s2let__analysis__adjoint_8c.html#a72146aacc61a608c02b22299d6c61e98',1,'s2let_analysis_adjoint_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a529cb2b3e504faf4cda24b4c6d99d333',1,'s2let_analysis_adjoint_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5flmn2lm_5freal_57',['s2let_analysis_adjoint_lmn2lm_real',['../s2let__analysis__adjoint_8c.html#abee7a1a11683f976937f6ab167a4a2ed',1,'s2let_analysis_adjoint_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a2c83c6835e02811a5d264613391b789e',1,'s2let_analysis_adjoint_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2lm_58',['s2let_analysis_adjoint_wav2lm',['../s2let__analysis__adjoint_8c.html#acbf24f007aab1439f827cafe351db721',1,'s2let_analysis_adjoint_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a6c6a34d9203703ddf27f323109f9dde6',1,'s2let_analysis_adjoint_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2lm_5fmanual_59',['s2let_analysis_adjoint_wav2lm_manual',['../s2let__analysis__adjoint_8c.html#a29d0f211cfd72f240cf53504d0ba12c3',1,'s2let_analysis_adjoint_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a181593f69b4cc0d9d26aa9379dc9bba2',1,'s2let_analysis_adjoint_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2lm_5freal_60',['s2let_analysis_adjoint_wav2lm_real',['../s2let__analysis__adjoint_8c.html#a055b05e4838ea75986215b775a124568',1,'s2let_analysis_adjoint_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a46105f73ba49339a7b5565db46ac3b28',1,'s2let_analysis_adjoint_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2px_61',['s2let_analysis_adjoint_wav2px',['../s2let__analysis__adjoint_8c.html#a4033dce73ff132c2d7f0a23b7b741d85',1,'s2let_analysis_adjoint_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a8af02104042ed3c6ea7398889483cc45',1,'s2let_analysis_adjoint_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2px_5freal_62',['s2let_analysis_adjoint_wav2px_real',['../s2let__analysis__adjoint_8c.html#ad3c34c9c83b067fb9c350698fd66d5a6',1,'s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#ad3c34c9c83b067fb9c350698fd66d5a6',1,'s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c']]], - ['s2let_5fanalysis_5flm2lmn_63',['s2let_analysis_lm2lmn',['../s2let__analysis_8c.html#a9781ec2d11788c9aa5a13bbca0e6ba9c',1,'s2let_analysis_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a1ff7c08702b71c00f79668abbc950d30',1,'s2let_analysis_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5flm2lmn_5freal_64',['s2let_analysis_lm2lmn_real',['../s2let__analysis_8c.html#a08075042a4adb01136d60414fd401a60',1,'s2let_analysis_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a0ae75e5749e9bb978f21d86b674c41b5',1,'s2let_analysis_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5flm2wav_65',['s2let_analysis_lm2wav',['../s2let__analysis_8c.html#ac5d95aed75e346bb48b9249bf80ace23',1,'s2let_analysis_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a2c035e3a62cab8dd9586d6fe75ab8268',1,'s2let_analysis_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5flm2wav_5fmanual_66',['s2let_analysis_lm2wav_manual',['../s2let__analysis_8c.html#a36f06dd57668341905eb038f85c309a2',1,'s2let_analysis_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis.c'],['../s2let__analysis_8h.html#a8af83cfbde6d80b9802c85553aed5828',1,'s2let_analysis_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis.h']]], - ['s2let_5fanalysis_5flm2wav_5freal_67',['s2let_analysis_lm2wav_real',['../s2let__analysis_8c.html#a33928a9b09c9afe216dcf733ae7d1c5f',1,'s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a107abc090af40bf3d9ee37787e9d86c8',1,'s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5fpx2wav_68',['s2let_analysis_px2wav',['../s2let__analysis_8c.html#a685f469be2016583d3fc15dae0e24c93',1,'s2let_analysis_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a1fc2440d51f5255a14fddd3cc6e25e61',1,'s2let_analysis_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5fpx2wav_5freal_69',['s2let_analysis_px2wav_real',['../s2let__analysis_8c.html#a559ce533b1453fddd43b2046323d3abf',1,'s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a559ce533b1453fddd43b2046323d3abf',1,'s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_analysis.c']]], - ['s2let_5faxisym_5fdenoising_5fdemo_2ec_70',['s2let_axisym_denoising_demo.c',['../s2let__axisym__denoising__demo_8c.html',1,'']]], - ['s2let_5faxisym_5fdenoising_5fdemo_2eh_71',['s2let_axisym_denoising_demo.h',['../s2let__axisym__denoising__demo_8h.html',1,'']]], - ['s2let_5fbandlimit_72',['s2let_bandlimit',['../s2let__tiling_8c.html#ac022968b50a5a7a294fd6ae9d792119a',1,'s2let_bandlimit(int j, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ac022968b50a5a7a294fd6ae9d792119a',1,'s2let_bandlimit(int j, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5fbinomial_5fcoefficient_5ftest_73',['s2let_binomial_coefficient_test',['../s2let__test_8c.html#a468603fe2a4ae0176b1a3008b5508ac7',1,'s2let_test.c']]], - ['s2let_5fcomplex_74',['S2LET_COMPLEX',['../s2let__types_8h.html#a121c8622035e81912b4b85b436b4ec6d',1,'s2let_types.h']]], - ['s2let_5fdenoising_5fdemo_2ec_75',['s2let_denoising_demo.c',['../s2let__denoising__demo_8c.html',1,'']]], - ['s2let_5fdenoising_5fdemo_2eh_76',['s2let_denoising_demo.h',['../s2let__denoising__demo_8h.html',1,'']]], - ['s2let_5fdot_5fproduct_5fcomplex_77',['s2let_dot_product_complex',['../s2let__test_8c.html#af85961da9316af3f997f88fedd2604d9',1,'s2let_test.c']]], - ['s2let_5fdot_5fproduct_5freal_78',['s2let_dot_product_real',['../s2let__test_8c.html#ab9098753dfdaad47814f9d13a5e838a1',1,'s2let_test.c']]], - ['s2let_5ferror_2eh_79',['s2let_error.h',['../s2let__error_8h.html',1,'']]], - ['s2let_5ferror_5fgeneric_80',['S2LET_ERROR_GENERIC',['../s2let__error_8h.html#a740f1ee53df6b15f6ca098bb9163c1fc',1,'s2let_error.h']]], - ['s2let_5ferror_5fmem_5falloc_5fcheck_81',['S2LET_ERROR_MEM_ALLOC_CHECK',['../s2let__error_8h.html#a74500ae1fd825972a4508c643173c763',1,'s2let_error.h']]], - ['s2let_5ffits_2ec_82',['s2let_fits.c',['../s2let__fits_8c.html',1,'']]], - ['s2let_5ffits_2eh_83',['s2let_fits.h',['../s2let__fits_8h.html',1,'']]], - ['s2let_5ffits_5fhpx_5fread_5fnside_84',['s2let_fits_hpx_read_nside',['../s2let__fits_8c.html#a332b4542fd283126c1bfd55c6f96d0e9',1,'s2let_fits_hpx_read_nside(char *filename): s2let_fits.c'],['../s2let__fits_8h.html#a332b4542fd283126c1bfd55c6f96d0e9',1,'s2let_fits_hpx_read_nside(char *filename): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fread_5fbandlimit_85',['s2let_fits_mw_read_bandlimit',['../s2let__fits_8c.html#a32b9baca740954e5dd89ff84a873bd5f',1,'s2let_fits_mw_read_bandlimit(char *filename): s2let_fits.c'],['../s2let__fits_8h.html#a32b9baca740954e5dd89ff84a873bd5f',1,'s2let_fits_mw_read_bandlimit(char *filename): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fread_5fmap_86',['s2let_fits_mw_read_map',['../s2let__fits_8c.html#af6db1f82ef3c0d037656ec6ac54e2d19',1,'s2let_fits_mw_read_map(double *f, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a8f3efe334a8689717e3c4af67bfcc182',1,'s2let_fits_mw_read_map(double *f, char *file, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fread_5fspin_5fmaps_87',['s2let_fits_mw_read_spin_maps',['../s2let__fits_8c.html#a76db1cab8202e48ed93378d68d5e1b0f',1,'s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a6452019812d547dc0de6888e76c9f2db',1,'s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *file, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fwrite_5fmap_88',['s2let_fits_mw_write_map',['../s2let__fits_8c.html#a33e069a17c3116f44eb667a9cba40615',1,'s2let_fits_mw_write_map(char *filename, double *f, int L): s2let_fits.c'],['../s2let__fits_8h.html#ae98dbd904653a070d64f31fa37bfa617',1,'s2let_fits_mw_write_map(char *file, double *f, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fwrite_5fspin_5fmaps_89',['s2let_fits_mw_write_spin_maps',['../s2let__fits_8c.html#a5c22448360290d72a157eb886a3bb23e',1,'s2let_fits_mw_write_spin_maps(char *filename, double *fQ, double *fU, int L): s2let_fits.c'],['../s2let__fits_8h.html#afe7d32ae54ded848bd7a7cb25d4dba93',1,'s2let_fits_mw_write_spin_maps(char *file, double *fQ, double *fU, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmwss_5fread_5fmap_90',['s2let_fits_mwss_read_map',['../s2let__fits_8c.html#a30d6c0469210655e662bbdf8153d3e3f',1,'s2let_fits_mwss_read_map(double *f, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#ad022bd34785d0cc2d5a2b1f924ba26fd',1,'s2let_fits_mwss_read_map(double *f, char *file, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmwss_5fread_5fspin_5fmaps_91',['s2let_fits_mwss_read_spin_maps',['../s2let__fits_8c.html#abf0138418d23fff52dea5dabb8e2a7fa',1,'s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a85a1bcdf0dee2673f2d5ffd374f2bdfd',1,'s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *file, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmwss_5fwrite_5fmap_92',['s2let_fits_mwss_write_map',['../s2let__fits_8c.html#a7b7613e2e45ffa5e2ff4ef51c88039f7',1,'s2let_fits_mwss_write_map(char *filename, double *f, int L): s2let_fits.c'],['../s2let__fits_8h.html#a22e885366d6e8367fd5afe62679ff42f',1,'s2let_fits_mwss_write_map(char *file, double *f, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmwss_5fwrite_5fspin_5fmaps_93',['s2let_fits_mwss_write_spin_maps',['../s2let__fits_8c.html#ac0aa9a648728c543e0a15490e639b7e7',1,'s2let_fits_mwss_write_spin_maps(char *filename, double *fQ, double *fU, int L): s2let_fits.c'],['../s2let__fits_8h.html#abb0ad8df2666842d52b8b6b724d2688f',1,'s2let_fits_mwss_write_spin_maps(char *file, double *fQ, double *fU, int L): s2let_fits.c']]], - ['s2let_5fhelper_2ec_94',['s2let_helper.c',['../s2let__helper_8c.html',1,'']]], - ['s2let_5fhelper_2eh_95',['s2let_helper.h',['../s2let__helper_8h.html',1,'']]], - ['s2let_5fhpx_2ec_96',['s2let_hpx.c',['../s2let__hpx_8c.html',1,'']]], - ['s2let_5fhpx_2eh_97',['s2let_hpx.h',['../s2let__hpx_8h.html',1,'']]], - ['s2let_5fhpx_5fallocate_5freal_98',['s2let_hpx_allocate_real',['../s2let__hpx_8c.html#a5fd3f8d1975ab0798c4797665256083a',1,'s2let_hpx_allocate_real(double **f, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a5fd3f8d1975ab0798c4797665256083a',1,'s2let_hpx_allocate_real(double **f, int nside): s2let_hpx.c']]], - ['s2let_5fhpx_5falm2map_5freal_99',['s2let_hpx_alm2map_real',['../s2let__hpx_8c.html#a3a16f082dbd93ca1413282167eb70b78',1,'s2let_hpx_alm2map_real(double *f, const complex double *flm, int nside, int L): s2let_hpx.c'],['../s2let__hpx_8h.html#adfeed42820bd0d0c686c83b87c091050',1,'s2let_hpx_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int nside, int L): s2let_hpx.h']]], - ['s2let_5fhpx_5falm2map_5fspin_5freal_100',['s2let_hpx_alm2map_spin_real',['../s2let__hpx_8c.html#a628694892c6f91d3e04fef9fccf145d9',1,'s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const complex double *flmE, const complex double *flmB, int nside, int L, int spin): s2let_hpx.c'],['../s2let__hpx_8h.html#aeeb308d10fad6609143c7b88add754c1',1,'s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const S2LET_COMPLEX(double) *flmE, const S2LET_COMPLEX(double) *flmB, int nside, int L, int spin): s2let_hpx.h']]], - ['s2let_5fhpx_5fdemo_2ec_101',['s2let_hpx_demo.c',['../s2let__hpx__demo_8c.html',1,'']]], - ['s2let_5fhpx_5fio_5ftest_102',['s2let_hpx_io_test',['../s2let__hpx__test_8c.html#a38519222c90d787d322f0163273466c6',1,'s2let_hpx_test.c']]], - ['s2let_5fhpx_5fmap2alm_5freal_103',['s2let_hpx_map2alm_real',['../s2let__hpx_8c.html#a78d966279d936b4937553e58b88265f3',1,'s2let_hpx_map2alm_real(complex double *flm, const double *f, int nside, int L): s2let_hpx.c'],['../s2let__hpx_8h.html#addf44689d1620ff08e9e623064a3da0f',1,'s2let_hpx_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int nside, int L): s2let_hpx.h']]], - ['s2let_5fhpx_5fmap2alm_5fspin_5freal_104',['s2let_hpx_map2alm_spin_real',['../s2let__hpx_8c.html#a9183b4967c1e5f8a6c973a1697362e91',1,'s2let_hpx_map2alm_spin_real(complex double *flmE, complex double *flmB, const double *fQ, const double *fU, int nside, int L, int spin): s2let_hpx.c'],['../s2let__hpx_8h.html#aa7a27c83a31e71f1fd90bdf0bbb84a8d',1,'s2let_hpx_map2alm_spin_real(S2LET_COMPLEX(double) *flmE, S2LET_COMPLEX(double) *flmB, const double *fQ, const double *fU, int nside, int L, int spin): s2let_hpx.h']]], - ['s2let_5fhpx_5fread_5fmap_105',['s2let_hpx_read_map',['../s2let__hpx_8c.html#a007bb3a6640667248187f9ac38b9d6a4',1,'s2let_hpx_read_map(double *f, char *file, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a007bb3a6640667248187f9ac38b9d6a4',1,'s2let_hpx_read_map(double *f, char *file, int nside): s2let_hpx.c']]], - ['s2let_5fhpx_5fread_5fmaps_106',['s2let_hpx_read_maps',['../s2let__hpx_8c.html#a5c51e9a1cbae07bee6dede794c93470c',1,'s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps): s2let_hpx.c'],['../s2let__hpx_8h.html#a5c51e9a1cbae07bee6dede794c93470c',1,'s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps): s2let_hpx.c']]], - ['s2let_5fhpx_5fspinalm_5ftest_107',['s2let_hpx_spinalm_test',['../s2let__hpx__test_8c.html#a2d59903931d514b42dadfe993b697712',1,'s2let_hpx_test.c']]], - ['s2let_5fhpx_5ftest_2ec_108',['s2let_hpx_test.c',['../s2let__hpx__test_8c.html',1,'']]], - ['s2let_5fhpx_5fwrite_5fmap_109',['s2let_hpx_write_map',['../s2let__hpx_8c.html#a5f03d8745c5e15c0f03c2546464ec042',1,'s2let_hpx_write_map(char *file, const double *f, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a5f03d8745c5e15c0f03c2546464ec042',1,'s2let_hpx_write_map(char *file, const double *f, int nside): s2let_hpx.c']]], - ['s2let_5fidl_5faxisym_5fhpx_5fwav_5fanalysis_5freal_110',['s2let_idl_axisym_hpx_wav_analysis_real',['../s2let__idl__hpx_8c.html#a8d5e1acca474c541532a3c249a2f3814',1,'s2let_idl_hpx.c']]], - ['s2let_5fidl_5faxisym_5fhpx_5fwav_5fsynthesis_5freal_111',['s2let_idl_axisym_hpx_wav_synthesis_real',['../s2let__idl__hpx_8c.html#a8bbb1aa9b6b3987cd55b6f6d2ac212f5',1,'s2let_idl_hpx.c']]], - ['s2let_5fidl_5fhpx_2ec_112',['s2let_idl_hpx.c',['../s2let__idl__hpx_8c.html',1,'']]], - ['s2let_5fidl_5fhpx_2eh_113',['s2let_idl_hpx.h',['../s2let__idl__hpx_8h.html',1,'']]], - ['s2let_5fidl_5fhpx_5falm2map_5freal_114',['s2let_idl_hpx_alm2map_real',['../s2let__idl__hpx_8c.html#a2405269f6a3905d347497fdd8f8737b2',1,'s2let_idl_hpx_alm2map_real(int argc, void *argv[]): s2let_idl_hpx.c'],['../s2let__idl__hpx_8h.html#a2405269f6a3905d347497fdd8f8737b2',1,'s2let_idl_hpx_alm2map_real(int argc, void *argv[]): s2let_idl_hpx.c']]], - ['s2let_5fidl_5fhpx_5faxisym_5fwav_5fanalysis_5freal_115',['s2let_idl_hpx_axisym_wav_analysis_real',['../s2let__idl__hpx_8h.html#af0b753f2c0d41972ff727e18bbf51490',1,'s2let_idl_hpx.h']]], - ['s2let_5fidl_5fhpx_5faxisym_5fwav_5fsynthesis_5freal_116',['s2let_idl_hpx_axisym_wav_synthesis_real',['../s2let__idl__hpx_8h.html#a780c8d58d24780b54367b2751d456d21',1,'s2let_idl_hpx.h']]], - ['s2let_5fidl_5fhpx_5fmap2alm_5freal_117',['s2let_idl_hpx_map2alm_real',['../s2let__idl__hpx_8c.html#ad34b479c1681a81cc1c707def15d296c',1,'s2let_idl_hpx_map2alm_real(int argc, void *argv[]): s2let_idl_hpx.c'],['../s2let__idl__hpx_8h.html#ad34b479c1681a81cc1c707def15d296c',1,'s2let_idl_hpx_map2alm_real(int argc, void *argv[]): s2let_idl_hpx.c']]], - ['s2let_5fidl_5fmw_2ec_118',['s2let_idl_mw.c',['../s2let__idl__mw_8c.html',1,'']]], - ['s2let_5fidl_5fmw_2eh_119',['s2let_idl_mw.h',['../s2let__idl__mw_8h.html',1,'']]], - ['s2let_5fidl_5fmw_5falm2map_120',['s2let_idl_mw_alm2map',['../s2let__idl__mw_8c.html#a4c2ef5574faf8b82ca91295b1321b5e8',1,'s2let_idl_mw.c']]], - ['s2let_5fidl_5fmw_5falm2map_5freal_121',['s2let_idl_mw_alm2map_real',['../s2let__idl__mw_8c.html#af7a317220109dabfc86d0dd5c4b8987c',1,'s2let_idl_mw.c']]], - ['s2let_5fidl_5fmw_5fmap2alm_122',['s2let_idl_mw_map2alm',['../s2let__idl__mw_8c.html#a2e12cdca9f43efd97ab6a93da615599c',1,'s2let_idl_mw.c']]], - ['s2let_5fidl_5fmw_5fmap2alm_5freal_123',['s2let_idl_mw_map2alm_real',['../s2let__idl__mw_8c.html#ac5974e9a553e5ca74bcf2cedf0faa970',1,'s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5falm2map_124',['s2let_idl_transform_alm2map',['../s2let__idl__mw_8h.html#aee50e78b2a8b7521629d086621d23c60',1,'s2let_idl_mw.h']]], - ['s2let_5fidl_5ftransform_5falm2map_5freal_125',['s2let_idl_transform_alm2map_real',['../s2let__idl__mw_8h.html#aceb297101069e992a356fadfc43820d0',1,'s2let_idl_mw.h']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_126',['s2let_idl_transform_axisym_wav_analysis_mw',['../s2let__idl__mw_8c.html#a7fcf1a787d1d465620d3287703e5ce6c',1,'s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a7fcf1a787d1d465620d3287703e5ce6c',1,'s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_127',['s2let_idl_transform_axisym_wav_analysis_mw_multires',['../s2let__idl__mw_8c.html#a97466a06e494b38c4d60a7f6839a41e3',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a97466a06e494b38c4d60a7f6839a41e3',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_5freal_128',['s2let_idl_transform_axisym_wav_analysis_mw_multires_real',['../s2let__idl__mw_8c.html#ad1712f32e26d77c9b21b7f3bd62f4609',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad1712f32e26d77c9b21b7f3bd62f4609',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5freal_129',['s2let_idl_transform_axisym_wav_analysis_mw_real',['../s2let__idl__mw_8c.html#a168466d81a6d248d0b4280a9687d8172',1,'s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a168466d81a6d248d0b4280a9687d8172',1,'s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_130',['s2let_idl_transform_axisym_wav_synthesis_mw',['../s2let__idl__mw_8c.html#ad3bd4d2483d2716820eb6b0d107cd75b',1,'s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad3bd4d2483d2716820eb6b0d107cd75b',1,'s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_131',['s2let_idl_transform_axisym_wav_synthesis_mw_multires',['../s2let__idl__mw_8c.html#abb8950501cac08ff378bc0dbf172eb73',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#abb8950501cac08ff378bc0dbf172eb73',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_5freal_132',['s2let_idl_transform_axisym_wav_synthesis_mw_multires_real',['../s2let__idl__mw_8c.html#ad0f7dd4ae05137d49d8e35e4e2dd827e',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad0f7dd4ae05137d49d8e35e4e2dd827e',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5freal_133',['s2let_idl_transform_axisym_wav_synthesis_mw_real',['../s2let__idl__mw_8c.html#a61efa315fb01f338ed265b7898c91caa',1,'s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a61efa315fb01f338ed265b7898c91caa',1,'s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5fmap2alm_134',['s2let_idl_transform_map2alm',['../s2let__idl__mw_8h.html#a2653d09d0f6ab88cfb2803505da9fd6b',1,'s2let_idl_mw.h']]], - ['s2let_5fidl_5ftransform_5fmap2alm_5freal_135',['s2let_idl_transform_map2alm_real',['../s2let__idl__mw_8h.html#a8e509c9e23c2225aafdc6e77c6b73c58',1,'s2let_idl_mw.h']]], - ['s2let_5fj_5fmax_136',['s2let_j_max',['../s2let__tiling_8c.html#af8e45477d8b8a0bbd2f0dd706ee29f7e',1,'s2let_j_max(const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#af8e45477d8b8a0bbd2f0dd706ee29f7e',1,'s2let_j_max(const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5fkernel_137',['s2let_kernel',['../s2let__tiling_8c.html#ab2ff4854b8611353b7ba607e99a742f3',1,'s2let_tiling.c']]], - ['s2let_5fkernel_5ftype_138',['s2let_kernel_type',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879a',1,'s2let_tiling.c']]], - ['s2let_5fl0_139',['s2let_L0',['../s2let__tiling_8c.html#a970c83288da0b2f1b0c783dc32da5d58',1,'s2let_L0(int j, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a970c83288da0b2f1b0c783dc32da5d58',1,'s2let_L0(int j, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5flm_2ec_140',['s2let_lm.c',['../s2let__lm_8c.html',1,'']]], - ['s2let_5flm_2eh_141',['s2let_lm.h',['../s2let__lm_8h.html',1,'']]], - ['s2let_5flm_5fpower_142',['s2let_lm_power',['../s2let__lm_8c.html#a520c6e822fd2d004f87b0babf793b93b',1,'s2let_lm_power(complex double *flm, int L): s2let_lm.c'],['../s2let__lm_8h.html#ace994f794328a0338095553fd7e81c2e',1,'s2let_lm_power(S2LET_COMPLEX(double) *flm, int L): s2let_lm.h']]], - ['s2let_5flm_5frandom_5fflm_143',['s2let_lm_random_flm',['../s2let__lm_8c.html#aecdba2ebff470192c677d787331440da',1,'s2let_lm_random_flm(complex double *flm, int L, int spin, int seed): s2let_lm.c'],['../s2let__lm_8h.html#aa1cf89a60a2c297ed93525c7abd36d82',1,'s2let_lm_random_flm(S2LET_COMPLEX(double) *flm, int L, int spin, int seed): s2let_lm.h']]], - ['s2let_5flm_5frandom_5fflm_5freal_144',['s2let_lm_random_flm_real',['../s2let__lm_8c.html#a976ccda30f8c30bfbcd238242deef100',1,'s2let_lm_random_flm_real(complex double *flm, int L, int seed): s2let_lm.c'],['../s2let__lm_8h.html#a52b1d6d06e4ac3b5d386b6a9a9f5d9d1',1,'s2let_lm_random_flm_real(S2LET_COMPLEX(double) *flm, int L, int seed): s2let_lm.h']]], - ['s2let_5flm_5frandom_5fflm_5freal_5fsigma_145',['s2let_lm_random_flm_real_sigma',['../s2let__axisym__denoising__demo_8c.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8c.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_denoising_demo.c'],['../s2let__axisym__denoising__demo_8h.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8h.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c']]], - ['s2let_5flm_5frandom_5fflm_5fsigma_146',['s2let_lm_random_flm_sigma',['../s2let__spin__denoising__demo_8c.html#a8f2d6d26977c37558bd348037fac075f',1,'s2let_spin_denoising_demo.c']]], - ['s2let_5fmath_2ec_147',['s2let_math.c',['../s2let__math_8c.html',1,'']]], - ['s2let_5fmath_2eh_148',['s2let_math.h',['../s2let__math_8h.html',1,'']]], - ['s2let_5fmath_5fkappa0_5fquadtrap_5fneedlet_149',['s2let_math_kappa0_quadtrap_needlet',['../s2let__math_8c.html#a1ee31db982694aeff4308288cb38e044',1,'s2let_math_kappa0_quadtrap_needlet(double a, double b, int n): s2let_math.c'],['../s2let__math_8h.html#a1ee31db982694aeff4308288cb38e044',1,'s2let_math_kappa0_quadtrap_needlet(double a, double b, int n): s2let_math.c']]], - ['s2let_5fmath_5fkappa0_5fquadtrap_5fs2dw_150',['s2let_math_kappa0_quadtrap_s2dw',['../s2let__math_8c.html#a44eb4f6042bf9dd406b3da22eca7e434',1,'s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B): s2let_math.c'],['../s2let__math_8h.html#a44eb4f6042bf9dd406b3da22eca7e434',1,'s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B): s2let_math.c']]], - ['s2let_5fmath_5fspline_5fscalingfct_151',['s2let_math_spline_scalingfct',['../s2let__math_8c.html#a5a6d036165ebcd79b2c4f5716a42bcd8',1,'s2let_math_spline_scalingfct(double x, double y): s2let_math.c'],['../s2let__math_8h.html#a5a6d036165ebcd79b2c4f5716a42bcd8',1,'s2let_math_spline_scalingfct(double x, double y): s2let_math.c']]], - ['s2let_5fmex_2eh_152',['s2let_mex.h',['../s2let__mex_8h.html',1,'']]], - ['s2let_5fmw_2ec_153',['s2let_mw.c',['../s2let__mw_8c.html',1,'']]], - ['s2let_5fmw_2eh_154',['s2let_mw.h',['../s2let__mw_8h.html',1,'']]], - ['s2let_5fmw_5falm2map_155',['s2let_mw_alm2map',['../s2let__mw_8c.html#a71a1d94b45021758562acb54f7efbadc',1,'s2let_mw_alm2map(complex double *f, const complex double *flm, int L, int spin): s2let_mw.c'],['../s2let__mw_8h.html#adbfa150db5b9bcca2993df5e14cb05b9',1,'s2let_mw_alm2map(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *flm, int L, int spin): s2let_mw.h']]], - ['s2let_5fmw_5falm2map_5freal_156',['s2let_mw_alm2map_real',['../s2let__mw_8c.html#acec65039b721a60d622aa6ccdc57fe58',1,'s2let_mw_alm2map_real(double *f, const complex double *flm, int L): s2let_mw.c'],['../s2let__mw_8h.html#a845b320975dc03e952f28c539da9d426',1,'s2let_mw_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int L): s2let_mw.h']]], - ['s2let_5fmw_5fio_5fspin_5ftest_157',['s2let_mw_io_spin_test',['../s2let__hpx__test_8c.html#a2cb09cab436803d8581b6b96959dff9e',1,'s2let_hpx_test.c']]], - ['s2let_5fmw_5fio_5ftest_158',['s2let_mw_io_test',['../s2let__hpx__test_8c.html#af91cc34a400e0f94e570728ac6f6c759',1,'s2let_hpx_test.c']]], - ['s2let_5fmw_5fmap2alm_159',['s2let_mw_map2alm',['../s2let__mw_8c.html#ae2d95be7cf71bfe84060dbdd77c6947b',1,'s2let_mw_map2alm(complex double *flm, const complex double *f, int L, int spin): s2let_mw.c'],['../s2let__mw_8h.html#a727851e328422320a31ef6548631e0dd',1,'s2let_mw_map2alm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f, int L, int spin): s2let_mw.h']]], - ['s2let_5fmw_5fmap2alm_5freal_160',['s2let_mw_map2alm_real',['../s2let__mw_8c.html#adee030c15f2b401361c278a6c6ea6f7c',1,'s2let_mw_map2alm_real(complex double *flm, const double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#a297725ba5e35713e59c0b601a6964942',1,'s2let_mw_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int L): s2let_mw.h']]], - ['s2let_5fmw_5fpower_161',['s2let_mw_power',['../s2let__mw_8c.html#a91dbb4ab1556928322986d21d413abdf',1,'s2let_mw_power(complex double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#aceb97384257965caeb908162dae89009',1,'s2let_mw_power(S2LET_COMPLEX(double) *flm, int L): s2let_mw.h']]], - ['s2let_5fmw_5fpower_5freal_162',['s2let_mw_power_real',['../s2let__mw_8c.html#a3520764bba2023b957373df5769f25e8',1,'s2let_mw_power_real(double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#aa3c531ec00960d928d8d7fca2f6a3108',1,'s2let_mw_power_real(double *flm, int L): s2let_mw.c']]], - ['s2let_5fn_5fgamma_163',['s2let_n_gamma',['../s2let__helper_8c.html#a33cd356d3eca688b51e0a70cc216b3c6',1,'s2let_n_gamma(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a33cd356d3eca688b51e0a70cc216b3c6',1,'s2let_n_gamma(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5flm_164',['s2let_n_lm',['../s2let__helper_8c.html#a31cd45045fa530a8b67db235da15d29f',1,'s2let_n_lm(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a31cd45045fa530a8b67db235da15d29f',1,'s2let_n_lm(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5flm_5fscal_165',['s2let_n_lm_scal',['../s2let__helper_8c.html#aaf6daa1bc9b68e76a247860c57a9e8b9',1,'s2let_n_lm_scal(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aaf6daa1bc9b68e76a247860c57a9e8b9',1,'s2let_n_lm_scal(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5flmn_5fwav_166',['s2let_n_lmn_wav',['../s2let__helper_8c.html#a8db8dd8265358a8501a40fe77c4ab908',1,'s2let_n_lmn_wav(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a8db8dd8265358a8501a40fe77c4ab908',1,'s2let_n_lmn_wav(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fphi_167',['s2let_n_phi',['../s2let__helper_8c.html#aca44ba24618888aa56773d0fa662bb87',1,'s2let_n_phi(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aca44ba24618888aa56773d0fa662bb87',1,'s2let_n_phi(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fpx_168',['s2let_n_px',['../s2let__helper_8c.html#a8de2596044e8dbd481d0d86e1ad8bd44',1,'s2let_n_px(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a8de2596044e8dbd481d0d86e1ad8bd44',1,'s2let_n_px(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fscal_169',['s2let_n_scal',['../s2let__helper_8c.html#a94202177168781d62964cfb09b568d77',1,'s2let_n_scal(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a94202177168781d62964cfb09b568d77',1,'s2let_n_scal(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5ftheta_170',['s2let_n_theta',['../s2let__helper_8c.html#a93ae2fb9184ae2bb35200063113b3db8',1,'s2let_n_theta(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a93ae2fb9184ae2bb35200063113b3db8',1,'s2let_n_theta(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fwav_171',['s2let_n_wav',['../s2let__helper_8c.html#aa267d575405f5aec34f642d7278ea15c',1,'s2let_n_wav(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aa267d575405f5aec34f642d7278ea15c',1,'s2let_n_wav(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fwav_5fj_172',['s2let_n_wav_j',['../s2let__helper_8c.html#a5489f45f63977ad580729370eeabd3c8',1,'s2let_n_wav_j(int j, const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a5489f45f63977ad580729370eeabd3c8',1,'s2let_n_wav_j(int j, const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fparameters_5ft_173',['s2let_parameters_t',['../structs2let__parameters__t.html',1,'']]], - ['s2let_5fsampling_5fmw_174',['S2LET_SAMPLING_MW',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea061a427ab87d0615aeea0bbc9ef5a8bc',1,'s2let_types.h']]], - ['s2let_5fsampling_5fmw_5fss_175',['S2LET_SAMPLING_MW_SS',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea4735249ce28fc1c5b443806760f8fcd8',1,'s2let_types.h']]], - ['s2let_5fsampling_5fmw_5fss_5fstr_176',['S2LET_SAMPLING_MW_SS_STR',['../s2let__mex_8h.html#aef877ec016bc062e71412e295efbe843',1,'s2let_mex.h']]], - ['s2let_5fsampling_5fmw_5fstr_177',['S2LET_SAMPLING_MW_STR',['../s2let__mex_8h.html#a965fb52ef2d665d3443bd08e8ec47548',1,'s2let_mex.h']]], - ['s2let_5fsampling_5fsize_178',['S2LET_SAMPLING_SIZE',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea1eb522fb952502e38119d2a315cce842',1,'s2let_types.h']]], - ['s2let_5fsampling_5ft_179',['s2let_sampling_t',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001e',1,'s2let_types.h']]], - ['s2let_5fso3_2eh_180',['s2let_so3.h',['../s2let__so3_8h.html',1,'']]], - ['s2let_5fso3_5fn_5forder_181',['S2LET_SO3_N_ORDER',['../s2let__so3_8h.html#a0c50a5de20f171c266985a92764153b3',1,'s2let_so3.h']]], - ['s2let_5fso3_5fstorage_182',['S2LET_SO3_STORAGE',['../s2let__so3_8h.html#a234c5518a86c602ca220a16b33dc2e22',1,'s2let_so3.h']]], - ['s2let_5fspin_5fdenoising_5fdemo_2ec_183',['s2let_spin_denoising_demo.c',['../s2let__spin__denoising__demo_8c.html',1,'']]], - ['s2let_5fstring_5flen_184',['S2LET_STRING_LEN',['../s2let__mex_8h.html#a3bd7f5fbd27ea58ab3a23a1eb7a6f4cd',1,'s2let_mex.h']]], - ['s2let_5fswitch_5fwavtype_185',['s2let_switch_wavtype',['../s2let__tiling_8c.html#a740dd43f4aeae426b96bd4488881297c',1,'s2let_switch_wavtype(int typenum): s2let_tiling.c'],['../s2let__tiling_8h.html#a740dd43f4aeae426b96bd4488881297c',1,'s2let_switch_wavtype(int typenum): s2let_tiling.c']]], - ['s2let_5fsynthesis_2ec_186',['s2let_synthesis.c',['../s2let__synthesis_8c.html',1,'']]], - ['s2let_5fsynthesis_2eh_187',['s2let_synthesis.h',['../s2let__synthesis_8h.html',1,'']]], - ['s2let_5fsynthesis_5fadjoint_2ec_188',['s2let_synthesis_adjoint.c',['../s2let__synthesis__adjoint_8c.html',1,'']]], - ['s2let_5fsynthesis_5fadjoint_2eh_189',['s2let_synthesis_adjoint.h',['../s2let__synthesis__adjoint_8h.html',1,'']]], - ['s2let_5fsynthesis_5fadjoint_5flm2lmn_190',['s2let_synthesis_adjoint_lm2lmn',['../s2let__synthesis__adjoint_8c.html#aa22074c5b8f3c6f93101bda21dd41477',1,'s2let_synthesis_adjoint_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#ab2e27bf29fd328e5737010a8e965a392',1,'s2let_synthesis_adjoint_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5flm2lmn_5freal_191',['s2let_synthesis_adjoint_lm2lmn_real',['../s2let__synthesis__adjoint_8c.html#a3b3ba86b4c6ccbea501743a31f0fbaba',1,'s2let_synthesis_adjoint_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a8f619d5750ea69d11f5a8a72e7789c5c',1,'s2let_synthesis_adjoint_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5flm2wav_192',['s2let_synthesis_adjoint_lm2wav',['../s2let__synthesis__adjoint_8c.html#a0ded78fd254dfcf523607af9d6384b04',1,'s2let_synthesis_adjoint_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a076501801b028f2c5a43b703afc55746',1,'s2let_synthesis_adjoint_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5flm2wav_5fmanual_193',['s2let_synthesis_adjoint_lm2wav_manual',['../s2let__synthesis__adjoint_8c.html#af1ad88c078072d2c2f9262ab60664627',1,'s2let_synthesis_adjoint_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a80993ff9162a6694085cad936b366c66',1,'s2let_synthesis_adjoint_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5flm2wav_5freal_194',['s2let_synthesis_adjoint_lm2wav_real',['../s2let__synthesis__adjoint_8c.html#a3d89c7c0fd47c34293d0c915e8680212',1,'s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a3ca845d22e3f872b584ba8078eebdf2c',1,'s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5fpx2wav_195',['s2let_synthesis_adjoint_px2wav',['../s2let__synthesis__adjoint_8c.html#af92b8ee7a5d7467aca1aadf574101ed1',1,'s2let_synthesis_adjoint_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#acb574fe4af36dac2771e323b23f038f5',1,'s2let_synthesis_adjoint_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5fpx2wav_5freal_196',['s2let_synthesis_adjoint_px2wav_real',['../s2let__synthesis__adjoint_8c.html#a8ac56364e5e11e70afdc89dcbdfa5e54',1,'s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a8ac56364e5e11e70afdc89dcbdfa5e54',1,'s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c']]], - ['s2let_5fsynthesis_5flmn2lm_197',['s2let_synthesis_lmn2lm',['../s2let__synthesis_8c.html#aeab2e51756b722c7fcb0246fa7bcf4e8',1,'s2let_synthesis_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a07acb11aa82e55efc3af49548de2c595',1,'s2let_synthesis_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5flmn2lm_5freal_198',['s2let_synthesis_lmn2lm_real',['../s2let__synthesis_8c.html#ae985651ea8c8225166983b660e15648e',1,'s2let_synthesis_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#adfeebcfa8d5032b78dd85634a5c32b1e',1,'s2let_synthesis_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2lm_199',['s2let_synthesis_wav2lm',['../s2let__synthesis_8c.html#ad898b41a0d83f31033c87f43339dccc2',1,'s2let_synthesis_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a69a72f4cf574108a313f7320b093beee',1,'s2let_synthesis_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2lm_5fmanual_200',['s2let_synthesis_wav2lm_manual',['../s2let__synthesis_8c.html#ae32a0ec051091cb18844e51d8d0ad7fd',1,'s2let_synthesis_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis.c'],['../s2let__synthesis_8h.html#ad3cd8f875820fc345277f57957f6ad40',1,'s2let_synthesis_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2lm_5freal_201',['s2let_synthesis_wav2lm_real',['../s2let__synthesis_8c.html#ab4592958d2f658ac6711edb3589a0d04',1,'s2let_synthesis_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a21c5e68bb92ff9cb6d50a2fd19213a2e',1,'s2let_synthesis_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2px_202',['s2let_synthesis_wav2px',['../s2let__synthesis_8c.html#a171869de60c6dba907994e24eb1ad568',1,'s2let_synthesis_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#aa051be81ee272ce0291f78b66170c5db',1,'s2let_synthesis_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2px_5freal_203',['s2let_synthesis_wav2px_real',['../s2let__synthesis_8c.html#a4ef1adffb439379ca652533588879ab5',1,'s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a4ef1adffb439379ca652533588879ab5',1,'s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c']]], - ['s2let_5ftest_2ec_204',['s2let_test.c',['../s2let__test_8c.html',1,'']]], - ['s2let_5ftest_5fcsv_2ec_205',['s2let_test_csv.c',['../s2let__test__csv_8c.html',1,'']]], - ['s2let_5ftiling_2ec_206',['s2let_tiling.c',['../s2let__tiling_8c.html',1,'']]], - ['s2let_5ftiling_2eh_207',['s2let_tiling.h',['../s2let__tiling_8h.html',1,'']]], - ['s2let_5ftiling_5faxisym_208',['s2let_tiling_axisym',['../s2let__tiling_8c.html#a2dcc3541cd5003f7c20189b5f1e569b0',1,'s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a2dcc3541cd5003f7c20189b5f1e569b0',1,'s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5ftiling_5faxisym_5fallocate_209',['s2let_tiling_axisym_allocate',['../s2let__tiling_8c.html#acfff04a4e1d0f2c422b2c0a22a01c9a9',1,'s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#acfff04a4e1d0f2c422b2c0a22a01c9a9',1,'s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5ftiling_5faxisym_5fcheck_5fidentity_210',['s2let_tiling_axisym_check_identity',['../s2let__tiling_8c.html#a895b0a2aed140ef5591af7ac630d6113',1,'s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a895b0a2aed140ef5591af7ac630d6113',1,'s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5ftiling_5faxisym_5ftest_211',['s2let_tiling_axisym_test',['../s2let__test_8c.html#a72ed78cf85c9437d0a2545c8e3a61cf2',1,'s2let_test.c']]], - ['s2let_5ftiling_5fdirection_212',['s2let_tiling_direction',['../s2let__tiling_8c.html#a4811cf4eadbebb73245f54b676734b17',1,'s2let_tiling_direction(complex double *s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ae2b1be4ee6ee593ccc3673bb8c8119a0',1,'s2let_tiling_direction(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fdirection_5fallocate_213',['s2let_tiling_direction_allocate',['../s2let__tiling_8c.html#a10fa29a59b170d6ade97303878faf7ef',1,'s2let_tiling_direction_allocate(complex double **s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a14a6f342214def49e0a4007425a85885',1,'s2let_tiling_direction_allocate(S2LET_COMPLEX(double) **s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fdirection_5fcheck_5fidentity_214',['s2let_tiling_direction_check_identity',['../s2let__tiling_8c.html#ab69e82a484169f248873ae9ccb5bb89a',1,'s2let_tiling_direction_check_identity(complex double *s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a57fea5748d955b5caa9ddf46cda3036b',1,'s2let_tiling_direction_check_identity(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fdirection_5ftest_215',['s2let_tiling_direction_test',['../s2let__test_8c.html#a84ab4ae94142563376cc58ce9b3f0529',1,'s2let_test.c']]], - ['s2let_5ftiling_5fphi2_5fneedlet_216',['s2let_tiling_phi2_needlet',['../s2let__tiling_8c.html#aa9f045a72ccf0df8bff4a8a245ecc52a',1,'s2let_tiling.c']]], - ['s2let_5ftiling_5fphi2_5fs2dw_217',['s2let_tiling_phi2_s2dw',['../s2let__tiling_8c.html#a255c8db4bb8f33e546d44e2b96fd4eb5',1,'s2let_tiling.c']]], - ['s2let_5ftiling_5fphi2_5fspline_218',['s2let_tiling_phi2_spline',['../s2let__tiling_8c.html#afd4de938c00ee3cbde3e6e10944a496b',1,'s2let_tiling.c']]], - ['s2let_5ftiling_5fwavelet_219',['s2let_tiling_wavelet',['../s2let__tiling_8c.html#a9878fae074371b64e7de24ebfdbd752c',1,'s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ae0e09c45e6d87dee84f94bb04b6215d8',1,'s2let_tiling_wavelet(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fwavelet_5fallocate_220',['s2let_tiling_wavelet_allocate',['../s2let__tiling_8c.html#af1770bfbe7ff5ead2769089867a03fbb',1,'s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#af5491812d40095dfbab3c08edf4d9fa5',1,'s2let_tiling_wavelet_allocate(S2LET_COMPLEX(double) **psi, double **phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fwavelet_5fcheck_5fidentity_221',['s2let_tiling_wavelet_check_identity',['../s2let__tiling_8c.html#abd52d0b819985f55fe6fca8259597b48',1,'s2let_tiling_wavelet_check_identity(complex double *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a9a4117a039022f6fff78939c4e0f3a86',1,'s2let_tiling_wavelet_check_identity(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fwavelet_5ftest_222',['s2let_tiling_wavelet_test',['../s2let__test_8c.html#ad612b1930b2a90f6bb8b507f6dc2ae4d',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fhpx_5ff_5fwav_5freal_223',['s2let_transform_axisym_allocate_hpx_f_wav_real',['../s2let__transform__axisym__hpx_8c.html#a8d0f962069938cdf19c4ad1cce2862f8',1,'s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#a8d0f962069938cdf19c4ad1cce2862f8',1,'s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_224',['s2let_transform_axisym_allocate_mw_f_wav',['../s2let__transform__axisym__mw_8c.html#abdb0070e4e2f67007c6755020cbf3f76',1,'s2let_transform_axisym_allocate_mw_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aa0ce4a50c9b076757a1360030dc00c9e',1,'s2let_transform_axisym_allocate_mw_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5fmultires_225',['s2let_transform_axisym_allocate_mw_f_wav_multires',['../s2let__transform__axisym__mw_8c.html#a34f35be55f0d7920e66ffa96948b7132',1,'s2let_transform_axisym_allocate_mw_f_wav_multires(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a0c9e93d33296d57f7722d91288606268',1,'s2let_transform_axisym_allocate_mw_f_wav_multires(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5fmultires_5freal_226',['s2let_transform_axisym_allocate_mw_f_wav_multires_real',['../s2let__transform__axisym__mw_8c.html#aaf2dc03fea7d12bf85c36ecb827c67f1',1,'s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aaf2dc03fea7d12bf85c36ecb827c67f1',1,'s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5freal_227',['s2let_transform_axisym_allocate_mw_f_wav_real',['../s2let__transform__axisym__mw_8c.html#a71d7ea7def45be0508e37eb4789a42be',1,'s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a71d7ea7def45be0508e37eb4789a42be',1,'s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fanalysis_5fhpx_5freal_2ec_228',['s2let_transform_axisym_analysis_hpx_real.c',['../s2let__transform__axisym__analysis__hpx__real_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fanalysis_5fmw_5freal_2ec_229',['s2let_transform_axisym_analysis_mw_real.c',['../s2let__transform__axisym__analysis__mw__real_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fhpx_2ec_230',['s2let_transform_axisym_hpx.c',['../s2let__transform__axisym__hpx_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fhpx_2eh_231',['s2let_transform_axisym_hpx.h',['../s2let__transform__axisym__hpx_8h.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fhpx_5ftest_232',['s2let_transform_axisym_hpx_test',['../s2let__hpx__test_8c.html#a967b49df6d8f162875b8fd691fc5673e',1,'s2let_hpx_test.c']]], - ['s2let_5ftransform_5faxisym_5fhpx_5fwav_5ftest_233',['s2let_transform_axisym_hpx_wav_test',['../s2let__hpx__test_8c.html#ae0c6235281f47c3580a082a8ff6442a0',1,'s2let_hpx_test.c']]], - ['s2let_5ftransform_5faxisym_5flm_2ec_234',['s2let_transform_axisym_lm.c',['../s2let__transform__axisym__lm_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5flm_2eh_235',['s2let_transform_axisym_lm.h',['../s2let__transform__axisym__lm_8h.html',1,'']]], - ['s2let_5ftransform_5faxisym_5flm_5fallocate_5ff_5fwav_236',['s2let_transform_axisym_lm_allocate_f_wav',['../s2let__transform__axisym__lm_8c.html#a27717c57665b77ad3f6f5aef35c1c9e4',1,'s2let_transform_axisym_lm_allocate_f_wav(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a6ed8eae362ffc710e4f256f4a2c7a59c',1,'s2let_transform_axisym_lm_allocate_f_wav(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fallocate_5ff_5fwav_5fmultires_237',['s2let_transform_axisym_lm_allocate_f_wav_multires',['../s2let__transform__axisym__lm_8c.html#a53fc1d52b6e959e2d2a23319237c9087',1,'s2let_transform_axisym_lm_allocate_f_wav_multires(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a49deaad455c0f37f085794a95bc2cc8f',1,'s2let_transform_axisym_lm_allocate_f_wav_multires(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fallocate_5fwav_238',['s2let_transform_axisym_lm_allocate_wav',['../s2let__transform__axisym__lm_8c.html#ae5c57282bb1116eababa279c2f8757a9',1,'s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#ae5c57282bb1116eababa279c2f8757a9',1,'s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_239',['s2let_transform_axisym_lm_wav',['../s2let__transform__axisym__lm_8c.html#a2efd3fe3938b0f6cb3166804f0ca62bc',1,'s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a2efd3fe3938b0f6cb3166804f0ca62bc',1,'s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fanalysis_240',['s2let_transform_axisym_lm_wav_analysis',['../s2let__transform__axisym__lm_8c.html#a1363fa22f22fe3faf9601fc4d8dc2185',1,'s2let_transform_axisym_lm_wav_analysis(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#ac7bd36f0e12ae8e06d7f1e8c4c0c1f9e',1,'s2let_transform_axisym_lm_wav_analysis(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fanalysis_5fmultires_241',['s2let_transform_axisym_lm_wav_analysis_multires',['../s2let__transform__axisym__lm_8c.html#ac55ab672138aa0703ba3b3d24a6673c0',1,'s2let_transform_axisym_lm_wav_analysis_multires(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a41cd8c62327019175b700208d2891464',1,'s2let_transform_axisym_lm_wav_analysis_multires(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fmultires_5ftest_242',['s2let_transform_axisym_lm_wav_multires_test',['../s2let__test_8c.html#a6490580b66410b64846b31124ae5a0f4',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fsynthesis_243',['s2let_transform_axisym_lm_wav_synthesis',['../s2let__transform__axisym__lm_8c.html#a288f88b4dd18d732a0d6819c4d06e3f4',1,'s2let_transform_axisym_lm_wav_synthesis(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#acaad9856b9ff5ea5588fff2a796a8ecf',1,'s2let_transform_axisym_lm_wav_synthesis(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fsynthesis_5fmultires_244',['s2let_transform_axisym_lm_wav_synthesis_multires',['../s2let__transform__axisym__lm_8c.html#ad31585dbae5edde3fc3704a59cbe1034',1,'s2let_transform_axisym_lm_wav_synthesis_multires(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a1cf1b759d1947fea4f100a80d8a420aa',1,'s2let_transform_axisym_lm_wav_synthesis_multires(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5ftest_245',['s2let_transform_axisym_lm_wav_test',['../s2let__test_8c.html#a21e0d56f5074c798cb77ee9ccf081e3c',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fmw_2ec_246',['s2let_transform_axisym_mw.c',['../s2let__transform__axisym__mw_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fmw_2eh_247',['s2let_transform_axisym_mw.h',['../s2let__transform__axisym__mw_8h.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fsynthesis_5fhpx_5freal_2ec_248',['s2let_transform_axisym_synthesis_hpx_real.c',['../s2let__transform__axisym__synthesis__hpx__real_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fsynthesis_5fmw_5freal_2ec_249',['s2let_transform_axisym_synthesis_mw_real.c',['../s2let__transform__axisym__synthesis__mw__real_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5fmultires_5ftest_250',['s2let_transform_axisym_vs_directional_mw_multires_test',['../s2let__test_8c.html#a4942f2f69c0519399f61579dc47d98d2',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5ftest_251',['s2let_transform_axisym_vs_directional_mw_test',['../s2let__test_8c.html#a45c632c898e73d473bcc38e492847182',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_252',['s2let_transform_axisym_wav_analysis_adjoint_mw',['../s2let__transform__axisym__mw_8c.html#a73b9085432c8673c6fde059b708dea46',1,'s2let_transform_axisym_wav_analysis_adjoint_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#afca147888501702b34ca4e1767c78710',1,'s2let_transform_axisym_wav_analysis_adjoint_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5fmultires_253',['s2let_transform_axisym_wav_analysis_adjoint_mw_multires',['../s2let__transform__axisym__mw_8c.html#abbbb0b8729b4b4d936723f57fa133bde',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a516ee27f27eb79de7c3214cab7271779',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5fmultires_5freal_254',['s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#ad16f124ef82ba5422107d53991578e2b',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ad16f124ef82ba5422107d53991578e2b',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5freal_255',['s2let_transform_axisym_wav_analysis_adjoint_mw_real',['../s2let__transform__axisym__mw_8c.html#a9d190e3dc17c1e73036fa7def51baf44',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a9d190e3dc17c1e73036fa7def51baf44',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fhpx_5freal_256',['s2let_transform_axisym_wav_analysis_hpx_real',['../s2let__transform__axisym__hpx_8c.html#a3f69c1366658007590fc63877230d1a7',1,'s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#a3f69c1366658007590fc63877230d1a7',1,'s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_257',['s2let_transform_axisym_wav_analysis_mw',['../s2let__transform__axisym__mw_8c.html#a866080c7ca98673e75acaf8f384ea936',1,'s2let_transform_axisym_wav_analysis_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ac768b473723b5e525c959deb48e08825',1,'s2let_transform_axisym_wav_analysis_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_258',['s2let_transform_axisym_wav_analysis_mw_multires',['../s2let__transform__axisym__mw_8c.html#a272edc957f57772f4af7161c4776f118',1,'s2let_transform_axisym_wav_analysis_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aec92f0a5f1bf3d14ed9dcdadd96153c3',1,'s2let_transform_axisym_wav_analysis_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_5freal_259',['s2let_transform_axisym_wav_analysis_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#abbaca141c3699c766e341c5ceee14cdb',1,'s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abbaca141c3699c766e341c5ceee14cdb',1,'s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5freal_260',['s2let_transform_axisym_wav_analysis_mw_real',['../s2let__transform__axisym__mw_8c.html#abab7d46ecc4813503ab0fd5f09d8bfa7',1,'s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abab7d46ecc4813503ab0fd5f09d8bfa7',1,'s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fhardthreshold_5fmultires_5freal_261',['s2let_transform_axisym_wav_hardthreshold_multires_real',['../s2let__transform__axisym__mw_8c.html#ab3b3272365c739034b2c5c8fc00613a9',1,'s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ab3b3272365c739034b2c5c8fc00613a9',1,'s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fhardthreshold_5freal_262',['s2let_transform_axisym_wav_hardthreshold_real',['../s2let__transform__axisym__mw_8c.html#af2f861872a0b6640d8e24202a451272f',1,'s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#af2f861872a0b6640d8e24202a451272f',1,'s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fmultires_5freal_5ftest_263',['s2let_transform_axisym_wav_multires_real_test',['../s2let__test_8c.html#a30b6b4ec19a7bc9c3bb7fb3b933e6c94',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fmultires_5ftest_264',['s2let_transform_axisym_wav_multires_test',['../s2let__test_8c.html#ac20052515fa751c919b54fb6bfb7b5a1',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5freal_5ftest_265',['s2let_transform_axisym_wav_real_test',['../s2let__test_8c.html#a42ef36d238046edb1b4a03e2269797f2',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_266',['s2let_transform_axisym_wav_synthesis_adjoint_mw',['../s2let__transform__axisym__mw_8c.html#a333120eb88ad818a3e360c1004c3d1e8',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a595657bb4bf8ac9d99afe415539eff8e',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5fmultires_267',['s2let_transform_axisym_wav_synthesis_adjoint_mw_multires',['../s2let__transform__axisym__mw_8c.html#a9d4cb0b9b608e1956058899cfba58280',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ac2b1764294b14d89aad77c8473d70e92',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5fmultires_5freal_268',['s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#abcfc455a2b4dfd52f52d095227ff67c3',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abcfc455a2b4dfd52f52d095227ff67c3',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_269',['s2let_transform_axisym_wav_synthesis_adjoint_mw_real',['../s2let__transform__axisym__mw_8c.html#a202737e2b30d90af7984051d82e6b55a',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a202737e2b30d90af7984051d82e6b55a',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fhpx_5freal_270',['s2let_transform_axisym_wav_synthesis_hpx_real',['../s2let__transform__axisym__hpx_8c.html#ad1987cd08f8add08bba681aa26c32b77',1,'s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#ad1987cd08f8add08bba681aa26c32b77',1,'s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_271',['s2let_transform_axisym_wav_synthesis_mw',['../s2let__transform__axisym__mw_8c.html#ab2dba22615138e520985ca58ead38e28',1,'s2let_transform_axisym_wav_synthesis_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a26507106a70d5143e76fba3bb298f7e7',1,'s2let_transform_axisym_wav_synthesis_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_272',['s2let_transform_axisym_wav_synthesis_mw_multires',['../s2let__transform__axisym__mw_8c.html#a002718ed6a64a6d7268626e01931ecba',1,'s2let_transform_axisym_wav_synthesis_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a988074918fff2d3f06b6898542ba1072',1,'s2let_transform_axisym_wav_synthesis_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_5freal_273',['s2let_transform_axisym_wav_synthesis_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#a9a77993fec7b5b26a0290ade7623c1ea',1,'s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a9a77993fec7b5b26a0290ade7623c1ea',1,'s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5freal_274',['s2let_transform_axisym_wav_synthesis_mw_real',['../s2let__transform__axisym__mw_8c.html#a5eec6f7cb23d0ffb408abc583153d496',1,'s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a5eec6f7cb23d0ffb408abc583153d496',1,'s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5ftest_275',['s2let_transform_axisym_wav_test',['../s2let__test_8c.html#a4f77ce64b0ecb6acdfeb8cd03b5b4d19',1,'s2let_test.c']]], - ['s2let_5ftransform_5flm_5fperformance_5fmultires_5ftest_276',['s2let_transform_lm_performance_multires_test',['../s2let__test_8c.html#a601830de99f48906fcfe6b53907bb190',1,'s2let_test.c']]], - ['s2let_5ftransform_5flm_5fperformance_5ftest_277',['s2let_transform_lm_performance_test',['../s2let__test_8c.html#a677d7f0b1315a8f13a3ecd057a928372',1,'s2let_test.c']]], - ['s2let_5ftransform_5fperformance_5fmultires_5ftest_278',['s2let_transform_performance_multires_test',['../s2let__test_8c.html#a6707d377e1f45cf08f165f35f9b4f4cc',1,'s2let_test.c']]], - ['s2let_5ftransform_5fperformance_5ftest_279',['s2let_transform_performance_test',['../s2let__test_8c.html#abf6416ad05d8f169fc6eadb5a9ad537d',1,'s2let_test.c']]], - ['s2let_5ftypes_2eh_280',['s2let_types.h',['../s2let__types_8h.html',1,'']]], - ['s2let_5fwav_5fanalysis_5fadjoint_5flm_5flmn_5ftest_281',['s2let_wav_analysis_adjoint_lm_lmn_test',['../s2let__test_8c.html#afc35303ba9eb6beeee088d9f08c3444c',1,'s2let_test.c']]], - ['s2let_5fwav_5fanalysis_5fadjoint_5fmw_5freal_5ftest_282',['s2let_wav_analysis_adjoint_mw_real_test',['../s2let__test_8c.html#a07e8d14353d7a404098560c1a9db92fe',1,'s2let_test.c']]], - ['s2let_5fwav_5fanalysis_5fadjoint_5fmw_5ftest_283',['s2let_wav_analysis_adjoint_mw_test',['../s2let__test_8c.html#a4b3a9612e87e483e27bff0888bd964a0',1,'s2let_test.c']]], - ['s2let_5fwav_5fso3_5fforward_5fadjoint_5ftest_284',['s2let_wav_so3_forward_adjoint_test',['../s2let__test_8c.html#ac85f518078a76b2dd77de9ccc9f34f07',1,'s2let_test.c']]], - ['s2let_5fwav_5fsynthesis_5fadjoint_5flm2wav_5ftest_285',['s2let_wav_synthesis_adjoint_lm2wav_test',['../s2let__test_8c.html#ae9c1885807e8ac48440a0b0d3dd2a667',1,'s2let_test.c']]], - ['s2let_5fwav_5fsynthesis_5fadjoint_5flm_5flmn_5ftest_286',['s2let_wav_synthesis_adjoint_lm_lmn_test',['../s2let__test_8c.html#a33ed7d71c1e2543ab0ec5d5034a0269f',1,'s2let_test.c']]], - ['s2let_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_5ftest_287',['s2let_wav_synthesis_adjoint_mw_real_test',['../s2let__test_8c.html#a5185ca4b0f65740ab88242cff55b796d',1,'s2let_test.c']]], - ['s2let_5fwav_5fsynthesis_5fadjoint_5fmw_5ftest_288',['s2let_wav_synthesis_adjoint_mw_test',['../s2let__test_8c.html#a1bb00b26cbe0fbb23f41778220fa5824',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fharmonic_5fmultires_5ftest_289',['s2let_wav_transform_harmonic_multires_test',['../s2let__test_8c.html#a9a6c059a89a24d1faf87c71d4daa0aad',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fharmonic_5ftest_290',['s2let_wav_transform_harmonic_test',['../s2let__test_8c.html#a36c393819821e9d3230f1b611029c03a',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5flm2wav_5fmultires_5freal_5ftest_291',['s2let_wav_transform_lm2wav_multires_real_test',['../s2let__test_8c.html#a97581c49341c7cd099bde20868fc7cd6',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5flm2wav_5fmultires_5ftest_292',['s2let_wav_transform_lm2wav_multires_test',['../s2let__test_8c.html#af37a0a8300c436e3de4404914b06644b',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5flm2wav_5freal_5ftest_293',['s2let_wav_transform_lm2wav_real_test',['../s2let__test_8c.html#a4631a44a831e086e712e9f1aa7ffab62',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5flm2wav_5ftest_294',['s2let_wav_transform_lm2wav_test',['../s2let__test_8c.html#a2cf679450a2ce6ea636c2dc10f7e540a',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmw_5fmultires_5freal_5ftest_295',['s2let_wav_transform_mw_multires_real_test',['../s2let__test_8c.html#a4d1b3d1c528a9251c2f7ca5841b7ea4c',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmw_5fmultires_5ftest_296',['s2let_wav_transform_mw_multires_test',['../s2let__test_8c.html#a8e3ae237fa88d72d1dbd073219148d14',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmw_5freal_5ftest_297',['s2let_wav_transform_mw_real_test',['../s2let__test_8c.html#a8c730406b8d674ce01adf2f00b23a80b',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmw_5ftest_298',['s2let_wav_transform_mw_test',['../s2let__test_8c.html#ac21ea0848f541e57646992df1f019ac6',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmwss_5fmultires_5freal_5ftest_299',['s2let_wav_transform_mwss_multires_real_test',['../s2let__test_8c.html#a98871d63a676332bf18fa0e759ed7b75',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmwss_5fmultires_5ftest_300',['s2let_wav_transform_mwss_multires_test',['../s2let__test_8c.html#a47c841b99612070b47ad9cc82e15381f',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmwss_5freal_5ftest_301',['s2let_wav_transform_mwss_real_test',['../s2let__test_8c.html#a0405e044e4b231f44c78768efa065da2',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmwss_5ftest_302',['s2let_wav_transform_mwss_test',['../s2let__test_8c.html#a50a13ab98a0345f3d9d66d4252f6b4c6',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fwavlm_5fmanual_5ftest_303',['s2let_wav_transform_wavlm_manual_test',['../s2let__test_8c.html#a73199654867cc48b0fdfa593987dfecd',1,'s2let_test.c']]], - ['sampling_5fscheme_304',['sampling_scheme',['../structs2let__parameters__t.html#a32942243b855116a10cc6b8b81a90b87',1,'s2let_parameters_t']]], - ['so3_5ftest_5fgen_5fflmn_5fcomplex_305',['so3_test_gen_flmn_complex',['../s2let__test_8c.html#af5b2cded1bb3914d1398df3b65eec310',1,'s2let_test.c']]], - ['spin_306',['spin',['../structs2let__parameters__t.html#a4fd720e3d7a947dab5bbfd0f51c3dcf7',1,'s2let_parameters_t']]], - ['spline_307',['SPLINE',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aa4d8b3b9406a35793dead4b293d793463',1,'s2let_tiling.c']]] + ['s2dw_39',['S2DW',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aad2e1e459d07d91ca00e5f09caf8b4558',1,'s2let_tiling.c']]], + ['s2let_2eh_40',['s2let.h',['../s2let_8h.html',1,'']]], + ['s2let_5fabout_2ec_41',['s2let_about.c',['../s2let__about_8c.html',1,'']]], + ['s2let_5falloc_2ec_42',['s2let_alloc.c',['../s2let__alloc_8c.html',1,'']]], + ['s2let_5falloc_2eh_43',['s2let_alloc.h',['../s2let__alloc_8h.html',1,'']]], + ['s2let_5fallocate_5ff_5fwav_44',['s2let_allocate_f_wav',['../s2let__alloc_8c.html#a04372bb80be30ca4b5442c682c550866',1,'s2let_allocate_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a1e37dc2888e4d40c947e7c7727eb8ad7',1,'s2let_allocate_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_alloc.h']]], + ['s2let_5fallocate_5ff_5fwav_5fmanual_45',['s2let_allocate_f_wav_manual',['../s2let__alloc_8c.html#afb051ec7fd9741b39b184f4b957acd36',1,'s2let_allocate_f_wav_manual(complex double **f_wav, complex double **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#afc97a325f105008a466164506e12c864',1,'s2let_allocate_f_wav_manual(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, const s2let_parameters_t *parameters): s2let_alloc.h']]], + ['s2let_5fallocate_5ff_5fwav_5freal_46',['s2let_allocate_f_wav_real',['../s2let__alloc_8c.html#a979f526f58f72c9c96e16e2ba46e0f63',1,'s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a979f526f58f72c9c96e16e2ba46e0f63',1,'s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c']]], + ['s2let_5fallocate_5flm_47',['s2let_allocate_lm',['../s2let__alloc_8c.html#a8b221a008760c8dbe1a655c74dc2d0d0',1,'s2let_allocate_lm(complex double **flm, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#aa7bc8a069c40873338f1e8c770f34424',1,'s2let_allocate_lm(S2LET_COMPLEX(double) **flm, int L): s2let_alloc.h']]], + ['s2let_5fallocate_5flmn_5ff_5fwav_48',['s2let_allocate_lmn_f_wav',['../s2let__alloc_8c.html#a9dcb24db0b9cd7dd522bead7d61f7960',1,'s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a8c43cc27f8f2450ae6ec9bb6165dfd8b',1,'s2let_allocate_lmn_f_wav(S2LET_COMPLEX(double) **f_wav_lmn, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_alloc.h']]], + ['s2let_5fallocate_5fmw_49',['s2let_allocate_mw',['../s2let__alloc_8c.html#a83fad2b470cea9f29d8fe104616236dc',1,'s2let_allocate_mw(complex double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#ac042b364686fc53225102c71fc10f797',1,'s2let_allocate_mw(S2LET_COMPLEX(double) **f, int L): s2let_alloc.h']]], + ['s2let_5fallocate_5fmw_5freal_50',['s2let_allocate_mw_real',['../s2let__alloc_8c.html#a22e7d6f3fdc037d975eaad03ef0ece23',1,'s2let_allocate_mw_real(double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#a22e7d6f3fdc037d975eaad03ef0ece23',1,'s2let_allocate_mw_real(double **f, int L): s2let_alloc.c']]], + ['s2let_5fallocate_5fmwss_51',['s2let_allocate_mwss',['../s2let__alloc_8c.html#a4569d2d2e8251c4e65494b1518ebe72e',1,'s2let_allocate_mwss(complex double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#ab914515792a062cc87662d8a6b028b7b',1,'s2let_allocate_mwss(S2LET_COMPLEX(double) **f, int L): s2let_alloc.h']]], + ['s2let_5fallocate_5fmwss_5freal_52',['s2let_allocate_mwss_real',['../s2let__alloc_8c.html#a562dc748f45b20b9791bbca68045c472',1,'s2let_allocate_mwss_real(double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#a562dc748f45b20b9791bbca68045c472',1,'s2let_allocate_mwss_real(double **f, int L): s2let_alloc.c']]], + ['s2let_5fanalysis_2ec_53',['s2let_analysis.c',['../s2let__analysis_8c.html',1,'']]], + ['s2let_5fanalysis_2eh_54',['s2let_analysis.h',['../s2let__analysis_8h.html',1,'']]], + ['s2let_5fanalysis_5fadjoint_2ec_55',['s2let_analysis_adjoint.c',['../s2let__analysis__adjoint_8c.html',1,'']]], + ['s2let_5fanalysis_5fadjoint_2eh_56',['s2let_analysis_adjoint.h',['../s2let__analysis__adjoint_8h.html',1,'']]], + ['s2let_5fanalysis_5fadjoint_5flmn2lm_57',['s2let_analysis_adjoint_lmn2lm',['../s2let__analysis__adjoint_8c.html#a72146aacc61a608c02b22299d6c61e98',1,'s2let_analysis_adjoint_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a529cb2b3e504faf4cda24b4c6d99d333',1,'s2let_analysis_adjoint_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5flmn2lm_5freal_58',['s2let_analysis_adjoint_lmn2lm_real',['../s2let__analysis__adjoint_8c.html#abee7a1a11683f976937f6ab167a4a2ed',1,'s2let_analysis_adjoint_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a2c83c6835e02811a5d264613391b789e',1,'s2let_analysis_adjoint_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2lm_59',['s2let_analysis_adjoint_wav2lm',['../s2let__analysis__adjoint_8c.html#acbf24f007aab1439f827cafe351db721',1,'s2let_analysis_adjoint_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a6c6a34d9203703ddf27f323109f9dde6',1,'s2let_analysis_adjoint_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2lm_5fmanual_60',['s2let_analysis_adjoint_wav2lm_manual',['../s2let__analysis__adjoint_8c.html#a29d0f211cfd72f240cf53504d0ba12c3',1,'s2let_analysis_adjoint_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a181593f69b4cc0d9d26aa9379dc9bba2',1,'s2let_analysis_adjoint_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2lm_5freal_61',['s2let_analysis_adjoint_wav2lm_real',['../s2let__analysis__adjoint_8c.html#a055b05e4838ea75986215b775a124568',1,'s2let_analysis_adjoint_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a46105f73ba49339a7b5565db46ac3b28',1,'s2let_analysis_adjoint_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2px_62',['s2let_analysis_adjoint_wav2px',['../s2let__analysis__adjoint_8c.html#a4033dce73ff132c2d7f0a23b7b741d85',1,'s2let_analysis_adjoint_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a8af02104042ed3c6ea7398889483cc45',1,'s2let_analysis_adjoint_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2px_5freal_63',['s2let_analysis_adjoint_wav2px_real',['../s2let__analysis__adjoint_8c.html#ad3c34c9c83b067fb9c350698fd66d5a6',1,'s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#ad3c34c9c83b067fb9c350698fd66d5a6',1,'s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c']]], + ['s2let_5fanalysis_5flm2lmn_64',['s2let_analysis_lm2lmn',['../s2let__analysis_8c.html#a9781ec2d11788c9aa5a13bbca0e6ba9c',1,'s2let_analysis_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a1ff7c08702b71c00f79668abbc950d30',1,'s2let_analysis_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5flm2lmn_5freal_65',['s2let_analysis_lm2lmn_real',['../s2let__analysis_8c.html#a08075042a4adb01136d60414fd401a60',1,'s2let_analysis_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a0ae75e5749e9bb978f21d86b674c41b5',1,'s2let_analysis_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5flm2wav_66',['s2let_analysis_lm2wav',['../s2let__analysis_8c.html#ac5d95aed75e346bb48b9249bf80ace23',1,'s2let_analysis_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a2c035e3a62cab8dd9586d6fe75ab8268',1,'s2let_analysis_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5flm2wav_5fmanual_67',['s2let_analysis_lm2wav_manual',['../s2let__analysis_8c.html#a36f06dd57668341905eb038f85c309a2',1,'s2let_analysis_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis.c'],['../s2let__analysis_8h.html#a8af83cfbde6d80b9802c85553aed5828',1,'s2let_analysis_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis.h']]], + ['s2let_5fanalysis_5flm2wav_5freal_68',['s2let_analysis_lm2wav_real',['../s2let__analysis_8c.html#a33928a9b09c9afe216dcf733ae7d1c5f',1,'s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a107abc090af40bf3d9ee37787e9d86c8',1,'s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5fpx2wav_69',['s2let_analysis_px2wav',['../s2let__analysis_8c.html#a685f469be2016583d3fc15dae0e24c93',1,'s2let_analysis_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a1fc2440d51f5255a14fddd3cc6e25e61',1,'s2let_analysis_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5fpx2wav_5freal_70',['s2let_analysis_px2wav_real',['../s2let__analysis_8c.html#a559ce533b1453fddd43b2046323d3abf',1,'s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a559ce533b1453fddd43b2046323d3abf',1,'s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_analysis.c']]], + ['s2let_5faxisym_5fdenoising_5fdemo_2ec_71',['s2let_axisym_denoising_demo.c',['../s2let__axisym__denoising__demo_8c.html',1,'']]], + ['s2let_5faxisym_5fdenoising_5fdemo_2eh_72',['s2let_axisym_denoising_demo.h',['../s2let__axisym__denoising__demo_8h.html',1,'']]], + ['s2let_5fbandlimit_73',['s2let_bandlimit',['../s2let__tiling_8c.html#ac022968b50a5a7a294fd6ae9d792119a',1,'s2let_bandlimit(int j, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ac022968b50a5a7a294fd6ae9d792119a',1,'s2let_bandlimit(int j, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5fbinomial_5fcoefficient_5ftest_74',['s2let_binomial_coefficient_test',['../s2let__test_8c.html#a468603fe2a4ae0176b1a3008b5508ac7',1,'s2let_test.c']]], + ['s2let_5fcomplex_75',['S2LET_COMPLEX',['../s2let__types_8h.html#a121c8622035e81912b4b85b436b4ec6d',1,'s2let_types.h']]], + ['s2let_5fdenoising_5fdemo_2ec_76',['s2let_denoising_demo.c',['../s2let__denoising__demo_8c.html',1,'']]], + ['s2let_5fdenoising_5fdemo_2eh_77',['s2let_denoising_demo.h',['../s2let__denoising__demo_8h.html',1,'']]], + ['s2let_5fdot_5fproduct_5fcomplex_78',['s2let_dot_product_complex',['../s2let__test_8c.html#af85961da9316af3f997f88fedd2604d9',1,'s2let_test.c']]], + ['s2let_5fdot_5fproduct_5freal_79',['s2let_dot_product_real',['../s2let__test_8c.html#ab9098753dfdaad47814f9d13a5e838a1',1,'s2let_test.c']]], + ['s2let_5ferror_2eh_80',['s2let_error.h',['../s2let__error_8h.html',1,'']]], + ['s2let_5ferror_5fgeneric_81',['S2LET_ERROR_GENERIC',['../s2let__error_8h.html#a740f1ee53df6b15f6ca098bb9163c1fc',1,'s2let_error.h']]], + ['s2let_5ferror_5fmem_5falloc_5fcheck_82',['S2LET_ERROR_MEM_ALLOC_CHECK',['../s2let__error_8h.html#a74500ae1fd825972a4508c643173c763',1,'s2let_error.h']]], + ['s2let_5ffits_2ec_83',['s2let_fits.c',['../s2let__fits_8c.html',1,'']]], + ['s2let_5ffits_2eh_84',['s2let_fits.h',['../s2let__fits_8h.html',1,'']]], + ['s2let_5ffits_5fhpx_5fread_5fnside_85',['s2let_fits_hpx_read_nside',['../s2let__fits_8c.html#a332b4542fd283126c1bfd55c6f96d0e9',1,'s2let_fits_hpx_read_nside(char *filename): s2let_fits.c'],['../s2let__fits_8h.html#a332b4542fd283126c1bfd55c6f96d0e9',1,'s2let_fits_hpx_read_nside(char *filename): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fread_5fbandlimit_86',['s2let_fits_mw_read_bandlimit',['../s2let__fits_8c.html#a32b9baca740954e5dd89ff84a873bd5f',1,'s2let_fits_mw_read_bandlimit(char *filename): s2let_fits.c'],['../s2let__fits_8h.html#a32b9baca740954e5dd89ff84a873bd5f',1,'s2let_fits_mw_read_bandlimit(char *filename): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fread_5fmap_87',['s2let_fits_mw_read_map',['../s2let__fits_8c.html#af6db1f82ef3c0d037656ec6ac54e2d19',1,'s2let_fits_mw_read_map(double *f, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a8f3efe334a8689717e3c4af67bfcc182',1,'s2let_fits_mw_read_map(double *f, char *file, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fread_5fspin_5fmaps_88',['s2let_fits_mw_read_spin_maps',['../s2let__fits_8c.html#a76db1cab8202e48ed93378d68d5e1b0f',1,'s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a6452019812d547dc0de6888e76c9f2db',1,'s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *file, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fwrite_5fmap_89',['s2let_fits_mw_write_map',['../s2let__fits_8c.html#a33e069a17c3116f44eb667a9cba40615',1,'s2let_fits_mw_write_map(char *filename, double *f, int L): s2let_fits.c'],['../s2let__fits_8h.html#ae98dbd904653a070d64f31fa37bfa617',1,'s2let_fits_mw_write_map(char *file, double *f, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fwrite_5fspin_5fmaps_90',['s2let_fits_mw_write_spin_maps',['../s2let__fits_8c.html#a5c22448360290d72a157eb886a3bb23e',1,'s2let_fits_mw_write_spin_maps(char *filename, double *fQ, double *fU, int L): s2let_fits.c'],['../s2let__fits_8h.html#afe7d32ae54ded848bd7a7cb25d4dba93',1,'s2let_fits_mw_write_spin_maps(char *file, double *fQ, double *fU, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmwss_5fread_5fmap_91',['s2let_fits_mwss_read_map',['../s2let__fits_8c.html#a30d6c0469210655e662bbdf8153d3e3f',1,'s2let_fits_mwss_read_map(double *f, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#ad022bd34785d0cc2d5a2b1f924ba26fd',1,'s2let_fits_mwss_read_map(double *f, char *file, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmwss_5fread_5fspin_5fmaps_92',['s2let_fits_mwss_read_spin_maps',['../s2let__fits_8c.html#abf0138418d23fff52dea5dabb8e2a7fa',1,'s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a85a1bcdf0dee2673f2d5ffd374f2bdfd',1,'s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *file, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmwss_5fwrite_5fmap_93',['s2let_fits_mwss_write_map',['../s2let__fits_8c.html#a7b7613e2e45ffa5e2ff4ef51c88039f7',1,'s2let_fits_mwss_write_map(char *filename, double *f, int L): s2let_fits.c'],['../s2let__fits_8h.html#a22e885366d6e8367fd5afe62679ff42f',1,'s2let_fits_mwss_write_map(char *file, double *f, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmwss_5fwrite_5fspin_5fmaps_94',['s2let_fits_mwss_write_spin_maps',['../s2let__fits_8c.html#ac0aa9a648728c543e0a15490e639b7e7',1,'s2let_fits_mwss_write_spin_maps(char *filename, double *fQ, double *fU, int L): s2let_fits.c'],['../s2let__fits_8h.html#abb0ad8df2666842d52b8b6b724d2688f',1,'s2let_fits_mwss_write_spin_maps(char *file, double *fQ, double *fU, int L): s2let_fits.c']]], + ['s2let_5fhelper_2ec_95',['s2let_helper.c',['../s2let__helper_8c.html',1,'']]], + ['s2let_5fhelper_2eh_96',['s2let_helper.h',['../s2let__helper_8h.html',1,'']]], + ['s2let_5fhpx_2ec_97',['s2let_hpx.c',['../s2let__hpx_8c.html',1,'']]], + ['s2let_5fhpx_2eh_98',['s2let_hpx.h',['../s2let__hpx_8h.html',1,'']]], + ['s2let_5fhpx_5fallocate_5freal_99',['s2let_hpx_allocate_real',['../s2let__hpx_8c.html#a5fd3f8d1975ab0798c4797665256083a',1,'s2let_hpx_allocate_real(double **f, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a5fd3f8d1975ab0798c4797665256083a',1,'s2let_hpx_allocate_real(double **f, int nside): s2let_hpx.c']]], + ['s2let_5fhpx_5falm2map_5freal_100',['s2let_hpx_alm2map_real',['../s2let__hpx_8c.html#a3a16f082dbd93ca1413282167eb70b78',1,'s2let_hpx_alm2map_real(double *f, const complex double *flm, int nside, int L): s2let_hpx.c'],['../s2let__hpx_8h.html#adfeed42820bd0d0c686c83b87c091050',1,'s2let_hpx_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int nside, int L): s2let_hpx.h']]], + ['s2let_5fhpx_5falm2map_5fspin_5freal_101',['s2let_hpx_alm2map_spin_real',['../s2let__hpx_8c.html#a628694892c6f91d3e04fef9fccf145d9',1,'s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const complex double *flmE, const complex double *flmB, int nside, int L, int spin): s2let_hpx.c'],['../s2let__hpx_8h.html#aeeb308d10fad6609143c7b88add754c1',1,'s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const S2LET_COMPLEX(double) *flmE, const S2LET_COMPLEX(double) *flmB, int nside, int L, int spin): s2let_hpx.h']]], + ['s2let_5fhpx_5fdemo_2ec_102',['s2let_hpx_demo.c',['../s2let__hpx__demo_8c.html',1,'']]], + ['s2let_5fhpx_5fio_5ftest_103',['s2let_hpx_io_test',['../s2let__hpx__test_8c.html#a38519222c90d787d322f0163273466c6',1,'s2let_hpx_test.c']]], + ['s2let_5fhpx_5fmap2alm_5freal_104',['s2let_hpx_map2alm_real',['../s2let__hpx_8c.html#a78d966279d936b4937553e58b88265f3',1,'s2let_hpx_map2alm_real(complex double *flm, const double *f, int nside, int L): s2let_hpx.c'],['../s2let__hpx_8h.html#addf44689d1620ff08e9e623064a3da0f',1,'s2let_hpx_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int nside, int L): s2let_hpx.h']]], + ['s2let_5fhpx_5fmap2alm_5fspin_5freal_105',['s2let_hpx_map2alm_spin_real',['../s2let__hpx_8c.html#a9183b4967c1e5f8a6c973a1697362e91',1,'s2let_hpx_map2alm_spin_real(complex double *flmE, complex double *flmB, const double *fQ, const double *fU, int nside, int L, int spin): s2let_hpx.c'],['../s2let__hpx_8h.html#aa7a27c83a31e71f1fd90bdf0bbb84a8d',1,'s2let_hpx_map2alm_spin_real(S2LET_COMPLEX(double) *flmE, S2LET_COMPLEX(double) *flmB, const double *fQ, const double *fU, int nside, int L, int spin): s2let_hpx.h']]], + ['s2let_5fhpx_5fread_5fmap_106',['s2let_hpx_read_map',['../s2let__hpx_8c.html#a007bb3a6640667248187f9ac38b9d6a4',1,'s2let_hpx_read_map(double *f, char *file, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a007bb3a6640667248187f9ac38b9d6a4',1,'s2let_hpx_read_map(double *f, char *file, int nside): s2let_hpx.c']]], + ['s2let_5fhpx_5fread_5fmaps_107',['s2let_hpx_read_maps',['../s2let__hpx_8c.html#a5c51e9a1cbae07bee6dede794c93470c',1,'s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps): s2let_hpx.c'],['../s2let__hpx_8h.html#a5c51e9a1cbae07bee6dede794c93470c',1,'s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps): s2let_hpx.c']]], + ['s2let_5fhpx_5fspinalm_5ftest_108',['s2let_hpx_spinalm_test',['../s2let__hpx__test_8c.html#a2d59903931d514b42dadfe993b697712',1,'s2let_hpx_test.c']]], + ['s2let_5fhpx_5ftest_2ec_109',['s2let_hpx_test.c',['../s2let__hpx__test_8c.html',1,'']]], + ['s2let_5fhpx_5fwrite_5fmap_110',['s2let_hpx_write_map',['../s2let__hpx_8c.html#a5f03d8745c5e15c0f03c2546464ec042',1,'s2let_hpx_write_map(char *file, const double *f, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a5f03d8745c5e15c0f03c2546464ec042',1,'s2let_hpx_write_map(char *file, const double *f, int nside): s2let_hpx.c']]], + ['s2let_5fidl_5faxisym_5fhpx_5fwav_5fanalysis_5freal_111',['s2let_idl_axisym_hpx_wav_analysis_real',['../s2let__idl__hpx_8c.html#a8d5e1acca474c541532a3c249a2f3814',1,'s2let_idl_hpx.c']]], + ['s2let_5fidl_5faxisym_5fhpx_5fwav_5fsynthesis_5freal_112',['s2let_idl_axisym_hpx_wav_synthesis_real',['../s2let__idl__hpx_8c.html#a8bbb1aa9b6b3987cd55b6f6d2ac212f5',1,'s2let_idl_hpx.c']]], + ['s2let_5fidl_5fhpx_2ec_113',['s2let_idl_hpx.c',['../s2let__idl__hpx_8c.html',1,'']]], + ['s2let_5fidl_5fhpx_2eh_114',['s2let_idl_hpx.h',['../s2let__idl__hpx_8h.html',1,'']]], + ['s2let_5fidl_5fhpx_5falm2map_5freal_115',['s2let_idl_hpx_alm2map_real',['../s2let__idl__hpx_8c.html#a2405269f6a3905d347497fdd8f8737b2',1,'s2let_idl_hpx_alm2map_real(int argc, void *argv[]): s2let_idl_hpx.c'],['../s2let__idl__hpx_8h.html#a2405269f6a3905d347497fdd8f8737b2',1,'s2let_idl_hpx_alm2map_real(int argc, void *argv[]): s2let_idl_hpx.c']]], + ['s2let_5fidl_5fhpx_5faxisym_5fwav_5fanalysis_5freal_116',['s2let_idl_hpx_axisym_wav_analysis_real',['../s2let__idl__hpx_8h.html#af0b753f2c0d41972ff727e18bbf51490',1,'s2let_idl_hpx.h']]], + ['s2let_5fidl_5fhpx_5faxisym_5fwav_5fsynthesis_5freal_117',['s2let_idl_hpx_axisym_wav_synthesis_real',['../s2let__idl__hpx_8h.html#a780c8d58d24780b54367b2751d456d21',1,'s2let_idl_hpx.h']]], + ['s2let_5fidl_5fhpx_5fmap2alm_5freal_118',['s2let_idl_hpx_map2alm_real',['../s2let__idl__hpx_8c.html#ad34b479c1681a81cc1c707def15d296c',1,'s2let_idl_hpx_map2alm_real(int argc, void *argv[]): s2let_idl_hpx.c'],['../s2let__idl__hpx_8h.html#ad34b479c1681a81cc1c707def15d296c',1,'s2let_idl_hpx_map2alm_real(int argc, void *argv[]): s2let_idl_hpx.c']]], + ['s2let_5fidl_5fmw_2ec_119',['s2let_idl_mw.c',['../s2let__idl__mw_8c.html',1,'']]], + ['s2let_5fidl_5fmw_2eh_120',['s2let_idl_mw.h',['../s2let__idl__mw_8h.html',1,'']]], + ['s2let_5fidl_5fmw_5falm2map_121',['s2let_idl_mw_alm2map',['../s2let__idl__mw_8c.html#a4c2ef5574faf8b82ca91295b1321b5e8',1,'s2let_idl_mw.c']]], + ['s2let_5fidl_5fmw_5falm2map_5freal_122',['s2let_idl_mw_alm2map_real',['../s2let__idl__mw_8c.html#af7a317220109dabfc86d0dd5c4b8987c',1,'s2let_idl_mw.c']]], + ['s2let_5fidl_5fmw_5fmap2alm_123',['s2let_idl_mw_map2alm',['../s2let__idl__mw_8c.html#a2e12cdca9f43efd97ab6a93da615599c',1,'s2let_idl_mw.c']]], + ['s2let_5fidl_5fmw_5fmap2alm_5freal_124',['s2let_idl_mw_map2alm_real',['../s2let__idl__mw_8c.html#ac5974e9a553e5ca74bcf2cedf0faa970',1,'s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5falm2map_125',['s2let_idl_transform_alm2map',['../s2let__idl__mw_8h.html#aee50e78b2a8b7521629d086621d23c60',1,'s2let_idl_mw.h']]], + ['s2let_5fidl_5ftransform_5falm2map_5freal_126',['s2let_idl_transform_alm2map_real',['../s2let__idl__mw_8h.html#aceb297101069e992a356fadfc43820d0',1,'s2let_idl_mw.h']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_127',['s2let_idl_transform_axisym_wav_analysis_mw',['../s2let__idl__mw_8c.html#a7fcf1a787d1d465620d3287703e5ce6c',1,'s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a7fcf1a787d1d465620d3287703e5ce6c',1,'s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_128',['s2let_idl_transform_axisym_wav_analysis_mw_multires',['../s2let__idl__mw_8c.html#a97466a06e494b38c4d60a7f6839a41e3',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a97466a06e494b38c4d60a7f6839a41e3',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_5freal_129',['s2let_idl_transform_axisym_wav_analysis_mw_multires_real',['../s2let__idl__mw_8c.html#ad1712f32e26d77c9b21b7f3bd62f4609',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad1712f32e26d77c9b21b7f3bd62f4609',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5freal_130',['s2let_idl_transform_axisym_wav_analysis_mw_real',['../s2let__idl__mw_8c.html#a168466d81a6d248d0b4280a9687d8172',1,'s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a168466d81a6d248d0b4280a9687d8172',1,'s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_131',['s2let_idl_transform_axisym_wav_synthesis_mw',['../s2let__idl__mw_8c.html#ad3bd4d2483d2716820eb6b0d107cd75b',1,'s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad3bd4d2483d2716820eb6b0d107cd75b',1,'s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_132',['s2let_idl_transform_axisym_wav_synthesis_mw_multires',['../s2let__idl__mw_8c.html#abb8950501cac08ff378bc0dbf172eb73',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#abb8950501cac08ff378bc0dbf172eb73',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_5freal_133',['s2let_idl_transform_axisym_wav_synthesis_mw_multires_real',['../s2let__idl__mw_8c.html#ad0f7dd4ae05137d49d8e35e4e2dd827e',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad0f7dd4ae05137d49d8e35e4e2dd827e',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5freal_134',['s2let_idl_transform_axisym_wav_synthesis_mw_real',['../s2let__idl__mw_8c.html#a61efa315fb01f338ed265b7898c91caa',1,'s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a61efa315fb01f338ed265b7898c91caa',1,'s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5fmap2alm_135',['s2let_idl_transform_map2alm',['../s2let__idl__mw_8h.html#a2653d09d0f6ab88cfb2803505da9fd6b',1,'s2let_idl_mw.h']]], + ['s2let_5fidl_5ftransform_5fmap2alm_5freal_136',['s2let_idl_transform_map2alm_real',['../s2let__idl__mw_8h.html#a8e509c9e23c2225aafdc6e77c6b73c58',1,'s2let_idl_mw.h']]], + ['s2let_5fj_5fmax_137',['s2let_j_max',['../s2let__tiling_8c.html#af8e45477d8b8a0bbd2f0dd706ee29f7e',1,'s2let_j_max(const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#af8e45477d8b8a0bbd2f0dd706ee29f7e',1,'s2let_j_max(const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5fkernel_138',['s2let_kernel',['../s2let__tiling_8c.html#ab2ff4854b8611353b7ba607e99a742f3',1,'s2let_tiling.c']]], + ['s2let_5fkernel_5ftype_139',['s2let_kernel_type',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879a',1,'s2let_tiling.c']]], + ['s2let_5fl0_140',['s2let_L0',['../s2let__tiling_8c.html#a970c83288da0b2f1b0c783dc32da5d58',1,'s2let_L0(int j, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a970c83288da0b2f1b0c783dc32da5d58',1,'s2let_L0(int j, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5flm_2ec_141',['s2let_lm.c',['../s2let__lm_8c.html',1,'']]], + ['s2let_5flm_2eh_142',['s2let_lm.h',['../s2let__lm_8h.html',1,'']]], + ['s2let_5flm_5fpower_143',['s2let_lm_power',['../s2let__lm_8c.html#a520c6e822fd2d004f87b0babf793b93b',1,'s2let_lm_power(complex double *flm, int L): s2let_lm.c'],['../s2let__lm_8h.html#ace994f794328a0338095553fd7e81c2e',1,'s2let_lm_power(S2LET_COMPLEX(double) *flm, int L): s2let_lm.h']]], + ['s2let_5flm_5frandom_5fflm_144',['s2let_lm_random_flm',['../s2let__lm_8c.html#aecdba2ebff470192c677d787331440da',1,'s2let_lm_random_flm(complex double *flm, int L, int spin, int seed): s2let_lm.c'],['../s2let__lm_8h.html#aa1cf89a60a2c297ed93525c7abd36d82',1,'s2let_lm_random_flm(S2LET_COMPLEX(double) *flm, int L, int spin, int seed): s2let_lm.h']]], + ['s2let_5flm_5frandom_5fflm_5freal_145',['s2let_lm_random_flm_real',['../s2let__lm_8c.html#a976ccda30f8c30bfbcd238242deef100',1,'s2let_lm_random_flm_real(complex double *flm, int L, int seed): s2let_lm.c'],['../s2let__lm_8h.html#a52b1d6d06e4ac3b5d386b6a9a9f5d9d1',1,'s2let_lm_random_flm_real(S2LET_COMPLEX(double) *flm, int L, int seed): s2let_lm.h']]], + ['s2let_5flm_5frandom_5fflm_5freal_5fsigma_146',['s2let_lm_random_flm_real_sigma',['../s2let__axisym__denoising__demo_8c.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8c.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_denoising_demo.c'],['../s2let__axisym__denoising__demo_8h.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8h.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c']]], + ['s2let_5flm_5frandom_5fflm_5fsigma_147',['s2let_lm_random_flm_sigma',['../s2let__spin__denoising__demo_8c.html#a8f2d6d26977c37558bd348037fac075f',1,'s2let_spin_denoising_demo.c']]], + ['s2let_5fmath_2ec_148',['s2let_math.c',['../s2let__math_8c.html',1,'']]], + ['s2let_5fmath_2eh_149',['s2let_math.h',['../s2let__math_8h.html',1,'']]], + ['s2let_5fmath_5fkappa0_5fquadtrap_5fneedlet_150',['s2let_math_kappa0_quadtrap_needlet',['../s2let__math_8c.html#a1ee31db982694aeff4308288cb38e044',1,'s2let_math_kappa0_quadtrap_needlet(double a, double b, int n): s2let_math.c'],['../s2let__math_8h.html#a1ee31db982694aeff4308288cb38e044',1,'s2let_math_kappa0_quadtrap_needlet(double a, double b, int n): s2let_math.c']]], + ['s2let_5fmath_5fkappa0_5fquadtrap_5fs2dw_151',['s2let_math_kappa0_quadtrap_s2dw',['../s2let__math_8c.html#a44eb4f6042bf9dd406b3da22eca7e434',1,'s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B): s2let_math.c'],['../s2let__math_8h.html#a44eb4f6042bf9dd406b3da22eca7e434',1,'s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B): s2let_math.c']]], + ['s2let_5fmath_5fspline_5fscalingfct_152',['s2let_math_spline_scalingfct',['../s2let__math_8c.html#a5a6d036165ebcd79b2c4f5716a42bcd8',1,'s2let_math_spline_scalingfct(double x, double y): s2let_math.c'],['../s2let__math_8h.html#a5a6d036165ebcd79b2c4f5716a42bcd8',1,'s2let_math_spline_scalingfct(double x, double y): s2let_math.c']]], + ['s2let_5fmex_2eh_153',['s2let_mex.h',['../s2let__mex_8h.html',1,'']]], + ['s2let_5fmw_2ec_154',['s2let_mw.c',['../s2let__mw_8c.html',1,'']]], + ['s2let_5fmw_2eh_155',['s2let_mw.h',['../s2let__mw_8h.html',1,'']]], + ['s2let_5fmw_5falm2map_156',['s2let_mw_alm2map',['../s2let__mw_8c.html#a71a1d94b45021758562acb54f7efbadc',1,'s2let_mw_alm2map(complex double *f, const complex double *flm, int L, int spin): s2let_mw.c'],['../s2let__mw_8h.html#adbfa150db5b9bcca2993df5e14cb05b9',1,'s2let_mw_alm2map(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *flm, int L, int spin): s2let_mw.h']]], + ['s2let_5fmw_5falm2map_5freal_157',['s2let_mw_alm2map_real',['../s2let__mw_8c.html#acec65039b721a60d622aa6ccdc57fe58',1,'s2let_mw_alm2map_real(double *f, const complex double *flm, int L): s2let_mw.c'],['../s2let__mw_8h.html#a845b320975dc03e952f28c539da9d426',1,'s2let_mw_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int L): s2let_mw.h']]], + ['s2let_5fmw_5fio_5fspin_5ftest_158',['s2let_mw_io_spin_test',['../s2let__hpx__test_8c.html#a2cb09cab436803d8581b6b96959dff9e',1,'s2let_hpx_test.c']]], + ['s2let_5fmw_5fio_5ftest_159',['s2let_mw_io_test',['../s2let__hpx__test_8c.html#af91cc34a400e0f94e570728ac6f6c759',1,'s2let_hpx_test.c']]], + ['s2let_5fmw_5fmap2alm_160',['s2let_mw_map2alm',['../s2let__mw_8c.html#ae2d95be7cf71bfe84060dbdd77c6947b',1,'s2let_mw_map2alm(complex double *flm, const complex double *f, int L, int spin): s2let_mw.c'],['../s2let__mw_8h.html#a727851e328422320a31ef6548631e0dd',1,'s2let_mw_map2alm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f, int L, int spin): s2let_mw.h']]], + ['s2let_5fmw_5fmap2alm_5freal_161',['s2let_mw_map2alm_real',['../s2let__mw_8c.html#adee030c15f2b401361c278a6c6ea6f7c',1,'s2let_mw_map2alm_real(complex double *flm, const double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#a297725ba5e35713e59c0b601a6964942',1,'s2let_mw_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int L): s2let_mw.h']]], + ['s2let_5fmw_5fpower_162',['s2let_mw_power',['../s2let__mw_8c.html#a91dbb4ab1556928322986d21d413abdf',1,'s2let_mw_power(complex double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#aceb97384257965caeb908162dae89009',1,'s2let_mw_power(S2LET_COMPLEX(double) *flm, int L): s2let_mw.h']]], + ['s2let_5fmw_5fpower_5freal_163',['s2let_mw_power_real',['../s2let__mw_8c.html#a3520764bba2023b957373df5769f25e8',1,'s2let_mw_power_real(double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#aa3c531ec00960d928d8d7fca2f6a3108',1,'s2let_mw_power_real(double *flm, int L): s2let_mw.c']]], + ['s2let_5fn_5fgamma_164',['s2let_n_gamma',['../s2let__helper_8c.html#a33cd356d3eca688b51e0a70cc216b3c6',1,'s2let_n_gamma(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a33cd356d3eca688b51e0a70cc216b3c6',1,'s2let_n_gamma(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5flm_165',['s2let_n_lm',['../s2let__helper_8c.html#a31cd45045fa530a8b67db235da15d29f',1,'s2let_n_lm(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a31cd45045fa530a8b67db235da15d29f',1,'s2let_n_lm(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5flm_5fscal_166',['s2let_n_lm_scal',['../s2let__helper_8c.html#aaf6daa1bc9b68e76a247860c57a9e8b9',1,'s2let_n_lm_scal(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aaf6daa1bc9b68e76a247860c57a9e8b9',1,'s2let_n_lm_scal(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5flmn_5fwav_167',['s2let_n_lmn_wav',['../s2let__helper_8c.html#a8db8dd8265358a8501a40fe77c4ab908',1,'s2let_n_lmn_wav(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a8db8dd8265358a8501a40fe77c4ab908',1,'s2let_n_lmn_wav(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fphi_168',['s2let_n_phi',['../s2let__helper_8c.html#aca44ba24618888aa56773d0fa662bb87',1,'s2let_n_phi(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aca44ba24618888aa56773d0fa662bb87',1,'s2let_n_phi(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fpx_169',['s2let_n_px',['../s2let__helper_8c.html#a8de2596044e8dbd481d0d86e1ad8bd44',1,'s2let_n_px(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a8de2596044e8dbd481d0d86e1ad8bd44',1,'s2let_n_px(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fscal_170',['s2let_n_scal',['../s2let__helper_8c.html#a94202177168781d62964cfb09b568d77',1,'s2let_n_scal(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a94202177168781d62964cfb09b568d77',1,'s2let_n_scal(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5ftheta_171',['s2let_n_theta',['../s2let__helper_8c.html#a93ae2fb9184ae2bb35200063113b3db8',1,'s2let_n_theta(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a93ae2fb9184ae2bb35200063113b3db8',1,'s2let_n_theta(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fwav_172',['s2let_n_wav',['../s2let__helper_8c.html#aa267d575405f5aec34f642d7278ea15c',1,'s2let_n_wav(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aa267d575405f5aec34f642d7278ea15c',1,'s2let_n_wav(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fwav_5fj_173',['s2let_n_wav_j',['../s2let__helper_8c.html#a5489f45f63977ad580729370eeabd3c8',1,'s2let_n_wav_j(int j, const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a5489f45f63977ad580729370eeabd3c8',1,'s2let_n_wav_j(int j, const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fparameters_5ft_174',['s2let_parameters_t',['../structs2let__parameters__t.html',1,'']]], + ['s2let_5fsampling_5fmw_175',['S2LET_SAMPLING_MW',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea061a427ab87d0615aeea0bbc9ef5a8bc',1,'s2let_types.h']]], + ['s2let_5fsampling_5fmw_5fss_176',['S2LET_SAMPLING_MW_SS',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea4735249ce28fc1c5b443806760f8fcd8',1,'s2let_types.h']]], + ['s2let_5fsampling_5fmw_5fss_5fstr_177',['S2LET_SAMPLING_MW_SS_STR',['../s2let__mex_8h.html#aef877ec016bc062e71412e295efbe843',1,'s2let_mex.h']]], + ['s2let_5fsampling_5fmw_5fstr_178',['S2LET_SAMPLING_MW_STR',['../s2let__mex_8h.html#a965fb52ef2d665d3443bd08e8ec47548',1,'s2let_mex.h']]], + ['s2let_5fsampling_5fsize_179',['S2LET_SAMPLING_SIZE',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea1eb522fb952502e38119d2a315cce842',1,'s2let_types.h']]], + ['s2let_5fsampling_5ft_180',['s2let_sampling_t',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001e',1,'s2let_types.h']]], + ['s2let_5fso3_2eh_181',['s2let_so3.h',['../s2let__so3_8h.html',1,'']]], + ['s2let_5fso3_5fn_5forder_182',['S2LET_SO3_N_ORDER',['../s2let__so3_8h.html#a0c50a5de20f171c266985a92764153b3',1,'s2let_so3.h']]], + ['s2let_5fso3_5fstorage_183',['S2LET_SO3_STORAGE',['../s2let__so3_8h.html#a234c5518a86c602ca220a16b33dc2e22',1,'s2let_so3.h']]], + ['s2let_5fspin_5fdenoising_5fdemo_2ec_184',['s2let_spin_denoising_demo.c',['../s2let__spin__denoising__demo_8c.html',1,'']]], + ['s2let_5fstring_5flen_185',['S2LET_STRING_LEN',['../s2let__mex_8h.html#a3bd7f5fbd27ea58ab3a23a1eb7a6f4cd',1,'s2let_mex.h']]], + ['s2let_5fswitch_5fwavtype_186',['s2let_switch_wavtype',['../s2let__tiling_8c.html#a740dd43f4aeae426b96bd4488881297c',1,'s2let_switch_wavtype(int typenum): s2let_tiling.c'],['../s2let__tiling_8h.html#a740dd43f4aeae426b96bd4488881297c',1,'s2let_switch_wavtype(int typenum): s2let_tiling.c']]], + ['s2let_5fsynthesis_2ec_187',['s2let_synthesis.c',['../s2let__synthesis_8c.html',1,'']]], + ['s2let_5fsynthesis_2eh_188',['s2let_synthesis.h',['../s2let__synthesis_8h.html',1,'']]], + ['s2let_5fsynthesis_5fadjoint_2ec_189',['s2let_synthesis_adjoint.c',['../s2let__synthesis__adjoint_8c.html',1,'']]], + ['s2let_5fsynthesis_5fadjoint_2eh_190',['s2let_synthesis_adjoint.h',['../s2let__synthesis__adjoint_8h.html',1,'']]], + ['s2let_5fsynthesis_5fadjoint_5flm2lmn_191',['s2let_synthesis_adjoint_lm2lmn',['../s2let__synthesis__adjoint_8c.html#aa22074c5b8f3c6f93101bda21dd41477',1,'s2let_synthesis_adjoint_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#ab2e27bf29fd328e5737010a8e965a392',1,'s2let_synthesis_adjoint_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5flm2lmn_5freal_192',['s2let_synthesis_adjoint_lm2lmn_real',['../s2let__synthesis__adjoint_8c.html#a3b3ba86b4c6ccbea501743a31f0fbaba',1,'s2let_synthesis_adjoint_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a8f619d5750ea69d11f5a8a72e7789c5c',1,'s2let_synthesis_adjoint_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5flm2wav_193',['s2let_synthesis_adjoint_lm2wav',['../s2let__synthesis__adjoint_8c.html#a0ded78fd254dfcf523607af9d6384b04',1,'s2let_synthesis_adjoint_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a076501801b028f2c5a43b703afc55746',1,'s2let_synthesis_adjoint_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5flm2wav_5fmanual_194',['s2let_synthesis_adjoint_lm2wav_manual',['../s2let__synthesis__adjoint_8c.html#af1ad88c078072d2c2f9262ab60664627',1,'s2let_synthesis_adjoint_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a80993ff9162a6694085cad936b366c66',1,'s2let_synthesis_adjoint_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5flm2wav_5freal_195',['s2let_synthesis_adjoint_lm2wav_real',['../s2let__synthesis__adjoint_8c.html#a3d89c7c0fd47c34293d0c915e8680212',1,'s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a3ca845d22e3f872b584ba8078eebdf2c',1,'s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5fpx2wav_196',['s2let_synthesis_adjoint_px2wav',['../s2let__synthesis__adjoint_8c.html#af92b8ee7a5d7467aca1aadf574101ed1',1,'s2let_synthesis_adjoint_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#acb574fe4af36dac2771e323b23f038f5',1,'s2let_synthesis_adjoint_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5fpx2wav_5freal_197',['s2let_synthesis_adjoint_px2wav_real',['../s2let__synthesis__adjoint_8c.html#a8ac56364e5e11e70afdc89dcbdfa5e54',1,'s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a8ac56364e5e11e70afdc89dcbdfa5e54',1,'s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c']]], + ['s2let_5fsynthesis_5flmn2lm_198',['s2let_synthesis_lmn2lm',['../s2let__synthesis_8c.html#aeab2e51756b722c7fcb0246fa7bcf4e8',1,'s2let_synthesis_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a07acb11aa82e55efc3af49548de2c595',1,'s2let_synthesis_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5flmn2lm_5freal_199',['s2let_synthesis_lmn2lm_real',['../s2let__synthesis_8c.html#ae985651ea8c8225166983b660e15648e',1,'s2let_synthesis_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#adfeebcfa8d5032b78dd85634a5c32b1e',1,'s2let_synthesis_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2lm_200',['s2let_synthesis_wav2lm',['../s2let__synthesis_8c.html#ad898b41a0d83f31033c87f43339dccc2',1,'s2let_synthesis_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a69a72f4cf574108a313f7320b093beee',1,'s2let_synthesis_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2lm_5fmanual_201',['s2let_synthesis_wav2lm_manual',['../s2let__synthesis_8c.html#ae32a0ec051091cb18844e51d8d0ad7fd',1,'s2let_synthesis_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis.c'],['../s2let__synthesis_8h.html#ad3cd8f875820fc345277f57957f6ad40',1,'s2let_synthesis_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2lm_5freal_202',['s2let_synthesis_wav2lm_real',['../s2let__synthesis_8c.html#ab4592958d2f658ac6711edb3589a0d04',1,'s2let_synthesis_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a21c5e68bb92ff9cb6d50a2fd19213a2e',1,'s2let_synthesis_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2px_203',['s2let_synthesis_wav2px',['../s2let__synthesis_8c.html#a171869de60c6dba907994e24eb1ad568',1,'s2let_synthesis_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#aa051be81ee272ce0291f78b66170c5db',1,'s2let_synthesis_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2px_5freal_204',['s2let_synthesis_wav2px_real',['../s2let__synthesis_8c.html#a4ef1adffb439379ca652533588879ab5',1,'s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a4ef1adffb439379ca652533588879ab5',1,'s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c']]], + ['s2let_5ftest_2ec_205',['s2let_test.c',['../s2let__test_8c.html',1,'']]], + ['s2let_5ftest_5fcsv_2ec_206',['s2let_test_csv.c',['../s2let__test__csv_8c.html',1,'']]], + ['s2let_5ftests_207',['S2LET_TESTS',['../test__back__and__forth_8c.html#a47e61454d11e89fdf7bdfed2b12de0f5',1,'S2LET_TESTS(): test_back_and_forth.c'],['../test__back__and__forth_8c.html#a47e61454d11e89fdf7bdfed2b12de0f5',1,'S2LET_TESTS(): test_back_and_forth.c']]], + ['s2let_5ftiling_2ec_208',['s2let_tiling.c',['../s2let__tiling_8c.html',1,'']]], + ['s2let_5ftiling_2eh_209',['s2let_tiling.h',['../s2let__tiling_8h.html',1,'']]], + ['s2let_5ftiling_5faxisym_210',['s2let_tiling_axisym',['../s2let__tiling_8c.html#a2dcc3541cd5003f7c20189b5f1e569b0',1,'s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a2dcc3541cd5003f7c20189b5f1e569b0',1,'s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5ftiling_5faxisym_5fallocate_211',['s2let_tiling_axisym_allocate',['../s2let__tiling_8c.html#acfff04a4e1d0f2c422b2c0a22a01c9a9',1,'s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#acfff04a4e1d0f2c422b2c0a22a01c9a9',1,'s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5ftiling_5faxisym_5fcheck_5fidentity_212',['s2let_tiling_axisym_check_identity',['../s2let__tiling_8c.html#a895b0a2aed140ef5591af7ac630d6113',1,'s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a895b0a2aed140ef5591af7ac630d6113',1,'s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5ftiling_5faxisym_5ftest_213',['s2let_tiling_axisym_test',['../s2let__test_8c.html#a72ed78cf85c9437d0a2545c8e3a61cf2',1,'s2let_test.c']]], + ['s2let_5ftiling_5fdirection_214',['s2let_tiling_direction',['../s2let__tiling_8c.html#a4811cf4eadbebb73245f54b676734b17',1,'s2let_tiling_direction(complex double *s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ae2b1be4ee6ee593ccc3673bb8c8119a0',1,'s2let_tiling_direction(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fdirection_5fallocate_215',['s2let_tiling_direction_allocate',['../s2let__tiling_8c.html#a10fa29a59b170d6ade97303878faf7ef',1,'s2let_tiling_direction_allocate(complex double **s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a14a6f342214def49e0a4007425a85885',1,'s2let_tiling_direction_allocate(S2LET_COMPLEX(double) **s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fdirection_5fcheck_5fidentity_216',['s2let_tiling_direction_check_identity',['../s2let__tiling_8c.html#ab69e82a484169f248873ae9ccb5bb89a',1,'s2let_tiling_direction_check_identity(complex double *s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a57fea5748d955b5caa9ddf46cda3036b',1,'s2let_tiling_direction_check_identity(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fdirection_5ftest_217',['s2let_tiling_direction_test',['../s2let__test_8c.html#a84ab4ae94142563376cc58ce9b3f0529',1,'s2let_test.c']]], + ['s2let_5ftiling_5fphi2_5fneedlet_218',['s2let_tiling_phi2_needlet',['../s2let__tiling_8c.html#aa9f045a72ccf0df8bff4a8a245ecc52a',1,'s2let_tiling.c']]], + ['s2let_5ftiling_5fphi2_5fs2dw_219',['s2let_tiling_phi2_s2dw',['../s2let__tiling_8c.html#a255c8db4bb8f33e546d44e2b96fd4eb5',1,'s2let_tiling.c']]], + ['s2let_5ftiling_5fphi2_5fspline_220',['s2let_tiling_phi2_spline',['../s2let__tiling_8c.html#afd4de938c00ee3cbde3e6e10944a496b',1,'s2let_tiling.c']]], + ['s2let_5ftiling_5fwavelet_221',['s2let_tiling_wavelet',['../s2let__tiling_8c.html#a9878fae074371b64e7de24ebfdbd752c',1,'s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ae0e09c45e6d87dee84f94bb04b6215d8',1,'s2let_tiling_wavelet(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fwavelet_5fallocate_222',['s2let_tiling_wavelet_allocate',['../s2let__tiling_8c.html#af1770bfbe7ff5ead2769089867a03fbb',1,'s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#af5491812d40095dfbab3c08edf4d9fa5',1,'s2let_tiling_wavelet_allocate(S2LET_COMPLEX(double) **psi, double **phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fwavelet_5fcheck_5fidentity_223',['s2let_tiling_wavelet_check_identity',['../s2let__tiling_8c.html#abd52d0b819985f55fe6fca8259597b48',1,'s2let_tiling_wavelet_check_identity(complex double *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a9a4117a039022f6fff78939c4e0f3a86',1,'s2let_tiling_wavelet_check_identity(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fwavelet_5ftest_224',['s2let_tiling_wavelet_test',['../s2let__test_8c.html#ad612b1930b2a90f6bb8b507f6dc2ae4d',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fhpx_5ff_5fwav_5freal_225',['s2let_transform_axisym_allocate_hpx_f_wav_real',['../s2let__transform__axisym__hpx_8c.html#a8d0f962069938cdf19c4ad1cce2862f8',1,'s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#a8d0f962069938cdf19c4ad1cce2862f8',1,'s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_226',['s2let_transform_axisym_allocate_mw_f_wav',['../s2let__transform__axisym__mw_8c.html#abdb0070e4e2f67007c6755020cbf3f76',1,'s2let_transform_axisym_allocate_mw_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aa0ce4a50c9b076757a1360030dc00c9e',1,'s2let_transform_axisym_allocate_mw_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5fmultires_227',['s2let_transform_axisym_allocate_mw_f_wav_multires',['../s2let__transform__axisym__mw_8c.html#a34f35be55f0d7920e66ffa96948b7132',1,'s2let_transform_axisym_allocate_mw_f_wav_multires(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a0c9e93d33296d57f7722d91288606268',1,'s2let_transform_axisym_allocate_mw_f_wav_multires(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5fmultires_5freal_228',['s2let_transform_axisym_allocate_mw_f_wav_multires_real',['../s2let__transform__axisym__mw_8c.html#aaf2dc03fea7d12bf85c36ecb827c67f1',1,'s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aaf2dc03fea7d12bf85c36ecb827c67f1',1,'s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5freal_229',['s2let_transform_axisym_allocate_mw_f_wav_real',['../s2let__transform__axisym__mw_8c.html#a71d7ea7def45be0508e37eb4789a42be',1,'s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a71d7ea7def45be0508e37eb4789a42be',1,'s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fanalysis_5fhpx_5freal_2ec_230',['s2let_transform_axisym_analysis_hpx_real.c',['../s2let__transform__axisym__analysis__hpx__real_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fanalysis_5fmw_5freal_2ec_231',['s2let_transform_axisym_analysis_mw_real.c',['../s2let__transform__axisym__analysis__mw__real_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fhpx_2ec_232',['s2let_transform_axisym_hpx.c',['../s2let__transform__axisym__hpx_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fhpx_2eh_233',['s2let_transform_axisym_hpx.h',['../s2let__transform__axisym__hpx_8h.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fhpx_5ftest_234',['s2let_transform_axisym_hpx_test',['../s2let__hpx__test_8c.html#a967b49df6d8f162875b8fd691fc5673e',1,'s2let_hpx_test.c']]], + ['s2let_5ftransform_5faxisym_5fhpx_5fwav_5ftest_235',['s2let_transform_axisym_hpx_wav_test',['../s2let__hpx__test_8c.html#ae0c6235281f47c3580a082a8ff6442a0',1,'s2let_hpx_test.c']]], + ['s2let_5ftransform_5faxisym_5flm_2ec_236',['s2let_transform_axisym_lm.c',['../s2let__transform__axisym__lm_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5flm_2eh_237',['s2let_transform_axisym_lm.h',['../s2let__transform__axisym__lm_8h.html',1,'']]], + ['s2let_5ftransform_5faxisym_5flm_5fallocate_5ff_5fwav_238',['s2let_transform_axisym_lm_allocate_f_wav',['../s2let__transform__axisym__lm_8c.html#a27717c57665b77ad3f6f5aef35c1c9e4',1,'s2let_transform_axisym_lm_allocate_f_wav(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a6ed8eae362ffc710e4f256f4a2c7a59c',1,'s2let_transform_axisym_lm_allocate_f_wav(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fallocate_5ff_5fwav_5fmultires_239',['s2let_transform_axisym_lm_allocate_f_wav_multires',['../s2let__transform__axisym__lm_8c.html#a53fc1d52b6e959e2d2a23319237c9087',1,'s2let_transform_axisym_lm_allocate_f_wav_multires(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a49deaad455c0f37f085794a95bc2cc8f',1,'s2let_transform_axisym_lm_allocate_f_wav_multires(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fallocate_5fwav_240',['s2let_transform_axisym_lm_allocate_wav',['../s2let__transform__axisym__lm_8c.html#ae5c57282bb1116eababa279c2f8757a9',1,'s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#ae5c57282bb1116eababa279c2f8757a9',1,'s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_241',['s2let_transform_axisym_lm_wav',['../s2let__transform__axisym__lm_8c.html#a2efd3fe3938b0f6cb3166804f0ca62bc',1,'s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a2efd3fe3938b0f6cb3166804f0ca62bc',1,'s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fanalysis_242',['s2let_transform_axisym_lm_wav_analysis',['../s2let__transform__axisym__lm_8c.html#a1363fa22f22fe3faf9601fc4d8dc2185',1,'s2let_transform_axisym_lm_wav_analysis(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#ac7bd36f0e12ae8e06d7f1e8c4c0c1f9e',1,'s2let_transform_axisym_lm_wav_analysis(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fanalysis_5fmultires_243',['s2let_transform_axisym_lm_wav_analysis_multires',['../s2let__transform__axisym__lm_8c.html#ac55ab672138aa0703ba3b3d24a6673c0',1,'s2let_transform_axisym_lm_wav_analysis_multires(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a41cd8c62327019175b700208d2891464',1,'s2let_transform_axisym_lm_wav_analysis_multires(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fmultires_5ftest_244',['s2let_transform_axisym_lm_wav_multires_test',['../s2let__test_8c.html#a6490580b66410b64846b31124ae5a0f4',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fsynthesis_245',['s2let_transform_axisym_lm_wav_synthesis',['../s2let__transform__axisym__lm_8c.html#a288f88b4dd18d732a0d6819c4d06e3f4',1,'s2let_transform_axisym_lm_wav_synthesis(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#acaad9856b9ff5ea5588fff2a796a8ecf',1,'s2let_transform_axisym_lm_wav_synthesis(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fsynthesis_5fmultires_246',['s2let_transform_axisym_lm_wav_synthesis_multires',['../s2let__transform__axisym__lm_8c.html#ad31585dbae5edde3fc3704a59cbe1034',1,'s2let_transform_axisym_lm_wav_synthesis_multires(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a1cf1b759d1947fea4f100a80d8a420aa',1,'s2let_transform_axisym_lm_wav_synthesis_multires(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5ftest_247',['s2let_transform_axisym_lm_wav_test',['../s2let__test_8c.html#a21e0d56f5074c798cb77ee9ccf081e3c',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fmw_2ec_248',['s2let_transform_axisym_mw.c',['../s2let__transform__axisym__mw_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fmw_2eh_249',['s2let_transform_axisym_mw.h',['../s2let__transform__axisym__mw_8h.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fsynthesis_5fhpx_5freal_2ec_250',['s2let_transform_axisym_synthesis_hpx_real.c',['../s2let__transform__axisym__synthesis__hpx__real_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fsynthesis_5fmw_5freal_2ec_251',['s2let_transform_axisym_synthesis_mw_real.c',['../s2let__transform__axisym__synthesis__mw__real_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5fmultires_5ftest_252',['s2let_transform_axisym_vs_directional_mw_multires_test',['../s2let__test_8c.html#a4942f2f69c0519399f61579dc47d98d2',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5ftest_253',['s2let_transform_axisym_vs_directional_mw_test',['../s2let__test_8c.html#a45c632c898e73d473bcc38e492847182',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_254',['s2let_transform_axisym_wav_analysis_adjoint_mw',['../s2let__transform__axisym__mw_8c.html#a73b9085432c8673c6fde059b708dea46',1,'s2let_transform_axisym_wav_analysis_adjoint_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#afca147888501702b34ca4e1767c78710',1,'s2let_transform_axisym_wav_analysis_adjoint_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5fmultires_255',['s2let_transform_axisym_wav_analysis_adjoint_mw_multires',['../s2let__transform__axisym__mw_8c.html#abbbb0b8729b4b4d936723f57fa133bde',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a516ee27f27eb79de7c3214cab7271779',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5fmultires_5freal_256',['s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#ad16f124ef82ba5422107d53991578e2b',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ad16f124ef82ba5422107d53991578e2b',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5freal_257',['s2let_transform_axisym_wav_analysis_adjoint_mw_real',['../s2let__transform__axisym__mw_8c.html#a9d190e3dc17c1e73036fa7def51baf44',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a9d190e3dc17c1e73036fa7def51baf44',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fhpx_5freal_258',['s2let_transform_axisym_wav_analysis_hpx_real',['../s2let__transform__axisym__hpx_8c.html#a3f69c1366658007590fc63877230d1a7',1,'s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#a3f69c1366658007590fc63877230d1a7',1,'s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_259',['s2let_transform_axisym_wav_analysis_mw',['../s2let__transform__axisym__mw_8c.html#a866080c7ca98673e75acaf8f384ea936',1,'s2let_transform_axisym_wav_analysis_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ac768b473723b5e525c959deb48e08825',1,'s2let_transform_axisym_wav_analysis_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_260',['s2let_transform_axisym_wav_analysis_mw_multires',['../s2let__transform__axisym__mw_8c.html#a272edc957f57772f4af7161c4776f118',1,'s2let_transform_axisym_wav_analysis_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aec92f0a5f1bf3d14ed9dcdadd96153c3',1,'s2let_transform_axisym_wav_analysis_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_5freal_261',['s2let_transform_axisym_wav_analysis_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#abbaca141c3699c766e341c5ceee14cdb',1,'s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abbaca141c3699c766e341c5ceee14cdb',1,'s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5freal_262',['s2let_transform_axisym_wav_analysis_mw_real',['../s2let__transform__axisym__mw_8c.html#abab7d46ecc4813503ab0fd5f09d8bfa7',1,'s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abab7d46ecc4813503ab0fd5f09d8bfa7',1,'s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fhardthreshold_5fmultires_5freal_263',['s2let_transform_axisym_wav_hardthreshold_multires_real',['../s2let__transform__axisym__mw_8c.html#ab3b3272365c739034b2c5c8fc00613a9',1,'s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ab3b3272365c739034b2c5c8fc00613a9',1,'s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fhardthreshold_5freal_264',['s2let_transform_axisym_wav_hardthreshold_real',['../s2let__transform__axisym__mw_8c.html#af2f861872a0b6640d8e24202a451272f',1,'s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#af2f861872a0b6640d8e24202a451272f',1,'s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fmultires_5freal_5ftest_265',['s2let_transform_axisym_wav_multires_real_test',['../s2let__test_8c.html#a30b6b4ec19a7bc9c3bb7fb3b933e6c94',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fmultires_5ftest_266',['s2let_transform_axisym_wav_multires_test',['../s2let__test_8c.html#ac20052515fa751c919b54fb6bfb7b5a1',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5freal_5ftest_267',['s2let_transform_axisym_wav_real_test',['../s2let__test_8c.html#a42ef36d238046edb1b4a03e2269797f2',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_268',['s2let_transform_axisym_wav_synthesis_adjoint_mw',['../s2let__transform__axisym__mw_8c.html#a333120eb88ad818a3e360c1004c3d1e8',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a595657bb4bf8ac9d99afe415539eff8e',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5fmultires_269',['s2let_transform_axisym_wav_synthesis_adjoint_mw_multires',['../s2let__transform__axisym__mw_8c.html#a9d4cb0b9b608e1956058899cfba58280',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ac2b1764294b14d89aad77c8473d70e92',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5fmultires_5freal_270',['s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#abcfc455a2b4dfd52f52d095227ff67c3',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abcfc455a2b4dfd52f52d095227ff67c3',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_271',['s2let_transform_axisym_wav_synthesis_adjoint_mw_real',['../s2let__transform__axisym__mw_8c.html#a202737e2b30d90af7984051d82e6b55a',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a202737e2b30d90af7984051d82e6b55a',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fhpx_5freal_272',['s2let_transform_axisym_wav_synthesis_hpx_real',['../s2let__transform__axisym__hpx_8c.html#ad1987cd08f8add08bba681aa26c32b77',1,'s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#ad1987cd08f8add08bba681aa26c32b77',1,'s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_273',['s2let_transform_axisym_wav_synthesis_mw',['../s2let__transform__axisym__mw_8c.html#ab2dba22615138e520985ca58ead38e28',1,'s2let_transform_axisym_wav_synthesis_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a26507106a70d5143e76fba3bb298f7e7',1,'s2let_transform_axisym_wav_synthesis_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_274',['s2let_transform_axisym_wav_synthesis_mw_multires',['../s2let__transform__axisym__mw_8c.html#a002718ed6a64a6d7268626e01931ecba',1,'s2let_transform_axisym_wav_synthesis_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a988074918fff2d3f06b6898542ba1072',1,'s2let_transform_axisym_wav_synthesis_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_5freal_275',['s2let_transform_axisym_wav_synthesis_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#a9a77993fec7b5b26a0290ade7623c1ea',1,'s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a9a77993fec7b5b26a0290ade7623c1ea',1,'s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5freal_276',['s2let_transform_axisym_wav_synthesis_mw_real',['../s2let__transform__axisym__mw_8c.html#a5eec6f7cb23d0ffb408abc583153d496',1,'s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a5eec6f7cb23d0ffb408abc583153d496',1,'s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5ftest_277',['s2let_transform_axisym_wav_test',['../s2let__test_8c.html#a4f77ce64b0ecb6acdfeb8cd03b5b4d19',1,'s2let_test.c']]], + ['s2let_5ftransform_5flm_5fperformance_5fmultires_5ftest_278',['s2let_transform_lm_performance_multires_test',['../s2let__test_8c.html#a601830de99f48906fcfe6b53907bb190',1,'s2let_test.c']]], + ['s2let_5ftransform_5flm_5fperformance_5ftest_279',['s2let_transform_lm_performance_test',['../s2let__test_8c.html#a677d7f0b1315a8f13a3ecd057a928372',1,'s2let_test.c']]], + ['s2let_5ftransform_5fperformance_5fmultires_5ftest_280',['s2let_transform_performance_multires_test',['../s2let__test_8c.html#a6707d377e1f45cf08f165f35f9b4f4cc',1,'s2let_test.c']]], + ['s2let_5ftransform_5fperformance_5ftest_281',['s2let_transform_performance_test',['../s2let__test_8c.html#abf6416ad05d8f169fc6eadb5a9ad537d',1,'s2let_test.c']]], + ['s2let_5ftypes_2eh_282',['s2let_types.h',['../s2let__types_8h.html',1,'']]], + ['s2let_5fwav_5fanalysis_5fadjoint_5flm_5flmn_5ftest_283',['s2let_wav_analysis_adjoint_lm_lmn_test',['../s2let__test_8c.html#afc35303ba9eb6beeee088d9f08c3444c',1,'s2let_test.c']]], + ['s2let_5fwav_5fanalysis_5fadjoint_5fmw_5freal_5ftest_284',['s2let_wav_analysis_adjoint_mw_real_test',['../s2let__test_8c.html#a07e8d14353d7a404098560c1a9db92fe',1,'s2let_test.c']]], + ['s2let_5fwav_5fanalysis_5fadjoint_5fmw_5ftest_285',['s2let_wav_analysis_adjoint_mw_test',['../s2let__test_8c.html#a4b3a9612e87e483e27bff0888bd964a0',1,'s2let_test.c']]], + ['s2let_5fwav_5fso3_5fforward_5fadjoint_5ftest_286',['s2let_wav_so3_forward_adjoint_test',['../s2let__test_8c.html#ac85f518078a76b2dd77de9ccc9f34f07',1,'s2let_test.c']]], + ['s2let_5fwav_5fsynthesis_5fadjoint_5flm2wav_5ftest_287',['s2let_wav_synthesis_adjoint_lm2wav_test',['../s2let__test_8c.html#ae9c1885807e8ac48440a0b0d3dd2a667',1,'s2let_test.c']]], + ['s2let_5fwav_5fsynthesis_5fadjoint_5flm_5flmn_5ftest_288',['s2let_wav_synthesis_adjoint_lm_lmn_test',['../s2let__test_8c.html#a33ed7d71c1e2543ab0ec5d5034a0269f',1,'s2let_test.c']]], + ['s2let_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_5ftest_289',['s2let_wav_synthesis_adjoint_mw_real_test',['../s2let__test_8c.html#a5185ca4b0f65740ab88242cff55b796d',1,'s2let_test.c']]], + ['s2let_5fwav_5fsynthesis_5fadjoint_5fmw_5ftest_290',['s2let_wav_synthesis_adjoint_mw_test',['../s2let__test_8c.html#a1bb00b26cbe0fbb23f41778220fa5824',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fharmonic_5fmultires_5ftest_291',['s2let_wav_transform_harmonic_multires_test',['../s2let__test_8c.html#a9a6c059a89a24d1faf87c71d4daa0aad',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fharmonic_5ftest_292',['s2let_wav_transform_harmonic_test',['../s2let__test_8c.html#a36c393819821e9d3230f1b611029c03a',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5flm2wav_5fmultires_5freal_5ftest_293',['s2let_wav_transform_lm2wav_multires_real_test',['../s2let__test_8c.html#a97581c49341c7cd099bde20868fc7cd6',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5flm2wav_5fmultires_5ftest_294',['s2let_wav_transform_lm2wav_multires_test',['../s2let__test_8c.html#af37a0a8300c436e3de4404914b06644b',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5flm2wav_5freal_5ftest_295',['s2let_wav_transform_lm2wav_real_test',['../s2let__test_8c.html#a4631a44a831e086e712e9f1aa7ffab62',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5flm2wav_5ftest_296',['s2let_wav_transform_lm2wav_test',['../s2let__test_8c.html#a2cf679450a2ce6ea636c2dc10f7e540a',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmw_5fmultires_5freal_5ftest_297',['s2let_wav_transform_mw_multires_real_test',['../s2let__test_8c.html#a4d1b3d1c528a9251c2f7ca5841b7ea4c',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmw_5fmultires_5ftest_298',['s2let_wav_transform_mw_multires_test',['../s2let__test_8c.html#a8e3ae237fa88d72d1dbd073219148d14',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmw_5freal_5ftest_299',['s2let_wav_transform_mw_real_test',['../s2let__test_8c.html#a8c730406b8d674ce01adf2f00b23a80b',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmw_5ftest_300',['s2let_wav_transform_mw_test',['../s2let__test_8c.html#ac21ea0848f541e57646992df1f019ac6',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmwss_5fmultires_5freal_5ftest_301',['s2let_wav_transform_mwss_multires_real_test',['../s2let__test_8c.html#a98871d63a676332bf18fa0e759ed7b75',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmwss_5fmultires_5ftest_302',['s2let_wav_transform_mwss_multires_test',['../s2let__test_8c.html#a47c841b99612070b47ad9cc82e15381f',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmwss_5freal_5ftest_303',['s2let_wav_transform_mwss_real_test',['../s2let__test_8c.html#a0405e044e4b231f44c78768efa065da2',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmwss_5ftest_304',['s2let_wav_transform_mwss_test',['../s2let__test_8c.html#a50a13ab98a0345f3d9d66d4252f6b4c6',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fwavlm_5fmanual_5ftest_305',['s2let_wav_transform_wavlm_manual_test',['../s2let__test_8c.html#a73199654867cc48b0fdfa593987dfecd',1,'s2let_test.c']]], + ['sampling_5fscheme_306',['sampling_scheme',['../structs2let__parameters__t.html#a32942243b855116a10cc6b8b81a90b87',1,'s2let_parameters_t']]], + ['seed_307',['seed',['../test__adjoint_8c.html#ab1633aa266a0a720540840343194b2cf',1,'seed(): test_adjoint.c'],['../test__axisym__vs__directional_8c.html#ab1633aa266a0a720540840343194b2cf',1,'seed(): test_axisym_vs_directional.c'],['../test__back__and__forth_8c.html#ab1633aa266a0a720540840343194b2cf',1,'seed(): test_back_and_forth.c'],['../test__tiling_8c.html#ab1633aa266a0a720540840343194b2cf',1,'seed(): test_tiling.c']]], + ['so3_5ftest_5fgen_5fflmn_5fcomplex_308',['so3_test_gen_flmn_complex',['../s2let__test_8c.html#af5b2cded1bb3914d1398df3b65eec310',1,'s2let_test.c']]], + ['spin_309',['spin',['../structs2let__parameters__t.html#a4fd720e3d7a947dab5bbfd0f51c3dcf7',1,'s2let_parameters_t']]], + ['spline_310',['SPLINE',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aa4d8b3b9406a35793dead4b293d793463',1,'s2let_tiling.c']]] ]; diff --git a/docs/c/search/all_f.js b/docs/c/search/all_f.js index 93bcb019..3ba2a7dc 100644 --- a/docs/c/search/all_f.js +++ b/docs/c/search/all_f.js @@ -1,4 +1,35 @@ var searchData= [ - ['upsample_308',['upsample',['../structs2let__parameters__t.html#aec567c0f2af65ec246fd92169ae66216',1,'s2let_parameters_t']]] + ['test_5fadjoint_2ec_311',['test_adjoint.c',['../test__adjoint_8c.html',1,'']]], + ['test_5faxisym_5fvs_5fdirectional_2ec_312',['test_axisym_vs_directional.c',['../test__axisym__vs__directional_8c.html',1,'']]], + ['test_5fback_5fand_5fforth_2ec_313',['test_back_and_forth.c',['../test__back__and__forth_8c.html',1,'']]], + ['test_5fbinomial_5fcoefficient_314',['test_binomial_coefficient',['../test__tiling_8c.html#ae9633e0907423f3621ab89db8eedb2cf',1,'test_tiling.c']]], + ['test_5ftiling_2ec_315',['test_tiling.c',['../test__tiling_8c.html',1,'']]], + ['test_5ftiling_5faxisym_316',['test_tiling_axisym',['../test__tiling_8c.html#a766f233806aaf9dd4e5fd864a2d810ee',1,'test_tiling.c']]], + ['test_5ftiling_5fdirection_317',['test_tiling_direction',['../test__tiling_8c.html#a4426878c26a0df52d562feb10a53a245',1,'test_tiling.c']]], + ['test_5ftiling_5fwavelet_318',['test_tiling_wavelet',['../test__tiling_8c.html#af21971543325f94b463757410edb0934',1,'test_tiling.c']]], + ['test_5ftransform_5faxisym_5flm_5fwav_319',['test_transform_axisym_lm_wav',['../test__back__and__forth_8c.html#ac9fcf3f5e4a2970da3b8e26e9b74c793',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5flm_5fwav_5fmultires_320',['test_transform_axisym_lm_wav_multires',['../test__back__and__forth_8c.html#a8ad18ca9179f167ba7a0d2515d8342f1',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_321',['test_transform_axisym_vs_directional_mw',['../test__axisym__vs__directional_8c.html#a74a283fc358f339a01d275f417c18e5d',1,'test_axisym_vs_directional.c']]], + ['test_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5fmultires_322',['test_transform_axisym_vs_directional_mw_multires',['../test__axisym__vs__directional_8c.html#ac97d3aa9eae5e240ca1d26dfda792e53',1,'test_axisym_vs_directional.c']]], + ['test_5ftransform_5faxisym_5fwav_323',['test_transform_axisym_wav',['../test__back__and__forth_8c.html#ab2e4e00c1d588b41ac24a8f4a94d6ad3',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5fwav_5fmultires_324',['test_transform_axisym_wav_multires',['../test__back__and__forth_8c.html#a0256cd509855748cdc48a79b423a041f',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5fwav_5fmultires_5freal_325',['test_transform_axisym_wav_multires_real',['../test__back__and__forth_8c.html#a7961f39862c9aa8a6fc65bd464b35bde',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5fwav_5freal_326',['test_transform_axisym_wav_real',['../test__back__and__forth_8c.html#a85921a6d1ef89b58d29ba1af7850bcd9',1,'test_back_and_forth.c']]], + ['test_5fwav_5fanalysis_5fadjoint_5flm_5flmn_327',['test_wav_analysis_adjoint_lm_lmn',['../test__adjoint_8c.html#ab09db2e87f3420892c200883fb9b9832',1,'test_adjoint.c']]], + ['test_5fwav_5fanalysis_5fadjoint_5fmw_328',['test_wav_analysis_adjoint_mw',['../test__adjoint_8c.html#a3d8bdd542273324689a6fccc7825992c',1,'test_adjoint.c']]], + ['test_5fwav_5fanalysis_5fadjoint_5fmw_5freal_329',['test_wav_analysis_adjoint_mw_real',['../test__adjoint_8c.html#a2d8f0d747f020308b003fdeb2d4b71cb',1,'test_adjoint.c']]], + ['test_5fwav_5fso3_5fforward_5fadjoint_330',['test_wav_so3_forward_adjoint',['../test__adjoint_8c.html#a0f720411753473e254fa74262847339a',1,'test_adjoint.c']]], + ['test_5fwav_5fsynthesis_5fadjoint_5flm2wav_331',['test_wav_synthesis_adjoint_lm2wav',['../test__adjoint_8c.html#ab774b4e999bca9dab81e71421ec1b260',1,'test_adjoint.c']]], + ['test_5fwav_5fsynthesis_5fadjoint_5flm_5flmn_332',['test_wav_synthesis_adjoint_lm_lmn',['../test__adjoint_8c.html#a6bdc8ebb47ecadfb1e927559bebcf640',1,'test_adjoint.c']]], + ['test_5fwav_5fsynthesis_5fadjoint_5fmw_333',['test_wav_synthesis_adjoint_mw',['../test__adjoint_8c.html#aab877161b784a8fc242165b4173a5946',1,'test_adjoint.c']]], + ['test_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_334',['test_wav_synthesis_adjoint_mw_real',['../test__adjoint_8c.html#aed4d5ce08f37d79963730384439d5374',1,'test_adjoint.c']]], + ['test_5fwav_5ftransform_5fharmonic_335',['test_wav_transform_harmonic',['../test__back__and__forth_8c.html#abd77fc8c1591ee0376ac0cec3e0d9885',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5flm2wav_336',['test_wav_transform_lm2wav',['../test__back__and__forth_8c.html#aebab0b3d5193306db3a6e582c0d64a60',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5flm2wav_5freal_337',['test_wav_transform_lm2wav_real',['../test__back__and__forth_8c.html#a15d9a645d273a8487b2600d0a2d3f9b2',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fmw_338',['test_wav_transform_mw',['../test__back__and__forth_8c.html#a67571ae3b17fc9049b368e3c7b143689',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fmw_5freal_339',['test_wav_transform_mw_real',['../test__back__and__forth_8c.html#adedc312c4297f635233796f342a4f18e',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fmwss_340',['test_wav_transform_mwss',['../test__back__and__forth_8c.html#a96352af103febda3ace5d6484941b55a',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fmwss_5freal_341',['test_wav_transform_mwss_real',['../test__back__and__forth_8c.html#acd882d430247a801681dc151fd3a6189',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fwavlm_5fmanual_342',['test_wav_transform_wavlm_manual',['../test__back__and__forth_8c.html#aed300dd664e565c23cb0bf24a0eecc47',1,'test_back_and_forth.c']]] ]; diff --git a/docs/c/search/classes_0.js b/docs/c/search/classes_0.js index 0e06a725..e7c09617 100644 --- a/docs/c/search/classes_0.js +++ b/docs/c/search/classes_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['s2let_5fparameters_5ft_312',['s2let_parameters_t',['../structs2let__parameters__t.html',1,'']]] + ['s2let_5fparameters_5ft_347',['s2let_parameters_t',['../structs2let__parameters__t.html',1,'']]] ]; diff --git a/docs/c/search/defines_0.js b/docs/c/search/defines_0.js index b049b6fa..f252cef4 100644 --- a/docs/c/search/defines_0.js +++ b/docs/c/search/defines_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['abs_609',['ABS',['../s2let__math_8h.html#ae2f08dc603ae93c402abd918ba4e23e1',1,'s2let_math.h']]] + ['abs_679',['ABS',['../s2let__math_8h.html#ae2f08dc603ae93c402abd918ba4e23e1',1,'s2let_math.h']]] ]; diff --git a/docs/c/search/defines_1.js b/docs/c/search/defines_1.js index 7905a7d0..2a5ef7e6 100644 --- a/docs/c/search/defines_1.js +++ b/docs/c/search/defines_1.js @@ -1,5 +1,5 @@ var searchData= [ - ['idl_5fsizeof_5fc_5flong_610',['IDL_SIZEOF_C_LONG',['../s2let__idl__hpx_8c.html#a313037b4edc7817a7a40c3a4615ebdfa',1,'IDL_SIZEOF_C_LONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a313037b4edc7817a7a40c3a4615ebdfa',1,'IDL_SIZEOF_C_LONG(): s2let_idl_mw.c']]], - ['idl_5fsizeof_5fc_5fptr_611',['IDL_SIZEOF_C_PTR',['../s2let__idl__hpx_8c.html#a40d088f282782bc6c35262aea13548c6',1,'IDL_SIZEOF_C_PTR(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a40d088f282782bc6c35262aea13548c6',1,'IDL_SIZEOF_C_PTR(): s2let_idl_mw.c']]] + ['idl_5fsizeof_5fc_5flong_680',['IDL_SIZEOF_C_LONG',['../s2let__idl__hpx_8c.html#a313037b4edc7817a7a40c3a4615ebdfa',1,'IDL_SIZEOF_C_LONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a313037b4edc7817a7a40c3a4615ebdfa',1,'IDL_SIZEOF_C_LONG(): s2let_idl_mw.c']]], + ['idl_5fsizeof_5fc_5fptr_681',['IDL_SIZEOF_C_PTR',['../s2let__idl__hpx_8c.html#a40d088f282782bc6c35262aea13548c6',1,'IDL_SIZEOF_C_PTR(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a40d088f282782bc6c35262aea13548c6',1,'IDL_SIZEOF_C_PTR(): s2let_idl_mw.c']]] ]; diff --git a/docs/c/search/defines_2.js b/docs/c/search/defines_2.js index 8ffaee63..e12fc949 100644 --- a/docs/c/search/defines_2.js +++ b/docs/c/search/defines_2.js @@ -1,5 +1,5 @@ var searchData= [ - ['max_612',['MAX',['../s2let__math_8h.html#afa99ec4acc4ecb2dc3c2d05da15d0e3f',1,'s2let_math.h']]], - ['min_613',['MIN',['../s2let__math_8h.html#a3acffbd305ee72dcd4593c0d8af64a4f',1,'s2let_math.h']]] + ['max_682',['MAX',['../s2let__math_8h.html#afa99ec4acc4ecb2dc3c2d05da15d0e3f',1,'s2let_math.h']]], + ['min_683',['MIN',['../s2let__math_8h.html#a3acffbd305ee72dcd4593c0d8af64a4f',1,'s2let_math.h']]] ]; diff --git a/docs/c/search/defines_3.js b/docs/c/search/defines_3.js index cce6dd97..f0ca87ea 100644 --- a/docs/c/search/defines_3.js +++ b/docs/c/search/defines_3.js @@ -1,4 +1,4 @@ var searchData= [ - ['nrepeat_614',['NREPEAT',['../s2let__test__csv_8c.html#a9fa6466347dd349266768c7f7f0b0e4e',1,'s2let_test_csv.c']]] + ['nrepeat_684',['NREPEAT',['../s2let__test__csv_8c.html#a9fa6466347dd349266768c7f7f0b0e4e',1,'s2let_test_csv.c']]] ]; diff --git a/docs/c/search/defines_4.js b/docs/c/search/defines_4.js index 34803db0..17d438ad 100644 --- a/docs/c/search/defines_4.js +++ b/docs/c/search/defines_4.js @@ -1,4 +1,4 @@ var searchData= [ - ['pi_615',['PI',['../s2let__math_8h.html#a598a3330b3c21701223ee0ca14316eca',1,'PI(): s2let_math.h'],['../s2let__tiling_8h.html#a598a3330b3c21701223ee0ca14316eca',1,'PI(): s2let_tiling.h']]] + ['pi_685',['PI',['../s2let__math_8h.html#a598a3330b3c21701223ee0ca14316eca',1,'PI(): s2let_math.h'],['../s2let__tiling_8h.html#a598a3330b3c21701223ee0ca14316eca',1,'PI(): s2let_tiling.h']]] ]; diff --git a/docs/c/search/defines_5.js b/docs/c/search/defines_5.js index 06241d06..903a6935 100644 --- a/docs/c/search/defines_5.js +++ b/docs/c/search/defines_5.js @@ -1,11 +1,12 @@ var searchData= [ - ['s2let_5fcomplex_616',['S2LET_COMPLEX',['../s2let__types_8h.html#a121c8622035e81912b4b85b436b4ec6d',1,'s2let_types.h']]], - ['s2let_5ferror_5fgeneric_617',['S2LET_ERROR_GENERIC',['../s2let__error_8h.html#a740f1ee53df6b15f6ca098bb9163c1fc',1,'s2let_error.h']]], - ['s2let_5ferror_5fmem_5falloc_5fcheck_618',['S2LET_ERROR_MEM_ALLOC_CHECK',['../s2let__error_8h.html#a74500ae1fd825972a4508c643173c763',1,'s2let_error.h']]], - ['s2let_5fsampling_5fmw_5fss_5fstr_619',['S2LET_SAMPLING_MW_SS_STR',['../s2let__mex_8h.html#aef877ec016bc062e71412e295efbe843',1,'s2let_mex.h']]], - ['s2let_5fsampling_5fmw_5fstr_620',['S2LET_SAMPLING_MW_STR',['../s2let__mex_8h.html#a965fb52ef2d665d3443bd08e8ec47548',1,'s2let_mex.h']]], - ['s2let_5fso3_5fn_5forder_621',['S2LET_SO3_N_ORDER',['../s2let__so3_8h.html#a0c50a5de20f171c266985a92764153b3',1,'s2let_so3.h']]], - ['s2let_5fso3_5fstorage_622',['S2LET_SO3_STORAGE',['../s2let__so3_8h.html#a234c5518a86c602ca220a16b33dc2e22',1,'s2let_so3.h']]], - ['s2let_5fstring_5flen_623',['S2LET_STRING_LEN',['../s2let__mex_8h.html#a3bd7f5fbd27ea58ab3a23a1eb7a6f4cd',1,'s2let_mex.h']]] + ['s2let_5fcomplex_686',['S2LET_COMPLEX',['../s2let__types_8h.html#a121c8622035e81912b4b85b436b4ec6d',1,'s2let_types.h']]], + ['s2let_5ferror_5fgeneric_687',['S2LET_ERROR_GENERIC',['../s2let__error_8h.html#a740f1ee53df6b15f6ca098bb9163c1fc',1,'s2let_error.h']]], + ['s2let_5ferror_5fmem_5falloc_5fcheck_688',['S2LET_ERROR_MEM_ALLOC_CHECK',['../s2let__error_8h.html#a74500ae1fd825972a4508c643173c763',1,'s2let_error.h']]], + ['s2let_5fsampling_5fmw_5fss_5fstr_689',['S2LET_SAMPLING_MW_SS_STR',['../s2let__mex_8h.html#aef877ec016bc062e71412e295efbe843',1,'s2let_mex.h']]], + ['s2let_5fsampling_5fmw_5fstr_690',['S2LET_SAMPLING_MW_STR',['../s2let__mex_8h.html#a965fb52ef2d665d3443bd08e8ec47548',1,'s2let_mex.h']]], + ['s2let_5fso3_5fn_5forder_691',['S2LET_SO3_N_ORDER',['../s2let__so3_8h.html#a0c50a5de20f171c266985a92764153b3',1,'s2let_so3.h']]], + ['s2let_5fso3_5fstorage_692',['S2LET_SO3_STORAGE',['../s2let__so3_8h.html#a234c5518a86c602ca220a16b33dc2e22',1,'s2let_so3.h']]], + ['s2let_5fstring_5flen_693',['S2LET_STRING_LEN',['../s2let__mex_8h.html#a3bd7f5fbd27ea58ab3a23a1eb7a6f4cd',1,'s2let_mex.h']]], + ['s2let_5ftests_694',['S2LET_TESTS',['../test__back__and__forth_8c.html#a47e61454d11e89fdf7bdfed2b12de0f5',1,'S2LET_TESTS(): test_back_and_forth.c'],['../test__back__and__forth_8c.html#a47e61454d11e89fdf7bdfed2b12de0f5',1,'S2LET_TESTS(): test_back_and_forth.c']]] ]; diff --git a/docs/c/search/enums_0.js b/docs/c/search/enums_0.js index b8891cde..1fb42907 100644 --- a/docs/c/search/enums_0.js +++ b/docs/c/search/enums_0.js @@ -1,5 +1,5 @@ var searchData= [ - ['s2let_5fkernel_5ftype_601',['s2let_kernel_type',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879a',1,'s2let_tiling.c']]], - ['s2let_5fsampling_5ft_602',['s2let_sampling_t',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001e',1,'s2let_types.h']]] + ['s2let_5fkernel_5ftype_671',['s2let_kernel_type',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879a',1,'s2let_tiling.c']]], + ['s2let_5fsampling_5ft_672',['s2let_sampling_t',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001e',1,'s2let_types.h']]] ]; diff --git a/docs/c/search/enumvalues_0.js b/docs/c/search/enumvalues_0.js index 58b76865..1e78d660 100644 --- a/docs/c/search/enumvalues_0.js +++ b/docs/c/search/enumvalues_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['needlet_603',['NEEDLET',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aa1ab4d051220837ebef5b7bbc03e7f2ac',1,'s2let_tiling.c']]] + ['needlet_673',['NEEDLET',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aa1ab4d051220837ebef5b7bbc03e7f2ac',1,'s2let_tiling.c']]] ]; diff --git a/docs/c/search/enumvalues_1.js b/docs/c/search/enumvalues_1.js index 2c23583c..6f27fb59 100644 --- a/docs/c/search/enumvalues_1.js +++ b/docs/c/search/enumvalues_1.js @@ -1,8 +1,8 @@ var searchData= [ - ['s2dw_604',['S2DW',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aad2e1e459d07d91ca00e5f09caf8b4558',1,'s2let_tiling.c']]], - ['s2let_5fsampling_5fmw_605',['S2LET_SAMPLING_MW',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea061a427ab87d0615aeea0bbc9ef5a8bc',1,'s2let_types.h']]], - ['s2let_5fsampling_5fmw_5fss_606',['S2LET_SAMPLING_MW_SS',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea4735249ce28fc1c5b443806760f8fcd8',1,'s2let_types.h']]], - ['s2let_5fsampling_5fsize_607',['S2LET_SAMPLING_SIZE',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea1eb522fb952502e38119d2a315cce842',1,'s2let_types.h']]], - ['spline_608',['SPLINE',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aa4d8b3b9406a35793dead4b293d793463',1,'s2let_tiling.c']]] + ['s2dw_674',['S2DW',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aad2e1e459d07d91ca00e5f09caf8b4558',1,'s2let_tiling.c']]], + ['s2let_5fsampling_5fmw_675',['S2LET_SAMPLING_MW',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea061a427ab87d0615aeea0bbc9ef5a8bc',1,'s2let_types.h']]], + ['s2let_5fsampling_5fmw_5fss_676',['S2LET_SAMPLING_MW_SS',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea4735249ce28fc1c5b443806760f8fcd8',1,'s2let_types.h']]], + ['s2let_5fsampling_5fsize_677',['S2LET_SAMPLING_SIZE',['../s2let__types_8h.html#a1bdf3bdc527d0a90b16cf5f3f507001ea1eb522fb952502e38119d2a315cce842',1,'s2let_types.h']]], + ['spline_678',['SPLINE',['../s2let__tiling_8c.html#aa95dc83ea2d993b343828e5c6ca4879aa4d8b3b9406a35793dead4b293d793463',1,'s2let_tiling.c']]] ]; diff --git a/docs/c/search/files_0.js b/docs/c/search/files_0.js index 974b5d01..2691d645 100644 --- a/docs/c/search/files_0.js +++ b/docs/c/search/files_0.js @@ -1,56 +1,56 @@ var searchData= [ - ['s2let_2eh_313',['s2let.h',['../s2let_8h.html',1,'']]], - ['s2let_5fabout_2ec_314',['s2let_about.c',['../s2let__about_8c.html',1,'']]], - ['s2let_5falloc_2ec_315',['s2let_alloc.c',['../s2let__alloc_8c.html',1,'']]], - ['s2let_5falloc_2eh_316',['s2let_alloc.h',['../s2let__alloc_8h.html',1,'']]], - ['s2let_5fanalysis_2ec_317',['s2let_analysis.c',['../s2let__analysis_8c.html',1,'']]], - ['s2let_5fanalysis_2eh_318',['s2let_analysis.h',['../s2let__analysis_8h.html',1,'']]], - ['s2let_5fanalysis_5fadjoint_2ec_319',['s2let_analysis_adjoint.c',['../s2let__analysis__adjoint_8c.html',1,'']]], - ['s2let_5fanalysis_5fadjoint_2eh_320',['s2let_analysis_adjoint.h',['../s2let__analysis__adjoint_8h.html',1,'']]], - ['s2let_5faxisym_5fdenoising_5fdemo_2ec_321',['s2let_axisym_denoising_demo.c',['../s2let__axisym__denoising__demo_8c.html',1,'']]], - ['s2let_5faxisym_5fdenoising_5fdemo_2eh_322',['s2let_axisym_denoising_demo.h',['../s2let__axisym__denoising__demo_8h.html',1,'']]], - ['s2let_5fdenoising_5fdemo_2ec_323',['s2let_denoising_demo.c',['../s2let__denoising__demo_8c.html',1,'']]], - ['s2let_5fdenoising_5fdemo_2eh_324',['s2let_denoising_demo.h',['../s2let__denoising__demo_8h.html',1,'']]], - ['s2let_5ferror_2eh_325',['s2let_error.h',['../s2let__error_8h.html',1,'']]], - ['s2let_5ffits_2ec_326',['s2let_fits.c',['../s2let__fits_8c.html',1,'']]], - ['s2let_5ffits_2eh_327',['s2let_fits.h',['../s2let__fits_8h.html',1,'']]], - ['s2let_5fhelper_2ec_328',['s2let_helper.c',['../s2let__helper_8c.html',1,'']]], - ['s2let_5fhelper_2eh_329',['s2let_helper.h',['../s2let__helper_8h.html',1,'']]], - ['s2let_5fhpx_2ec_330',['s2let_hpx.c',['../s2let__hpx_8c.html',1,'']]], - ['s2let_5fhpx_2eh_331',['s2let_hpx.h',['../s2let__hpx_8h.html',1,'']]], - ['s2let_5fhpx_5fdemo_2ec_332',['s2let_hpx_demo.c',['../s2let__hpx__demo_8c.html',1,'']]], - ['s2let_5fhpx_5ftest_2ec_333',['s2let_hpx_test.c',['../s2let__hpx__test_8c.html',1,'']]], - ['s2let_5fidl_5fhpx_2ec_334',['s2let_idl_hpx.c',['../s2let__idl__hpx_8c.html',1,'']]], - ['s2let_5fidl_5fhpx_2eh_335',['s2let_idl_hpx.h',['../s2let__idl__hpx_8h.html',1,'']]], - ['s2let_5fidl_5fmw_2ec_336',['s2let_idl_mw.c',['../s2let__idl__mw_8c.html',1,'']]], - ['s2let_5fidl_5fmw_2eh_337',['s2let_idl_mw.h',['../s2let__idl__mw_8h.html',1,'']]], - ['s2let_5flm_2ec_338',['s2let_lm.c',['../s2let__lm_8c.html',1,'']]], - ['s2let_5flm_2eh_339',['s2let_lm.h',['../s2let__lm_8h.html',1,'']]], - ['s2let_5fmath_2ec_340',['s2let_math.c',['../s2let__math_8c.html',1,'']]], - ['s2let_5fmath_2eh_341',['s2let_math.h',['../s2let__math_8h.html',1,'']]], - ['s2let_5fmex_2eh_342',['s2let_mex.h',['../s2let__mex_8h.html',1,'']]], - ['s2let_5fmw_2ec_343',['s2let_mw.c',['../s2let__mw_8c.html',1,'']]], - ['s2let_5fmw_2eh_344',['s2let_mw.h',['../s2let__mw_8h.html',1,'']]], - ['s2let_5fso3_2eh_345',['s2let_so3.h',['../s2let__so3_8h.html',1,'']]], - ['s2let_5fspin_5fdenoising_5fdemo_2ec_346',['s2let_spin_denoising_demo.c',['../s2let__spin__denoising__demo_8c.html',1,'']]], - ['s2let_5fsynthesis_2ec_347',['s2let_synthesis.c',['../s2let__synthesis_8c.html',1,'']]], - ['s2let_5fsynthesis_2eh_348',['s2let_synthesis.h',['../s2let__synthesis_8h.html',1,'']]], - ['s2let_5fsynthesis_5fadjoint_2ec_349',['s2let_synthesis_adjoint.c',['../s2let__synthesis__adjoint_8c.html',1,'']]], - ['s2let_5fsynthesis_5fadjoint_2eh_350',['s2let_synthesis_adjoint.h',['../s2let__synthesis__adjoint_8h.html',1,'']]], - ['s2let_5ftest_2ec_351',['s2let_test.c',['../s2let__test_8c.html',1,'']]], - ['s2let_5ftest_5fcsv_2ec_352',['s2let_test_csv.c',['../s2let__test__csv_8c.html',1,'']]], - ['s2let_5ftiling_2ec_353',['s2let_tiling.c',['../s2let__tiling_8c.html',1,'']]], - ['s2let_5ftiling_2eh_354',['s2let_tiling.h',['../s2let__tiling_8h.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fanalysis_5fhpx_5freal_2ec_355',['s2let_transform_axisym_analysis_hpx_real.c',['../s2let__transform__axisym__analysis__hpx__real_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fanalysis_5fmw_5freal_2ec_356',['s2let_transform_axisym_analysis_mw_real.c',['../s2let__transform__axisym__analysis__mw__real_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fhpx_2ec_357',['s2let_transform_axisym_hpx.c',['../s2let__transform__axisym__hpx_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fhpx_2eh_358',['s2let_transform_axisym_hpx.h',['../s2let__transform__axisym__hpx_8h.html',1,'']]], - ['s2let_5ftransform_5faxisym_5flm_2ec_359',['s2let_transform_axisym_lm.c',['../s2let__transform__axisym__lm_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5flm_2eh_360',['s2let_transform_axisym_lm.h',['../s2let__transform__axisym__lm_8h.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fmw_2ec_361',['s2let_transform_axisym_mw.c',['../s2let__transform__axisym__mw_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fmw_2eh_362',['s2let_transform_axisym_mw.h',['../s2let__transform__axisym__mw_8h.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fsynthesis_5fhpx_5freal_2ec_363',['s2let_transform_axisym_synthesis_hpx_real.c',['../s2let__transform__axisym__synthesis__hpx__real_8c.html',1,'']]], - ['s2let_5ftransform_5faxisym_5fsynthesis_5fmw_5freal_2ec_364',['s2let_transform_axisym_synthesis_mw_real.c',['../s2let__transform__axisym__synthesis__mw__real_8c.html',1,'']]], - ['s2let_5ftypes_2eh_365',['s2let_types.h',['../s2let__types_8h.html',1,'']]] + ['s2let_2eh_348',['s2let.h',['../s2let_8h.html',1,'']]], + ['s2let_5fabout_2ec_349',['s2let_about.c',['../s2let__about_8c.html',1,'']]], + ['s2let_5falloc_2ec_350',['s2let_alloc.c',['../s2let__alloc_8c.html',1,'']]], + ['s2let_5falloc_2eh_351',['s2let_alloc.h',['../s2let__alloc_8h.html',1,'']]], + ['s2let_5fanalysis_2ec_352',['s2let_analysis.c',['../s2let__analysis_8c.html',1,'']]], + ['s2let_5fanalysis_2eh_353',['s2let_analysis.h',['../s2let__analysis_8h.html',1,'']]], + ['s2let_5fanalysis_5fadjoint_2ec_354',['s2let_analysis_adjoint.c',['../s2let__analysis__adjoint_8c.html',1,'']]], + ['s2let_5fanalysis_5fadjoint_2eh_355',['s2let_analysis_adjoint.h',['../s2let__analysis__adjoint_8h.html',1,'']]], + ['s2let_5faxisym_5fdenoising_5fdemo_2ec_356',['s2let_axisym_denoising_demo.c',['../s2let__axisym__denoising__demo_8c.html',1,'']]], + ['s2let_5faxisym_5fdenoising_5fdemo_2eh_357',['s2let_axisym_denoising_demo.h',['../s2let__axisym__denoising__demo_8h.html',1,'']]], + ['s2let_5fdenoising_5fdemo_2ec_358',['s2let_denoising_demo.c',['../s2let__denoising__demo_8c.html',1,'']]], + ['s2let_5fdenoising_5fdemo_2eh_359',['s2let_denoising_demo.h',['../s2let__denoising__demo_8h.html',1,'']]], + ['s2let_5ferror_2eh_360',['s2let_error.h',['../s2let__error_8h.html',1,'']]], + ['s2let_5ffits_2ec_361',['s2let_fits.c',['../s2let__fits_8c.html',1,'']]], + ['s2let_5ffits_2eh_362',['s2let_fits.h',['../s2let__fits_8h.html',1,'']]], + ['s2let_5fhelper_2ec_363',['s2let_helper.c',['../s2let__helper_8c.html',1,'']]], + ['s2let_5fhelper_2eh_364',['s2let_helper.h',['../s2let__helper_8h.html',1,'']]], + ['s2let_5fhpx_2ec_365',['s2let_hpx.c',['../s2let__hpx_8c.html',1,'']]], + ['s2let_5fhpx_2eh_366',['s2let_hpx.h',['../s2let__hpx_8h.html',1,'']]], + ['s2let_5fhpx_5fdemo_2ec_367',['s2let_hpx_demo.c',['../s2let__hpx__demo_8c.html',1,'']]], + ['s2let_5fhpx_5ftest_2ec_368',['s2let_hpx_test.c',['../s2let__hpx__test_8c.html',1,'']]], + ['s2let_5fidl_5fhpx_2ec_369',['s2let_idl_hpx.c',['../s2let__idl__hpx_8c.html',1,'']]], + ['s2let_5fidl_5fhpx_2eh_370',['s2let_idl_hpx.h',['../s2let__idl__hpx_8h.html',1,'']]], + ['s2let_5fidl_5fmw_2ec_371',['s2let_idl_mw.c',['../s2let__idl__mw_8c.html',1,'']]], + ['s2let_5fidl_5fmw_2eh_372',['s2let_idl_mw.h',['../s2let__idl__mw_8h.html',1,'']]], + ['s2let_5flm_2ec_373',['s2let_lm.c',['../s2let__lm_8c.html',1,'']]], + ['s2let_5flm_2eh_374',['s2let_lm.h',['../s2let__lm_8h.html',1,'']]], + ['s2let_5fmath_2ec_375',['s2let_math.c',['../s2let__math_8c.html',1,'']]], + ['s2let_5fmath_2eh_376',['s2let_math.h',['../s2let__math_8h.html',1,'']]], + ['s2let_5fmex_2eh_377',['s2let_mex.h',['../s2let__mex_8h.html',1,'']]], + ['s2let_5fmw_2ec_378',['s2let_mw.c',['../s2let__mw_8c.html',1,'']]], + ['s2let_5fmw_2eh_379',['s2let_mw.h',['../s2let__mw_8h.html',1,'']]], + ['s2let_5fso3_2eh_380',['s2let_so3.h',['../s2let__so3_8h.html',1,'']]], + ['s2let_5fspin_5fdenoising_5fdemo_2ec_381',['s2let_spin_denoising_demo.c',['../s2let__spin__denoising__demo_8c.html',1,'']]], + ['s2let_5fsynthesis_2ec_382',['s2let_synthesis.c',['../s2let__synthesis_8c.html',1,'']]], + ['s2let_5fsynthesis_2eh_383',['s2let_synthesis.h',['../s2let__synthesis_8h.html',1,'']]], + ['s2let_5fsynthesis_5fadjoint_2ec_384',['s2let_synthesis_adjoint.c',['../s2let__synthesis__adjoint_8c.html',1,'']]], + ['s2let_5fsynthesis_5fadjoint_2eh_385',['s2let_synthesis_adjoint.h',['../s2let__synthesis__adjoint_8h.html',1,'']]], + ['s2let_5ftest_2ec_386',['s2let_test.c',['../s2let__test_8c.html',1,'']]], + ['s2let_5ftest_5fcsv_2ec_387',['s2let_test_csv.c',['../s2let__test__csv_8c.html',1,'']]], + ['s2let_5ftiling_2ec_388',['s2let_tiling.c',['../s2let__tiling_8c.html',1,'']]], + ['s2let_5ftiling_2eh_389',['s2let_tiling.h',['../s2let__tiling_8h.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fanalysis_5fhpx_5freal_2ec_390',['s2let_transform_axisym_analysis_hpx_real.c',['../s2let__transform__axisym__analysis__hpx__real_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fanalysis_5fmw_5freal_2ec_391',['s2let_transform_axisym_analysis_mw_real.c',['../s2let__transform__axisym__analysis__mw__real_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fhpx_2ec_392',['s2let_transform_axisym_hpx.c',['../s2let__transform__axisym__hpx_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fhpx_2eh_393',['s2let_transform_axisym_hpx.h',['../s2let__transform__axisym__hpx_8h.html',1,'']]], + ['s2let_5ftransform_5faxisym_5flm_2ec_394',['s2let_transform_axisym_lm.c',['../s2let__transform__axisym__lm_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5flm_2eh_395',['s2let_transform_axisym_lm.h',['../s2let__transform__axisym__lm_8h.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fmw_2ec_396',['s2let_transform_axisym_mw.c',['../s2let__transform__axisym__mw_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fmw_2eh_397',['s2let_transform_axisym_mw.h',['../s2let__transform__axisym__mw_8h.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fsynthesis_5fhpx_5freal_2ec_398',['s2let_transform_axisym_synthesis_hpx_real.c',['../s2let__transform__axisym__synthesis__hpx__real_8c.html',1,'']]], + ['s2let_5ftransform_5faxisym_5fsynthesis_5fmw_5freal_2ec_399',['s2let_transform_axisym_synthesis_mw_real.c',['../s2let__transform__axisym__synthesis__mw__real_8c.html',1,'']]], + ['s2let_5ftypes_2eh_400',['s2let_types.h',['../s2let__types_8h.html',1,'']]] ]; diff --git a/docs/c/search/files_1.html b/docs/c/search/files_1.html new file mode 100644 index 00000000..f1770a68 --- /dev/null +++ b/docs/c/search/files_1.html @@ -0,0 +1,36 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/c/search/files_1.js b/docs/c/search/files_1.js new file mode 100644 index 00000000..eb243c7c --- /dev/null +++ b/docs/c/search/files_1.js @@ -0,0 +1,7 @@ +var searchData= +[ + ['test_5fadjoint_2ec_401',['test_adjoint.c',['../test__adjoint_8c.html',1,'']]], + ['test_5faxisym_5fvs_5fdirectional_2ec_402',['test_axisym_vs_directional.c',['../test__axisym__vs__directional_8c.html',1,'']]], + ['test_5fback_5fand_5fforth_2ec_403',['test_back_and_forth.c',['../test__back__and__forth_8c.html',1,'']]], + ['test_5ftiling_2ec_404',['test_tiling.c',['../test__tiling_8c.html',1,'']]] +]; diff --git a/docs/c/search/functions_0.js b/docs/c/search/functions_0.js index 074fd51c..056ef59f 100644 --- a/docs/c/search/functions_0.js +++ b/docs/c/search/functions_0.js @@ -1,5 +1,5 @@ var searchData= [ - ['b3_5fspline_366',['b3_spline',['../s2let__math_8c.html#a77bf2f88aa8abaede094b8d4c98f641b',1,'s2let_math.c']]], - ['binomial_5fcoefficient_367',['binomial_coefficient',['../s2let__math_8c.html#a89bd27b2a137f59ca4c8aa8e3f1c485f',1,'binomial_coefficient(int n, int k, int exact): s2let_math.c'],['../s2let__math_8h.html#a89bd27b2a137f59ca4c8aa8e3f1c485f',1,'binomial_coefficient(int n, int k, int exact): s2let_math.c']]] + ['b3_5fspline_405',['b3_spline',['../s2let__math_8c.html#a77bf2f88aa8abaede094b8d4c98f641b',1,'s2let_math.c']]], + ['binomial_5fcoefficient_406',['binomial_coefficient',['../s2let__math_8c.html#a89bd27b2a137f59ca4c8aa8e3f1c485f',1,'binomial_coefficient(int n, int k, int exact): s2let_math.c'],['../s2let__math_8h.html#a89bd27b2a137f59ca4c8aa8e3f1c485f',1,'binomial_coefficient(int n, int k, int exact): s2let_math.c']]] ]; diff --git a/docs/c/search/functions_1.js b/docs/c/search/functions_1.js index 6e629aa2..2197daa1 100644 --- a/docs/c/search/functions_1.js +++ b/docs/c/search/functions_1.js @@ -1,5 +1,5 @@ var searchData= [ - ['f_5fneedlet_368',['f_needlet',['../s2let__math_8c.html#acba5b02a49e931413dc0cde1fce77234',1,'s2let_math.c']]], - ['f_5fs2dw_369',['f_s2dw',['../s2let__math_8c.html#a3a626259154382ef236e7d9ab33cca49',1,'s2let_math.c']]] + ['f_5fneedlet_407',['f_needlet',['../s2let__math_8c.html#acba5b02a49e931413dc0cde1fce77234',1,'s2let_math.c']]], + ['f_5fs2dw_408',['f_s2dw',['../s2let__math_8c.html#a3a626259154382ef236e7d9ab33cca49',1,'s2let_math.c']]] ]; diff --git a/docs/c/search/functions_2.js b/docs/c/search/functions_2.js index 7a4325d8..edd57813 100644 --- a/docs/c/search/functions_2.js +++ b/docs/c/search/functions_2.js @@ -1,4 +1,5 @@ var searchData= [ - ['get_5fmax_5ferror_370',['get_max_error',['../s2let__test__csv_8c.html#a4d00c945ef5468ad68184f0bc1ada91a',1,'s2let_test_csv.c']]] + ['gen_5fflmn_5fcomplex_409',['gen_flmn_complex',['../test__adjoint_8c.html#a4905dad7b518bab34378cec6d748634c',1,'test_adjoint.c']]], + ['get_5fmax_5ferror_410',['get_max_error',['../s2let__test__csv_8c.html#a4d00c945ef5468ad68184f0bc1ada91a',1,'s2let_test_csv.c']]] ]; diff --git a/docs/c/search/functions_3.js b/docs/c/search/functions_3.js index cb90d4b2..01837922 100644 --- a/docs/c/search/functions_3.js +++ b/docs/c/search/functions_3.js @@ -1,9 +1,9 @@ var searchData= [ - ['hard_5fthreshold_371',['hard_threshold',['../s2let__spin__denoising__demo_8c.html#a6efb36935c405dca5e9dd591164f79a0',1,'s2let_spin_denoising_demo.c']]], - ['hard_5fthreshold_5freal_372',['hard_threshold_real',['../s2let__denoising__demo_8c.html#a067d9bf357dbfd7a4986d3f62a9e8c45',1,'hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_denoising_demo.c'],['../s2let__denoising__demo_8h.html#a067d9bf357dbfd7a4986d3f62a9e8c45',1,'hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_denoising_demo.c']]], - ['healpix_5fforward_5freal_5f_373',['healpix_forward_real_',['../s2let__hpx_8c.html#ad1de3129addcea74634d9f809615948b',1,'s2let_hpx.c']]], - ['healpix_5fforward_5fspin_5freal_5f_374',['healpix_forward_spin_real_',['../s2let__hpx_8c.html#a3c1aa5d1d8986ea812c873bd8dd429fa',1,'s2let_hpx.c']]], - ['healpix_5finverse_5freal_5f_375',['healpix_inverse_real_',['../s2let__hpx_8c.html#aeb1da4714bc41184ec236de731756560',1,'s2let_hpx.c']]], - ['healpix_5finverse_5fspin_5freal_5f_376',['healpix_inverse_spin_real_',['../s2let__hpx_8c.html#a27eaaf7d94a6fa9c382fea95ad13d9a0',1,'s2let_hpx.c']]] + ['hard_5fthreshold_411',['hard_threshold',['../s2let__spin__denoising__demo_8c.html#a6efb36935c405dca5e9dd591164f79a0',1,'s2let_spin_denoising_demo.c']]], + ['hard_5fthreshold_5freal_412',['hard_threshold_real',['../s2let__denoising__demo_8c.html#a067d9bf357dbfd7a4986d3f62a9e8c45',1,'hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_denoising_demo.c'],['../s2let__denoising__demo_8h.html#a067d9bf357dbfd7a4986d3f62a9e8c45',1,'hard_threshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_denoising_demo.c']]], + ['healpix_5fforward_5freal_5f_413',['healpix_forward_real_',['../s2let__hpx_8c.html#ad1de3129addcea74634d9f809615948b',1,'s2let_hpx.c']]], + ['healpix_5fforward_5fspin_5freal_5f_414',['healpix_forward_spin_real_',['../s2let__hpx_8c.html#a3c1aa5d1d8986ea812c873bd8dd429fa',1,'s2let_hpx.c']]], + ['healpix_5finverse_5freal_5f_415',['healpix_inverse_real_',['../s2let__hpx_8c.html#aeb1da4714bc41184ec236de731756560',1,'s2let_hpx.c']]], + ['healpix_5finverse_5fspin_5freal_5f_416',['healpix_inverse_spin_real_',['../s2let__hpx_8c.html#a27eaaf7d94a6fa9c382fea95ad13d9a0',1,'s2let_hpx.c']]] ]; diff --git a/docs/c/search/functions_4.js b/docs/c/search/functions_4.js index 8abdc54d..3aa5e882 100644 --- a/docs/c/search/functions_4.js +++ b/docs/c/search/functions_4.js @@ -1,6 +1,7 @@ var searchData= [ - ['main_377',['main',['../s2let__about_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_about.c'],['../s2let__axisym__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_denoising_demo.c'],['../s2let__hpx__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_hpx_demo.c'],['../s2let__spin__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_spin_denoising_demo.c'],['../s2let__transform__axisym__analysis__hpx__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_analysis_hpx_real.c'],['../s2let__transform__axisym__analysis__mw__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_analysis_mw_real.c'],['../s2let__transform__axisym__synthesis__hpx__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_synthesis_hpx_real.c'],['../s2let__transform__axisym__synthesis__mw__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_synthesis_mw_real.c'],['../s2let__hpx__test_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_hpx_test.c'],['../s2let__test_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_test.c'],['../s2let__test__csv_8c.html#a3c04138a5bfe5d72780bb7e82a18e627',1,'main(int argc, char **argv): s2let_test_csv.c']]], - ['maxerr_378',['maxerr',['../s2let__math_8c.html#a4f5998b7b92ffac7fea15fee7ce645f0',1,'maxerr(double *a, double *b, int size): s2let_math.c'],['../s2let__math_8h.html#a4f5998b7b92ffac7fea15fee7ce645f0',1,'maxerr(double *a, double *b, int size): s2let_math.c']]], - ['maxerr_5fcplx_379',['maxerr_cplx',['../s2let__math_8c.html#a393b1deb6be62de0afa639a203b78b15',1,'maxerr_cplx(complex double *a, complex double *b, int size): s2let_math.c'],['../s2let__math_8h.html#af19ac104dc4577702838dcd24f99d2a0',1,'maxerr_cplx(S2LET_COMPLEX(double) *a, S2LET_COMPLEX(double) *b, int size): s2let_math.h']]] + ['main_417',['main',['../s2let__about_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_about.c'],['../s2let__axisym__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_denoising_demo.c'],['../s2let__hpx__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_hpx_demo.c'],['../s2let__spin__denoising__demo_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_spin_denoising_demo.c'],['../s2let__transform__axisym__analysis__hpx__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_analysis_hpx_real.c'],['../s2let__transform__axisym__analysis__mw__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_analysis_mw_real.c'],['../s2let__transform__axisym__synthesis__hpx__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_synthesis_hpx_real.c'],['../s2let__transform__axisym__synthesis__mw__real_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_transform_axisym_synthesis_mw_real.c'],['../s2let__hpx__test_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_hpx_test.c'],['../s2let__test_8c.html#a0ddf1224851353fc92bfbff6f499fa97',1,'main(int argc, char *argv[]): s2let_test.c'],['../s2let__test__csv_8c.html#a3c04138a5bfe5d72780bb7e82a18e627',1,'main(int argc, char **argv): s2let_test_csv.c'],['../test__adjoint_8c.html#a840291bc02cba5474a4cb46a9b9566fe',1,'main(void): test_adjoint.c'],['../test__axisym__vs__directional_8c.html#a840291bc02cba5474a4cb46a9b9566fe',1,'main(void): test_axisym_vs_directional.c'],['../test__back__and__forth_8c.html#a840291bc02cba5474a4cb46a9b9566fe',1,'main(void): test_back_and_forth.c'],['../test__tiling_8c.html#a840291bc02cba5474a4cb46a9b9566fe',1,'main(void): test_tiling.c']]], + ['maxerr_418',['maxerr',['../s2let__math_8c.html#a4f5998b7b92ffac7fea15fee7ce645f0',1,'maxerr(double *a, double *b, int size): s2let_math.c'],['../s2let__math_8h.html#a4f5998b7b92ffac7fea15fee7ce645f0',1,'maxerr(double *a, double *b, int size): s2let_math.c']]], + ['maxerr_5fcplx_419',['maxerr_cplx',['../s2let__math_8c.html#a393b1deb6be62de0afa639a203b78b15',1,'maxerr_cplx(complex double *a, complex double *b, int size): s2let_math.c'],['../s2let__math_8h.html#af19ac104dc4577702838dcd24f99d2a0',1,'maxerr_cplx(S2LET_COMPLEX(double) *a, S2LET_COMPLEX(double) *b, int size): s2let_math.h']]], + ['min_420',['min',['../test__axisym__vs__directional_8c.html#aafee2c9cc9a9d15d30b3c3189e2146d0',1,'test_axisym_vs_directional.c']]] ]; diff --git a/docs/c/search/functions_5.js b/docs/c/search/functions_5.js index b65f6f62..f3bb1050 100644 --- a/docs/c/search/functions_5.js +++ b/docs/c/search/functions_5.js @@ -1,4 +1,4 @@ var searchData= [ - ['needletpower_380',['needletpower',['../s2let__axisym__denoising__demo_8c.html#a16c08eb6db78637aae2b6ffdfd13cfe2',1,'needletpower(double *wav_lm, int L): s2let_axisym_denoising_demo.c'],['../s2let__axisym__denoising__demo_8h.html#a16c08eb6db78637aae2b6ffdfd13cfe2',1,'needletpower(double *wav_lm, int L): s2let_axisym_denoising_demo.c']]] + ['needletpower_421',['needletpower',['../s2let__axisym__denoising__demo_8c.html#a16c08eb6db78637aae2b6ffdfd13cfe2',1,'needletpower(double *wav_lm, int L): s2let_axisym_denoising_demo.c'],['../s2let__axisym__denoising__demo_8h.html#a16c08eb6db78637aae2b6ffdfd13cfe2',1,'needletpower(double *wav_lm, int L): s2let_axisym_denoising_demo.c']]] ]; diff --git a/docs/c/search/functions_6.js b/docs/c/search/functions_6.js index 75c1a527..e39063df 100644 --- a/docs/c/search/functions_6.js +++ b/docs/c/search/functions_6.js @@ -1,4 +1,4 @@ var searchData= [ - ['printerror_381',['printerror',['../s2let__fits_8c.html#aca57f410eb9f3d6ec61c1c17d4aea3da',1,'s2let_fits.c']]] + ['printerror_422',['printerror',['../s2let__fits_8c.html#aca57f410eb9f3d6ec61c1c17d4aea3da',1,'s2let_fits.c']]] ]; diff --git a/docs/c/search/functions_7.js b/docs/c/search/functions_7.js index 9ec3cda8..87cafc1f 100644 --- a/docs/c/search/functions_7.js +++ b/docs/c/search/functions_7.js @@ -1,6 +1,6 @@ var searchData= [ - ['ran2_5fdp_382',['ran2_dp',['../s2let__math_8c.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c'],['../s2let__test__csv_8c.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c'],['../s2let__math_8h.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c']]], - ['read_5fhealpix_5fmap_5f_383',['read_healpix_map_',['../s2let__hpx_8c.html#ae43fcaf0a30b8979a329c9d8a639f9aa',1,'s2let_hpx.c']]], - ['read_5fhealpix_5fmaps_5f_384',['read_healpix_maps_',['../s2let__hpx_8c.html#a24812c14ec76f109d5dae58289353afd',1,'s2let_hpx.c']]] + ['ran2_5fdp_423',['ran2_dp',['../s2let__math_8c.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c'],['../s2let__test__csv_8c.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c'],['../s2let__math_8h.html#a8f1de4509d2d559e1cf392353eae7afa',1,'ran2_dp(int idum): s2let_math.c']]], + ['read_5fhealpix_5fmap_5f_424',['read_healpix_map_',['../s2let__hpx_8c.html#ae43fcaf0a30b8979a329c9d8a639f9aa',1,'s2let_hpx.c']]], + ['read_5fhealpix_5fmaps_5f_425',['read_healpix_maps_',['../s2let__hpx_8c.html#a24812c14ec76f109d5dae58289353afd',1,'s2let_hpx.c']]] ]; diff --git a/docs/c/search/functions_8.js b/docs/c/search/functions_8.js index f5b00cba..b5c4dcf1 100644 --- a/docs/c/search/functions_8.js +++ b/docs/c/search/functions_8.js @@ -1,201 +1,201 @@ var searchData= [ - ['s2let_5fallocate_5ff_5fwav_385',['s2let_allocate_f_wav',['../s2let__alloc_8c.html#a04372bb80be30ca4b5442c682c550866',1,'s2let_allocate_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a1e37dc2888e4d40c947e7c7727eb8ad7',1,'s2let_allocate_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_alloc.h']]], - ['s2let_5fallocate_5ff_5fwav_5fmanual_386',['s2let_allocate_f_wav_manual',['../s2let__alloc_8c.html#a2a547a089b006e1dda73b84cad4c085e',1,'s2let_allocate_f_wav_manual(complex double **f_wav, complex double **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#aa5c19adf92fef81e6e6481d445b481bb',1,'s2let_allocate_f_wav_manual(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, s2let_parameters_t *parameters): s2let_alloc.h']]], - ['s2let_5fallocate_5ff_5fwav_5freal_387',['s2let_allocate_f_wav_real',['../s2let__alloc_8c.html#a979f526f58f72c9c96e16e2ba46e0f63',1,'s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a979f526f58f72c9c96e16e2ba46e0f63',1,'s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c']]], - ['s2let_5fallocate_5flm_388',['s2let_allocate_lm',['../s2let__alloc_8c.html#a8b221a008760c8dbe1a655c74dc2d0d0',1,'s2let_allocate_lm(complex double **flm, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#aa7bc8a069c40873338f1e8c770f34424',1,'s2let_allocate_lm(S2LET_COMPLEX(double) **flm, int L): s2let_alloc.h']]], - ['s2let_5fallocate_5flmn_5ff_5fwav_389',['s2let_allocate_lmn_f_wav',['../s2let__alloc_8c.html#a9dcb24db0b9cd7dd522bead7d61f7960',1,'s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a8c43cc27f8f2450ae6ec9bb6165dfd8b',1,'s2let_allocate_lmn_f_wav(S2LET_COMPLEX(double) **f_wav_lmn, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_alloc.h']]], - ['s2let_5fallocate_5fmw_390',['s2let_allocate_mw',['../s2let__alloc_8c.html#a83fad2b470cea9f29d8fe104616236dc',1,'s2let_allocate_mw(complex double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#ac042b364686fc53225102c71fc10f797',1,'s2let_allocate_mw(S2LET_COMPLEX(double) **f, int L): s2let_alloc.h']]], - ['s2let_5fallocate_5fmw_5freal_391',['s2let_allocate_mw_real',['../s2let__alloc_8c.html#a22e7d6f3fdc037d975eaad03ef0ece23',1,'s2let_allocate_mw_real(double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#a22e7d6f3fdc037d975eaad03ef0ece23',1,'s2let_allocate_mw_real(double **f, int L): s2let_alloc.c']]], - ['s2let_5fallocate_5fmwss_392',['s2let_allocate_mwss',['../s2let__alloc_8c.html#a4569d2d2e8251c4e65494b1518ebe72e',1,'s2let_allocate_mwss(complex double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#ab914515792a062cc87662d8a6b028b7b',1,'s2let_allocate_mwss(S2LET_COMPLEX(double) **f, int L): s2let_alloc.h']]], - ['s2let_5fallocate_5fmwss_5freal_393',['s2let_allocate_mwss_real',['../s2let__alloc_8c.html#a562dc748f45b20b9791bbca68045c472',1,'s2let_allocate_mwss_real(double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#a562dc748f45b20b9791bbca68045c472',1,'s2let_allocate_mwss_real(double **f, int L): s2let_alloc.c']]], - ['s2let_5fanalysis_5fadjoint_5flmn2lm_394',['s2let_analysis_adjoint_lmn2lm',['../s2let__analysis__adjoint_8c.html#a72146aacc61a608c02b22299d6c61e98',1,'s2let_analysis_adjoint_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a529cb2b3e504faf4cda24b4c6d99d333',1,'s2let_analysis_adjoint_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5flmn2lm_5freal_395',['s2let_analysis_adjoint_lmn2lm_real',['../s2let__analysis__adjoint_8c.html#abee7a1a11683f976937f6ab167a4a2ed',1,'s2let_analysis_adjoint_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a2c83c6835e02811a5d264613391b789e',1,'s2let_analysis_adjoint_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2lm_396',['s2let_analysis_adjoint_wav2lm',['../s2let__analysis__adjoint_8c.html#acbf24f007aab1439f827cafe351db721',1,'s2let_analysis_adjoint_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a6c6a34d9203703ddf27f323109f9dde6',1,'s2let_analysis_adjoint_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2lm_5fmanual_397',['s2let_analysis_adjoint_wav2lm_manual',['../s2let__analysis__adjoint_8c.html#a29d0f211cfd72f240cf53504d0ba12c3',1,'s2let_analysis_adjoint_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a181593f69b4cc0d9d26aa9379dc9bba2',1,'s2let_analysis_adjoint_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2lm_5freal_398',['s2let_analysis_adjoint_wav2lm_real',['../s2let__analysis__adjoint_8c.html#a055b05e4838ea75986215b775a124568',1,'s2let_analysis_adjoint_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a46105f73ba49339a7b5565db46ac3b28',1,'s2let_analysis_adjoint_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2px_399',['s2let_analysis_adjoint_wav2px',['../s2let__analysis__adjoint_8c.html#a4033dce73ff132c2d7f0a23b7b741d85',1,'s2let_analysis_adjoint_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a8af02104042ed3c6ea7398889483cc45',1,'s2let_analysis_adjoint_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], - ['s2let_5fanalysis_5fadjoint_5fwav2px_5freal_400',['s2let_analysis_adjoint_wav2px_real',['../s2let__analysis__adjoint_8c.html#ad3c34c9c83b067fb9c350698fd66d5a6',1,'s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#ad3c34c9c83b067fb9c350698fd66d5a6',1,'s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c']]], - ['s2let_5fanalysis_5flm2lmn_401',['s2let_analysis_lm2lmn',['../s2let__analysis_8c.html#a9781ec2d11788c9aa5a13bbca0e6ba9c',1,'s2let_analysis_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a1ff7c08702b71c00f79668abbc950d30',1,'s2let_analysis_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5flm2lmn_5freal_402',['s2let_analysis_lm2lmn_real',['../s2let__analysis_8c.html#a08075042a4adb01136d60414fd401a60',1,'s2let_analysis_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a0ae75e5749e9bb978f21d86b674c41b5',1,'s2let_analysis_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5flm2wav_403',['s2let_analysis_lm2wav',['../s2let__analysis_8c.html#ac5d95aed75e346bb48b9249bf80ace23',1,'s2let_analysis_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a2c035e3a62cab8dd9586d6fe75ab8268',1,'s2let_analysis_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5flm2wav_5fmanual_404',['s2let_analysis_lm2wav_manual',['../s2let__analysis_8c.html#a36f06dd57668341905eb038f85c309a2',1,'s2let_analysis_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis.c'],['../s2let__analysis_8h.html#a8af83cfbde6d80b9802c85553aed5828',1,'s2let_analysis_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis.h']]], - ['s2let_5fanalysis_5flm2wav_5freal_405',['s2let_analysis_lm2wav_real',['../s2let__analysis_8c.html#a33928a9b09c9afe216dcf733ae7d1c5f',1,'s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a107abc090af40bf3d9ee37787e9d86c8',1,'s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5fpx2wav_406',['s2let_analysis_px2wav',['../s2let__analysis_8c.html#a685f469be2016583d3fc15dae0e24c93',1,'s2let_analysis_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a1fc2440d51f5255a14fddd3cc6e25e61',1,'s2let_analysis_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_analysis.h']]], - ['s2let_5fanalysis_5fpx2wav_5freal_407',['s2let_analysis_px2wav_real',['../s2let__analysis_8c.html#a559ce533b1453fddd43b2046323d3abf',1,'s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a559ce533b1453fddd43b2046323d3abf',1,'s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_analysis.c']]], - ['s2let_5fbandlimit_408',['s2let_bandlimit',['../s2let__tiling_8c.html#ac022968b50a5a7a294fd6ae9d792119a',1,'s2let_bandlimit(int j, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ac022968b50a5a7a294fd6ae9d792119a',1,'s2let_bandlimit(int j, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5fbinomial_5fcoefficient_5ftest_409',['s2let_binomial_coefficient_test',['../s2let__test_8c.html#a468603fe2a4ae0176b1a3008b5508ac7',1,'s2let_test.c']]], - ['s2let_5fdot_5fproduct_5fcomplex_410',['s2let_dot_product_complex',['../s2let__test_8c.html#af85961da9316af3f997f88fedd2604d9',1,'s2let_test.c']]], - ['s2let_5fdot_5fproduct_5freal_411',['s2let_dot_product_real',['../s2let__test_8c.html#ab9098753dfdaad47814f9d13a5e838a1',1,'s2let_test.c']]], - ['s2let_5ffits_5fhpx_5fread_5fnside_412',['s2let_fits_hpx_read_nside',['../s2let__fits_8c.html#a332b4542fd283126c1bfd55c6f96d0e9',1,'s2let_fits_hpx_read_nside(char *filename): s2let_fits.c'],['../s2let__fits_8h.html#a332b4542fd283126c1bfd55c6f96d0e9',1,'s2let_fits_hpx_read_nside(char *filename): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fread_5fbandlimit_413',['s2let_fits_mw_read_bandlimit',['../s2let__fits_8c.html#a32b9baca740954e5dd89ff84a873bd5f',1,'s2let_fits_mw_read_bandlimit(char *filename): s2let_fits.c'],['../s2let__fits_8h.html#a32b9baca740954e5dd89ff84a873bd5f',1,'s2let_fits_mw_read_bandlimit(char *filename): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fread_5fmap_414',['s2let_fits_mw_read_map',['../s2let__fits_8c.html#af6db1f82ef3c0d037656ec6ac54e2d19',1,'s2let_fits_mw_read_map(double *f, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a8f3efe334a8689717e3c4af67bfcc182',1,'s2let_fits_mw_read_map(double *f, char *file, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fread_5fspin_5fmaps_415',['s2let_fits_mw_read_spin_maps',['../s2let__fits_8c.html#a76db1cab8202e48ed93378d68d5e1b0f',1,'s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a6452019812d547dc0de6888e76c9f2db',1,'s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *file, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fwrite_5fmap_416',['s2let_fits_mw_write_map',['../s2let__fits_8c.html#a33e069a17c3116f44eb667a9cba40615',1,'s2let_fits_mw_write_map(char *filename, double *f, int L): s2let_fits.c'],['../s2let__fits_8h.html#ae98dbd904653a070d64f31fa37bfa617',1,'s2let_fits_mw_write_map(char *file, double *f, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmw_5fwrite_5fspin_5fmaps_417',['s2let_fits_mw_write_spin_maps',['../s2let__fits_8c.html#a5c22448360290d72a157eb886a3bb23e',1,'s2let_fits_mw_write_spin_maps(char *filename, double *fQ, double *fU, int L): s2let_fits.c'],['../s2let__fits_8h.html#afe7d32ae54ded848bd7a7cb25d4dba93',1,'s2let_fits_mw_write_spin_maps(char *file, double *fQ, double *fU, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmwss_5fread_5fmap_418',['s2let_fits_mwss_read_map',['../s2let__fits_8c.html#a30d6c0469210655e662bbdf8153d3e3f',1,'s2let_fits_mwss_read_map(double *f, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#ad022bd34785d0cc2d5a2b1f924ba26fd',1,'s2let_fits_mwss_read_map(double *f, char *file, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmwss_5fread_5fspin_5fmaps_419',['s2let_fits_mwss_read_spin_maps',['../s2let__fits_8c.html#abf0138418d23fff52dea5dabb8e2a7fa',1,'s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a85a1bcdf0dee2673f2d5ffd374f2bdfd',1,'s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *file, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmwss_5fwrite_5fmap_420',['s2let_fits_mwss_write_map',['../s2let__fits_8c.html#a7b7613e2e45ffa5e2ff4ef51c88039f7',1,'s2let_fits_mwss_write_map(char *filename, double *f, int L): s2let_fits.c'],['../s2let__fits_8h.html#a22e885366d6e8367fd5afe62679ff42f',1,'s2let_fits_mwss_write_map(char *file, double *f, int L): s2let_fits.c']]], - ['s2let_5ffits_5fmwss_5fwrite_5fspin_5fmaps_421',['s2let_fits_mwss_write_spin_maps',['../s2let__fits_8c.html#ac0aa9a648728c543e0a15490e639b7e7',1,'s2let_fits_mwss_write_spin_maps(char *filename, double *fQ, double *fU, int L): s2let_fits.c'],['../s2let__fits_8h.html#abb0ad8df2666842d52b8b6b724d2688f',1,'s2let_fits_mwss_write_spin_maps(char *file, double *fQ, double *fU, int L): s2let_fits.c']]], - ['s2let_5fhpx_5fallocate_5freal_422',['s2let_hpx_allocate_real',['../s2let__hpx_8c.html#a5fd3f8d1975ab0798c4797665256083a',1,'s2let_hpx_allocate_real(double **f, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a5fd3f8d1975ab0798c4797665256083a',1,'s2let_hpx_allocate_real(double **f, int nside): s2let_hpx.c']]], - ['s2let_5fhpx_5falm2map_5freal_423',['s2let_hpx_alm2map_real',['../s2let__hpx_8c.html#a3a16f082dbd93ca1413282167eb70b78',1,'s2let_hpx_alm2map_real(double *f, const complex double *flm, int nside, int L): s2let_hpx.c'],['../s2let__hpx_8h.html#adfeed42820bd0d0c686c83b87c091050',1,'s2let_hpx_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int nside, int L): s2let_hpx.h']]], - ['s2let_5fhpx_5falm2map_5fspin_5freal_424',['s2let_hpx_alm2map_spin_real',['../s2let__hpx_8c.html#a628694892c6f91d3e04fef9fccf145d9',1,'s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const complex double *flmE, const complex double *flmB, int nside, int L, int spin): s2let_hpx.c'],['../s2let__hpx_8h.html#aeeb308d10fad6609143c7b88add754c1',1,'s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const S2LET_COMPLEX(double) *flmE, const S2LET_COMPLEX(double) *flmB, int nside, int L, int spin): s2let_hpx.h']]], - ['s2let_5fhpx_5fio_5ftest_425',['s2let_hpx_io_test',['../s2let__hpx__test_8c.html#a38519222c90d787d322f0163273466c6',1,'s2let_hpx_test.c']]], - ['s2let_5fhpx_5fmap2alm_5freal_426',['s2let_hpx_map2alm_real',['../s2let__hpx_8c.html#a78d966279d936b4937553e58b88265f3',1,'s2let_hpx_map2alm_real(complex double *flm, const double *f, int nside, int L): s2let_hpx.c'],['../s2let__hpx_8h.html#addf44689d1620ff08e9e623064a3da0f',1,'s2let_hpx_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int nside, int L): s2let_hpx.h']]], - ['s2let_5fhpx_5fmap2alm_5fspin_5freal_427',['s2let_hpx_map2alm_spin_real',['../s2let__hpx_8c.html#a9183b4967c1e5f8a6c973a1697362e91',1,'s2let_hpx_map2alm_spin_real(complex double *flmE, complex double *flmB, const double *fQ, const double *fU, int nside, int L, int spin): s2let_hpx.c'],['../s2let__hpx_8h.html#aa7a27c83a31e71f1fd90bdf0bbb84a8d',1,'s2let_hpx_map2alm_spin_real(S2LET_COMPLEX(double) *flmE, S2LET_COMPLEX(double) *flmB, const double *fQ, const double *fU, int nside, int L, int spin): s2let_hpx.h']]], - ['s2let_5fhpx_5fread_5fmap_428',['s2let_hpx_read_map',['../s2let__hpx_8c.html#a007bb3a6640667248187f9ac38b9d6a4',1,'s2let_hpx_read_map(double *f, char *file, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a007bb3a6640667248187f9ac38b9d6a4',1,'s2let_hpx_read_map(double *f, char *file, int nside): s2let_hpx.c']]], - ['s2let_5fhpx_5fread_5fmaps_429',['s2let_hpx_read_maps',['../s2let__hpx_8c.html#a5c51e9a1cbae07bee6dede794c93470c',1,'s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps): s2let_hpx.c'],['../s2let__hpx_8h.html#a5c51e9a1cbae07bee6dede794c93470c',1,'s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps): s2let_hpx.c']]], - ['s2let_5fhpx_5fspinalm_5ftest_430',['s2let_hpx_spinalm_test',['../s2let__hpx__test_8c.html#a2d59903931d514b42dadfe993b697712',1,'s2let_hpx_test.c']]], - ['s2let_5fhpx_5fwrite_5fmap_431',['s2let_hpx_write_map',['../s2let__hpx_8c.html#a5f03d8745c5e15c0f03c2546464ec042',1,'s2let_hpx_write_map(char *file, const double *f, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a5f03d8745c5e15c0f03c2546464ec042',1,'s2let_hpx_write_map(char *file, const double *f, int nside): s2let_hpx.c']]], - ['s2let_5fidl_5faxisym_5fhpx_5fwav_5fanalysis_5freal_432',['s2let_idl_axisym_hpx_wav_analysis_real',['../s2let__idl__hpx_8c.html#a8d5e1acca474c541532a3c249a2f3814',1,'s2let_idl_hpx.c']]], - ['s2let_5fidl_5faxisym_5fhpx_5fwav_5fsynthesis_5freal_433',['s2let_idl_axisym_hpx_wav_synthesis_real',['../s2let__idl__hpx_8c.html#a8bbb1aa9b6b3987cd55b6f6d2ac212f5',1,'s2let_idl_hpx.c']]], - ['s2let_5fidl_5fhpx_5falm2map_5freal_434',['s2let_idl_hpx_alm2map_real',['../s2let__idl__hpx_8c.html#a2405269f6a3905d347497fdd8f8737b2',1,'s2let_idl_hpx_alm2map_real(int argc, void *argv[]): s2let_idl_hpx.c'],['../s2let__idl__hpx_8h.html#a2405269f6a3905d347497fdd8f8737b2',1,'s2let_idl_hpx_alm2map_real(int argc, void *argv[]): s2let_idl_hpx.c']]], - ['s2let_5fidl_5fhpx_5faxisym_5fwav_5fanalysis_5freal_435',['s2let_idl_hpx_axisym_wav_analysis_real',['../s2let__idl__hpx_8h.html#af0b753f2c0d41972ff727e18bbf51490',1,'s2let_idl_hpx.h']]], - ['s2let_5fidl_5fhpx_5faxisym_5fwav_5fsynthesis_5freal_436',['s2let_idl_hpx_axisym_wav_synthesis_real',['../s2let__idl__hpx_8h.html#a780c8d58d24780b54367b2751d456d21',1,'s2let_idl_hpx.h']]], - ['s2let_5fidl_5fhpx_5fmap2alm_5freal_437',['s2let_idl_hpx_map2alm_real',['../s2let__idl__hpx_8c.html#ad34b479c1681a81cc1c707def15d296c',1,'s2let_idl_hpx_map2alm_real(int argc, void *argv[]): s2let_idl_hpx.c'],['../s2let__idl__hpx_8h.html#ad34b479c1681a81cc1c707def15d296c',1,'s2let_idl_hpx_map2alm_real(int argc, void *argv[]): s2let_idl_hpx.c']]], - ['s2let_5fidl_5fmw_5falm2map_438',['s2let_idl_mw_alm2map',['../s2let__idl__mw_8c.html#a4c2ef5574faf8b82ca91295b1321b5e8',1,'s2let_idl_mw.c']]], - ['s2let_5fidl_5fmw_5falm2map_5freal_439',['s2let_idl_mw_alm2map_real',['../s2let__idl__mw_8c.html#af7a317220109dabfc86d0dd5c4b8987c',1,'s2let_idl_mw.c']]], - ['s2let_5fidl_5fmw_5fmap2alm_440',['s2let_idl_mw_map2alm',['../s2let__idl__mw_8c.html#a2e12cdca9f43efd97ab6a93da615599c',1,'s2let_idl_mw.c']]], - ['s2let_5fidl_5fmw_5fmap2alm_5freal_441',['s2let_idl_mw_map2alm_real',['../s2let__idl__mw_8c.html#ac5974e9a553e5ca74bcf2cedf0faa970',1,'s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5falm2map_442',['s2let_idl_transform_alm2map',['../s2let__idl__mw_8h.html#aee50e78b2a8b7521629d086621d23c60',1,'s2let_idl_mw.h']]], - ['s2let_5fidl_5ftransform_5falm2map_5freal_443',['s2let_idl_transform_alm2map_real',['../s2let__idl__mw_8h.html#aceb297101069e992a356fadfc43820d0',1,'s2let_idl_mw.h']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_444',['s2let_idl_transform_axisym_wav_analysis_mw',['../s2let__idl__mw_8c.html#a7fcf1a787d1d465620d3287703e5ce6c',1,'s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a7fcf1a787d1d465620d3287703e5ce6c',1,'s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_445',['s2let_idl_transform_axisym_wav_analysis_mw_multires',['../s2let__idl__mw_8c.html#a97466a06e494b38c4d60a7f6839a41e3',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a97466a06e494b38c4d60a7f6839a41e3',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_5freal_446',['s2let_idl_transform_axisym_wav_analysis_mw_multires_real',['../s2let__idl__mw_8c.html#ad1712f32e26d77c9b21b7f3bd62f4609',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad1712f32e26d77c9b21b7f3bd62f4609',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5freal_447',['s2let_idl_transform_axisym_wav_analysis_mw_real',['../s2let__idl__mw_8c.html#a168466d81a6d248d0b4280a9687d8172',1,'s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a168466d81a6d248d0b4280a9687d8172',1,'s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_448',['s2let_idl_transform_axisym_wav_synthesis_mw',['../s2let__idl__mw_8c.html#ad3bd4d2483d2716820eb6b0d107cd75b',1,'s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad3bd4d2483d2716820eb6b0d107cd75b',1,'s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_449',['s2let_idl_transform_axisym_wav_synthesis_mw_multires',['../s2let__idl__mw_8c.html#abb8950501cac08ff378bc0dbf172eb73',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#abb8950501cac08ff378bc0dbf172eb73',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_5freal_450',['s2let_idl_transform_axisym_wav_synthesis_mw_multires_real',['../s2let__idl__mw_8c.html#ad0f7dd4ae05137d49d8e35e4e2dd827e',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad0f7dd4ae05137d49d8e35e4e2dd827e',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5freal_451',['s2let_idl_transform_axisym_wav_synthesis_mw_real',['../s2let__idl__mw_8c.html#a61efa315fb01f338ed265b7898c91caa',1,'s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a61efa315fb01f338ed265b7898c91caa',1,'s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[]): s2let_idl_mw.c']]], - ['s2let_5fidl_5ftransform_5fmap2alm_452',['s2let_idl_transform_map2alm',['../s2let__idl__mw_8h.html#a2653d09d0f6ab88cfb2803505da9fd6b',1,'s2let_idl_mw.h']]], - ['s2let_5fidl_5ftransform_5fmap2alm_5freal_453',['s2let_idl_transform_map2alm_real',['../s2let__idl__mw_8h.html#a8e509c9e23c2225aafdc6e77c6b73c58',1,'s2let_idl_mw.h']]], - ['s2let_5fj_5fmax_454',['s2let_j_max',['../s2let__tiling_8c.html#af8e45477d8b8a0bbd2f0dd706ee29f7e',1,'s2let_j_max(const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#af8e45477d8b8a0bbd2f0dd706ee29f7e',1,'s2let_j_max(const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5fl0_455',['s2let_L0',['../s2let__tiling_8c.html#a970c83288da0b2f1b0c783dc32da5d58',1,'s2let_L0(int j, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a970c83288da0b2f1b0c783dc32da5d58',1,'s2let_L0(int j, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5flm_5fpower_456',['s2let_lm_power',['../s2let__lm_8c.html#a520c6e822fd2d004f87b0babf793b93b',1,'s2let_lm_power(complex double *flm, int L): s2let_lm.c'],['../s2let__lm_8h.html#ace994f794328a0338095553fd7e81c2e',1,'s2let_lm_power(S2LET_COMPLEX(double) *flm, int L): s2let_lm.h']]], - ['s2let_5flm_5frandom_5fflm_457',['s2let_lm_random_flm',['../s2let__lm_8c.html#aecdba2ebff470192c677d787331440da',1,'s2let_lm_random_flm(complex double *flm, int L, int spin, int seed): s2let_lm.c'],['../s2let__lm_8h.html#aa1cf89a60a2c297ed93525c7abd36d82',1,'s2let_lm_random_flm(S2LET_COMPLEX(double) *flm, int L, int spin, int seed): s2let_lm.h']]], - ['s2let_5flm_5frandom_5fflm_5freal_458',['s2let_lm_random_flm_real',['../s2let__lm_8c.html#a976ccda30f8c30bfbcd238242deef100',1,'s2let_lm_random_flm_real(complex double *flm, int L, int seed): s2let_lm.c'],['../s2let__lm_8h.html#a52b1d6d06e4ac3b5d386b6a9a9f5d9d1',1,'s2let_lm_random_flm_real(S2LET_COMPLEX(double) *flm, int L, int seed): s2let_lm.h']]], - ['s2let_5flm_5frandom_5fflm_5freal_5fsigma_459',['s2let_lm_random_flm_real_sigma',['../s2let__axisym__denoising__demo_8c.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8c.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_denoising_demo.c'],['../s2let__axisym__denoising__demo_8h.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8h.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c']]], - ['s2let_5flm_5frandom_5fflm_5fsigma_460',['s2let_lm_random_flm_sigma',['../s2let__spin__denoising__demo_8c.html#a8f2d6d26977c37558bd348037fac075f',1,'s2let_spin_denoising_demo.c']]], - ['s2let_5fmath_5fkappa0_5fquadtrap_5fneedlet_461',['s2let_math_kappa0_quadtrap_needlet',['../s2let__math_8c.html#a1ee31db982694aeff4308288cb38e044',1,'s2let_math_kappa0_quadtrap_needlet(double a, double b, int n): s2let_math.c'],['../s2let__math_8h.html#a1ee31db982694aeff4308288cb38e044',1,'s2let_math_kappa0_quadtrap_needlet(double a, double b, int n): s2let_math.c']]], - ['s2let_5fmath_5fkappa0_5fquadtrap_5fs2dw_462',['s2let_math_kappa0_quadtrap_s2dw',['../s2let__math_8c.html#a44eb4f6042bf9dd406b3da22eca7e434',1,'s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B): s2let_math.c'],['../s2let__math_8h.html#a44eb4f6042bf9dd406b3da22eca7e434',1,'s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B): s2let_math.c']]], - ['s2let_5fmath_5fspline_5fscalingfct_463',['s2let_math_spline_scalingfct',['../s2let__math_8c.html#a5a6d036165ebcd79b2c4f5716a42bcd8',1,'s2let_math_spline_scalingfct(double x, double y): s2let_math.c'],['../s2let__math_8h.html#a5a6d036165ebcd79b2c4f5716a42bcd8',1,'s2let_math_spline_scalingfct(double x, double y): s2let_math.c']]], - ['s2let_5fmw_5falm2map_464',['s2let_mw_alm2map',['../s2let__mw_8c.html#a71a1d94b45021758562acb54f7efbadc',1,'s2let_mw_alm2map(complex double *f, const complex double *flm, int L, int spin): s2let_mw.c'],['../s2let__mw_8h.html#adbfa150db5b9bcca2993df5e14cb05b9',1,'s2let_mw_alm2map(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *flm, int L, int spin): s2let_mw.h']]], - ['s2let_5fmw_5falm2map_5freal_465',['s2let_mw_alm2map_real',['../s2let__mw_8c.html#acec65039b721a60d622aa6ccdc57fe58',1,'s2let_mw_alm2map_real(double *f, const complex double *flm, int L): s2let_mw.c'],['../s2let__mw_8h.html#a845b320975dc03e952f28c539da9d426',1,'s2let_mw_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int L): s2let_mw.h']]], - ['s2let_5fmw_5fio_5fspin_5ftest_466',['s2let_mw_io_spin_test',['../s2let__hpx__test_8c.html#a2cb09cab436803d8581b6b96959dff9e',1,'s2let_hpx_test.c']]], - ['s2let_5fmw_5fio_5ftest_467',['s2let_mw_io_test',['../s2let__hpx__test_8c.html#af91cc34a400e0f94e570728ac6f6c759',1,'s2let_hpx_test.c']]], - ['s2let_5fmw_5fmap2alm_468',['s2let_mw_map2alm',['../s2let__mw_8c.html#ae2d95be7cf71bfe84060dbdd77c6947b',1,'s2let_mw_map2alm(complex double *flm, const complex double *f, int L, int spin): s2let_mw.c'],['../s2let__mw_8h.html#a727851e328422320a31ef6548631e0dd',1,'s2let_mw_map2alm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f, int L, int spin): s2let_mw.h']]], - ['s2let_5fmw_5fmap2alm_5freal_469',['s2let_mw_map2alm_real',['../s2let__mw_8c.html#adee030c15f2b401361c278a6c6ea6f7c',1,'s2let_mw_map2alm_real(complex double *flm, const double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#a297725ba5e35713e59c0b601a6964942',1,'s2let_mw_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int L): s2let_mw.h']]], - ['s2let_5fmw_5fpower_470',['s2let_mw_power',['../s2let__mw_8c.html#a91dbb4ab1556928322986d21d413abdf',1,'s2let_mw_power(complex double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#aceb97384257965caeb908162dae89009',1,'s2let_mw_power(S2LET_COMPLEX(double) *flm, int L): s2let_mw.h']]], - ['s2let_5fmw_5fpower_5freal_471',['s2let_mw_power_real',['../s2let__mw_8c.html#a3520764bba2023b957373df5769f25e8',1,'s2let_mw_power_real(double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#aa3c531ec00960d928d8d7fca2f6a3108',1,'s2let_mw_power_real(double *flm, int L): s2let_mw.c']]], - ['s2let_5fn_5fgamma_472',['s2let_n_gamma',['../s2let__helper_8c.html#a33cd356d3eca688b51e0a70cc216b3c6',1,'s2let_n_gamma(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a33cd356d3eca688b51e0a70cc216b3c6',1,'s2let_n_gamma(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5flm_473',['s2let_n_lm',['../s2let__helper_8c.html#a31cd45045fa530a8b67db235da15d29f',1,'s2let_n_lm(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a31cd45045fa530a8b67db235da15d29f',1,'s2let_n_lm(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5flm_5fscal_474',['s2let_n_lm_scal',['../s2let__helper_8c.html#aaf6daa1bc9b68e76a247860c57a9e8b9',1,'s2let_n_lm_scal(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aaf6daa1bc9b68e76a247860c57a9e8b9',1,'s2let_n_lm_scal(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5flmn_5fwav_475',['s2let_n_lmn_wav',['../s2let__helper_8c.html#a8db8dd8265358a8501a40fe77c4ab908',1,'s2let_n_lmn_wav(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a8db8dd8265358a8501a40fe77c4ab908',1,'s2let_n_lmn_wav(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fphi_476',['s2let_n_phi',['../s2let__helper_8c.html#aca44ba24618888aa56773d0fa662bb87',1,'s2let_n_phi(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aca44ba24618888aa56773d0fa662bb87',1,'s2let_n_phi(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fpx_477',['s2let_n_px',['../s2let__helper_8c.html#a8de2596044e8dbd481d0d86e1ad8bd44',1,'s2let_n_px(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a8de2596044e8dbd481d0d86e1ad8bd44',1,'s2let_n_px(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fscal_478',['s2let_n_scal',['../s2let__helper_8c.html#a94202177168781d62964cfb09b568d77',1,'s2let_n_scal(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a94202177168781d62964cfb09b568d77',1,'s2let_n_scal(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5ftheta_479',['s2let_n_theta',['../s2let__helper_8c.html#a93ae2fb9184ae2bb35200063113b3db8',1,'s2let_n_theta(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a93ae2fb9184ae2bb35200063113b3db8',1,'s2let_n_theta(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fwav_480',['s2let_n_wav',['../s2let__helper_8c.html#aa267d575405f5aec34f642d7278ea15c',1,'s2let_n_wav(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aa267d575405f5aec34f642d7278ea15c',1,'s2let_n_wav(const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fn_5fwav_5fj_481',['s2let_n_wav_j',['../s2let__helper_8c.html#a5489f45f63977ad580729370eeabd3c8',1,'s2let_n_wav_j(int j, const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a5489f45f63977ad580729370eeabd3c8',1,'s2let_n_wav_j(int j, const s2let_parameters_t *parameters): s2let_helper.c']]], - ['s2let_5fswitch_5fwavtype_482',['s2let_switch_wavtype',['../s2let__tiling_8c.html#a740dd43f4aeae426b96bd4488881297c',1,'s2let_switch_wavtype(int typenum): s2let_tiling.c'],['../s2let__tiling_8h.html#a740dd43f4aeae426b96bd4488881297c',1,'s2let_switch_wavtype(int typenum): s2let_tiling.c']]], - ['s2let_5fsynthesis_5fadjoint_5flm2lmn_483',['s2let_synthesis_adjoint_lm2lmn',['../s2let__synthesis__adjoint_8c.html#aa22074c5b8f3c6f93101bda21dd41477',1,'s2let_synthesis_adjoint_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#ab2e27bf29fd328e5737010a8e965a392',1,'s2let_synthesis_adjoint_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5flm2lmn_5freal_484',['s2let_synthesis_adjoint_lm2lmn_real',['../s2let__synthesis__adjoint_8c.html#a3b3ba86b4c6ccbea501743a31f0fbaba',1,'s2let_synthesis_adjoint_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a8f619d5750ea69d11f5a8a72e7789c5c',1,'s2let_synthesis_adjoint_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5flm2wav_485',['s2let_synthesis_adjoint_lm2wav',['../s2let__synthesis__adjoint_8c.html#a0ded78fd254dfcf523607af9d6384b04',1,'s2let_synthesis_adjoint_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a076501801b028f2c5a43b703afc55746',1,'s2let_synthesis_adjoint_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5flm2wav_5fmanual_486',['s2let_synthesis_adjoint_lm2wav_manual',['../s2let__synthesis__adjoint_8c.html#af1ad88c078072d2c2f9262ab60664627',1,'s2let_synthesis_adjoint_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a80993ff9162a6694085cad936b366c66',1,'s2let_synthesis_adjoint_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5flm2wav_5freal_487',['s2let_synthesis_adjoint_lm2wav_real',['../s2let__synthesis__adjoint_8c.html#a3d89c7c0fd47c34293d0c915e8680212',1,'s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a3ca845d22e3f872b584ba8078eebdf2c',1,'s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5fpx2wav_488',['s2let_synthesis_adjoint_px2wav',['../s2let__synthesis__adjoint_8c.html#af92b8ee7a5d7467aca1aadf574101ed1',1,'s2let_synthesis_adjoint_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#acb574fe4af36dac2771e323b23f038f5',1,'s2let_synthesis_adjoint_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], - ['s2let_5fsynthesis_5fadjoint_5fpx2wav_5freal_489',['s2let_synthesis_adjoint_px2wav_real',['../s2let__synthesis__adjoint_8c.html#a8ac56364e5e11e70afdc89dcbdfa5e54',1,'s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a8ac56364e5e11e70afdc89dcbdfa5e54',1,'s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c']]], - ['s2let_5fsynthesis_5flmn2lm_490',['s2let_synthesis_lmn2lm',['../s2let__synthesis_8c.html#aeab2e51756b722c7fcb0246fa7bcf4e8',1,'s2let_synthesis_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a07acb11aa82e55efc3af49548de2c595',1,'s2let_synthesis_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5flmn2lm_5freal_491',['s2let_synthesis_lmn2lm_real',['../s2let__synthesis_8c.html#ae985651ea8c8225166983b660e15648e',1,'s2let_synthesis_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#adfeebcfa8d5032b78dd85634a5c32b1e',1,'s2let_synthesis_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2lm_492',['s2let_synthesis_wav2lm',['../s2let__synthesis_8c.html#ad898b41a0d83f31033c87f43339dccc2',1,'s2let_synthesis_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a69a72f4cf574108a313f7320b093beee',1,'s2let_synthesis_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2lm_5fmanual_493',['s2let_synthesis_wav2lm_manual',['../s2let__synthesis_8c.html#ae32a0ec051091cb18844e51d8d0ad7fd',1,'s2let_synthesis_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis.c'],['../s2let__synthesis_8h.html#ad3cd8f875820fc345277f57957f6ad40',1,'s2let_synthesis_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2lm_5freal_494',['s2let_synthesis_wav2lm_real',['../s2let__synthesis_8c.html#ab4592958d2f658ac6711edb3589a0d04',1,'s2let_synthesis_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a21c5e68bb92ff9cb6d50a2fd19213a2e',1,'s2let_synthesis_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2px_495',['s2let_synthesis_wav2px',['../s2let__synthesis_8c.html#a171869de60c6dba907994e24eb1ad568',1,'s2let_synthesis_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#aa051be81ee272ce0291f78b66170c5db',1,'s2let_synthesis_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], - ['s2let_5fsynthesis_5fwav2px_5freal_496',['s2let_synthesis_wav2px_real',['../s2let__synthesis_8c.html#a4ef1adffb439379ca652533588879ab5',1,'s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a4ef1adffb439379ca652533588879ab5',1,'s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c']]], - ['s2let_5ftiling_5faxisym_497',['s2let_tiling_axisym',['../s2let__tiling_8c.html#a2dcc3541cd5003f7c20189b5f1e569b0',1,'s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a2dcc3541cd5003f7c20189b5f1e569b0',1,'s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5ftiling_5faxisym_5fallocate_498',['s2let_tiling_axisym_allocate',['../s2let__tiling_8c.html#acfff04a4e1d0f2c422b2c0a22a01c9a9',1,'s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#acfff04a4e1d0f2c422b2c0a22a01c9a9',1,'s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5ftiling_5faxisym_5fcheck_5fidentity_499',['s2let_tiling_axisym_check_identity',['../s2let__tiling_8c.html#a895b0a2aed140ef5591af7ac630d6113',1,'s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a895b0a2aed140ef5591af7ac630d6113',1,'s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], - ['s2let_5ftiling_5faxisym_5ftest_500',['s2let_tiling_axisym_test',['../s2let__test_8c.html#a72ed78cf85c9437d0a2545c8e3a61cf2',1,'s2let_test.c']]], - ['s2let_5ftiling_5fdirection_501',['s2let_tiling_direction',['../s2let__tiling_8c.html#a4811cf4eadbebb73245f54b676734b17',1,'s2let_tiling_direction(complex double *s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ae2b1be4ee6ee593ccc3673bb8c8119a0',1,'s2let_tiling_direction(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fdirection_5fallocate_502',['s2let_tiling_direction_allocate',['../s2let__tiling_8c.html#a10fa29a59b170d6ade97303878faf7ef',1,'s2let_tiling_direction_allocate(complex double **s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a14a6f342214def49e0a4007425a85885',1,'s2let_tiling_direction_allocate(S2LET_COMPLEX(double) **s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fdirection_5fcheck_5fidentity_503',['s2let_tiling_direction_check_identity',['../s2let__tiling_8c.html#ab69e82a484169f248873ae9ccb5bb89a',1,'s2let_tiling_direction_check_identity(complex double *s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a57fea5748d955b5caa9ddf46cda3036b',1,'s2let_tiling_direction_check_identity(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fdirection_5ftest_504',['s2let_tiling_direction_test',['../s2let__test_8c.html#a84ab4ae94142563376cc58ce9b3f0529',1,'s2let_test.c']]], - ['s2let_5ftiling_5fphi2_5fneedlet_505',['s2let_tiling_phi2_needlet',['../s2let__tiling_8c.html#aa9f045a72ccf0df8bff4a8a245ecc52a',1,'s2let_tiling.c']]], - ['s2let_5ftiling_5fphi2_5fs2dw_506',['s2let_tiling_phi2_s2dw',['../s2let__tiling_8c.html#a255c8db4bb8f33e546d44e2b96fd4eb5',1,'s2let_tiling.c']]], - ['s2let_5ftiling_5fphi2_5fspline_507',['s2let_tiling_phi2_spline',['../s2let__tiling_8c.html#afd4de938c00ee3cbde3e6e10944a496b',1,'s2let_tiling.c']]], - ['s2let_5ftiling_5fwavelet_508',['s2let_tiling_wavelet',['../s2let__tiling_8c.html#a9878fae074371b64e7de24ebfdbd752c',1,'s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ae0e09c45e6d87dee84f94bb04b6215d8',1,'s2let_tiling_wavelet(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fwavelet_5fallocate_509',['s2let_tiling_wavelet_allocate',['../s2let__tiling_8c.html#af1770bfbe7ff5ead2769089867a03fbb',1,'s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#af5491812d40095dfbab3c08edf4d9fa5',1,'s2let_tiling_wavelet_allocate(S2LET_COMPLEX(double) **psi, double **phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fwavelet_5fcheck_5fidentity_510',['s2let_tiling_wavelet_check_identity',['../s2let__tiling_8c.html#abd52d0b819985f55fe6fca8259597b48',1,'s2let_tiling_wavelet_check_identity(complex double *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a9a4117a039022f6fff78939c4e0f3a86',1,'s2let_tiling_wavelet_check_identity(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], - ['s2let_5ftiling_5fwavelet_5ftest_511',['s2let_tiling_wavelet_test',['../s2let__test_8c.html#ad612b1930b2a90f6bb8b507f6dc2ae4d',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fhpx_5ff_5fwav_5freal_512',['s2let_transform_axisym_allocate_hpx_f_wav_real',['../s2let__transform__axisym__hpx_8c.html#a8d0f962069938cdf19c4ad1cce2862f8',1,'s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#a8d0f962069938cdf19c4ad1cce2862f8',1,'s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_513',['s2let_transform_axisym_allocate_mw_f_wav',['../s2let__transform__axisym__mw_8c.html#abdb0070e4e2f67007c6755020cbf3f76',1,'s2let_transform_axisym_allocate_mw_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aa0ce4a50c9b076757a1360030dc00c9e',1,'s2let_transform_axisym_allocate_mw_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5fmultires_514',['s2let_transform_axisym_allocate_mw_f_wav_multires',['../s2let__transform__axisym__mw_8c.html#a34f35be55f0d7920e66ffa96948b7132',1,'s2let_transform_axisym_allocate_mw_f_wav_multires(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a0c9e93d33296d57f7722d91288606268',1,'s2let_transform_axisym_allocate_mw_f_wav_multires(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5fmultires_5freal_515',['s2let_transform_axisym_allocate_mw_f_wav_multires_real',['../s2let__transform__axisym__mw_8c.html#aaf2dc03fea7d12bf85c36ecb827c67f1',1,'s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aaf2dc03fea7d12bf85c36ecb827c67f1',1,'s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5freal_516',['s2let_transform_axisym_allocate_mw_f_wav_real',['../s2let__transform__axisym__mw_8c.html#a71d7ea7def45be0508e37eb4789a42be',1,'s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a71d7ea7def45be0508e37eb4789a42be',1,'s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fhpx_5ftest_517',['s2let_transform_axisym_hpx_test',['../s2let__hpx__test_8c.html#a967b49df6d8f162875b8fd691fc5673e',1,'s2let_hpx_test.c']]], - ['s2let_5ftransform_5faxisym_5fhpx_5fwav_5ftest_518',['s2let_transform_axisym_hpx_wav_test',['../s2let__hpx__test_8c.html#ae0c6235281f47c3580a082a8ff6442a0',1,'s2let_hpx_test.c']]], - ['s2let_5ftransform_5faxisym_5flm_5fallocate_5ff_5fwav_519',['s2let_transform_axisym_lm_allocate_f_wav',['../s2let__transform__axisym__lm_8c.html#a27717c57665b77ad3f6f5aef35c1c9e4',1,'s2let_transform_axisym_lm_allocate_f_wav(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a6ed8eae362ffc710e4f256f4a2c7a59c',1,'s2let_transform_axisym_lm_allocate_f_wav(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fallocate_5ff_5fwav_5fmultires_520',['s2let_transform_axisym_lm_allocate_f_wav_multires',['../s2let__transform__axisym__lm_8c.html#a53fc1d52b6e959e2d2a23319237c9087',1,'s2let_transform_axisym_lm_allocate_f_wav_multires(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a49deaad455c0f37f085794a95bc2cc8f',1,'s2let_transform_axisym_lm_allocate_f_wav_multires(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fallocate_5fwav_521',['s2let_transform_axisym_lm_allocate_wav',['../s2let__transform__axisym__lm_8c.html#ae5c57282bb1116eababa279c2f8757a9',1,'s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#ae5c57282bb1116eababa279c2f8757a9',1,'s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_522',['s2let_transform_axisym_lm_wav',['../s2let__transform__axisym__lm_8c.html#a2efd3fe3938b0f6cb3166804f0ca62bc',1,'s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a2efd3fe3938b0f6cb3166804f0ca62bc',1,'s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fanalysis_523',['s2let_transform_axisym_lm_wav_analysis',['../s2let__transform__axisym__lm_8c.html#a1363fa22f22fe3faf9601fc4d8dc2185',1,'s2let_transform_axisym_lm_wav_analysis(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#ac7bd36f0e12ae8e06d7f1e8c4c0c1f9e',1,'s2let_transform_axisym_lm_wav_analysis(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fanalysis_5fmultires_524',['s2let_transform_axisym_lm_wav_analysis_multires',['../s2let__transform__axisym__lm_8c.html#ac55ab672138aa0703ba3b3d24a6673c0',1,'s2let_transform_axisym_lm_wav_analysis_multires(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a41cd8c62327019175b700208d2891464',1,'s2let_transform_axisym_lm_wav_analysis_multires(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fmultires_5ftest_525',['s2let_transform_axisym_lm_wav_multires_test',['../s2let__test_8c.html#a6490580b66410b64846b31124ae5a0f4',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fsynthesis_526',['s2let_transform_axisym_lm_wav_synthesis',['../s2let__transform__axisym__lm_8c.html#a288f88b4dd18d732a0d6819c4d06e3f4',1,'s2let_transform_axisym_lm_wav_synthesis(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#acaad9856b9ff5ea5588fff2a796a8ecf',1,'s2let_transform_axisym_lm_wav_synthesis(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5fsynthesis_5fmultires_527',['s2let_transform_axisym_lm_wav_synthesis_multires',['../s2let__transform__axisym__lm_8c.html#ad31585dbae5edde3fc3704a59cbe1034',1,'s2let_transform_axisym_lm_wav_synthesis_multires(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a1cf1b759d1947fea4f100a80d8a420aa',1,'s2let_transform_axisym_lm_wav_synthesis_multires(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], - ['s2let_5ftransform_5faxisym_5flm_5fwav_5ftest_528',['s2let_transform_axisym_lm_wav_test',['../s2let__test_8c.html#a21e0d56f5074c798cb77ee9ccf081e3c',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5fmultires_5ftest_529',['s2let_transform_axisym_vs_directional_mw_multires_test',['../s2let__test_8c.html#a4942f2f69c0519399f61579dc47d98d2',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5ftest_530',['s2let_transform_axisym_vs_directional_mw_test',['../s2let__test_8c.html#a45c632c898e73d473bcc38e492847182',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_531',['s2let_transform_axisym_wav_analysis_adjoint_mw',['../s2let__transform__axisym__mw_8c.html#a73b9085432c8673c6fde059b708dea46',1,'s2let_transform_axisym_wav_analysis_adjoint_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#afca147888501702b34ca4e1767c78710',1,'s2let_transform_axisym_wav_analysis_adjoint_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5fmultires_532',['s2let_transform_axisym_wav_analysis_adjoint_mw_multires',['../s2let__transform__axisym__mw_8c.html#abbbb0b8729b4b4d936723f57fa133bde',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a516ee27f27eb79de7c3214cab7271779',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5fmultires_5freal_533',['s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#ad16f124ef82ba5422107d53991578e2b',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ad16f124ef82ba5422107d53991578e2b',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5freal_534',['s2let_transform_axisym_wav_analysis_adjoint_mw_real',['../s2let__transform__axisym__mw_8c.html#a9d190e3dc17c1e73036fa7def51baf44',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a9d190e3dc17c1e73036fa7def51baf44',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fhpx_5freal_535',['s2let_transform_axisym_wav_analysis_hpx_real',['../s2let__transform__axisym__hpx_8c.html#a3f69c1366658007590fc63877230d1a7',1,'s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#a3f69c1366658007590fc63877230d1a7',1,'s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_536',['s2let_transform_axisym_wav_analysis_mw',['../s2let__transform__axisym__mw_8c.html#a866080c7ca98673e75acaf8f384ea936',1,'s2let_transform_axisym_wav_analysis_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ac768b473723b5e525c959deb48e08825',1,'s2let_transform_axisym_wav_analysis_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_537',['s2let_transform_axisym_wav_analysis_mw_multires',['../s2let__transform__axisym__mw_8c.html#a272edc957f57772f4af7161c4776f118',1,'s2let_transform_axisym_wav_analysis_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aec92f0a5f1bf3d14ed9dcdadd96153c3',1,'s2let_transform_axisym_wav_analysis_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_5freal_538',['s2let_transform_axisym_wav_analysis_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#abbaca141c3699c766e341c5ceee14cdb',1,'s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abbaca141c3699c766e341c5ceee14cdb',1,'s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5freal_539',['s2let_transform_axisym_wav_analysis_mw_real',['../s2let__transform__axisym__mw_8c.html#abab7d46ecc4813503ab0fd5f09d8bfa7',1,'s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abab7d46ecc4813503ab0fd5f09d8bfa7',1,'s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fhardthreshold_5fmultires_5freal_540',['s2let_transform_axisym_wav_hardthreshold_multires_real',['../s2let__transform__axisym__mw_8c.html#ab3b3272365c739034b2c5c8fc00613a9',1,'s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ab3b3272365c739034b2c5c8fc00613a9',1,'s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fhardthreshold_5freal_541',['s2let_transform_axisym_wav_hardthreshold_real',['../s2let__transform__axisym__mw_8c.html#af2f861872a0b6640d8e24202a451272f',1,'s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#af2f861872a0b6640d8e24202a451272f',1,'s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fmultires_5freal_5ftest_542',['s2let_transform_axisym_wav_multires_real_test',['../s2let__test_8c.html#a30b6b4ec19a7bc9c3bb7fb3b933e6c94',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fmultires_5ftest_543',['s2let_transform_axisym_wav_multires_test',['../s2let__test_8c.html#ac20052515fa751c919b54fb6bfb7b5a1',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5freal_5ftest_544',['s2let_transform_axisym_wav_real_test',['../s2let__test_8c.html#a42ef36d238046edb1b4a03e2269797f2',1,'s2let_test.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_545',['s2let_transform_axisym_wav_synthesis_adjoint_mw',['../s2let__transform__axisym__mw_8c.html#a333120eb88ad818a3e360c1004c3d1e8',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a595657bb4bf8ac9d99afe415539eff8e',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5fmultires_546',['s2let_transform_axisym_wav_synthesis_adjoint_mw_multires',['../s2let__transform__axisym__mw_8c.html#a9d4cb0b9b608e1956058899cfba58280',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ac2b1764294b14d89aad77c8473d70e92',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5fmultires_5freal_547',['s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#abcfc455a2b4dfd52f52d095227ff67c3',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abcfc455a2b4dfd52f52d095227ff67c3',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_548',['s2let_transform_axisym_wav_synthesis_adjoint_mw_real',['../s2let__transform__axisym__mw_8c.html#a202737e2b30d90af7984051d82e6b55a',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a202737e2b30d90af7984051d82e6b55a',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fhpx_5freal_549',['s2let_transform_axisym_wav_synthesis_hpx_real',['../s2let__transform__axisym__hpx_8c.html#ad1987cd08f8add08bba681aa26c32b77',1,'s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#ad1987cd08f8add08bba681aa26c32b77',1,'s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_550',['s2let_transform_axisym_wav_synthesis_mw',['../s2let__transform__axisym__mw_8c.html#ab2dba22615138e520985ca58ead38e28',1,'s2let_transform_axisym_wav_synthesis_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a26507106a70d5143e76fba3bb298f7e7',1,'s2let_transform_axisym_wav_synthesis_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_551',['s2let_transform_axisym_wav_synthesis_mw_multires',['../s2let__transform__axisym__mw_8c.html#a002718ed6a64a6d7268626e01931ecba',1,'s2let_transform_axisym_wav_synthesis_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a988074918fff2d3f06b6898542ba1072',1,'s2let_transform_axisym_wav_synthesis_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_5freal_552',['s2let_transform_axisym_wav_synthesis_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#a9a77993fec7b5b26a0290ade7623c1ea',1,'s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a9a77993fec7b5b26a0290ade7623c1ea',1,'s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5freal_553',['s2let_transform_axisym_wav_synthesis_mw_real',['../s2let__transform__axisym__mw_8c.html#a5eec6f7cb23d0ffb408abc583153d496',1,'s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a5eec6f7cb23d0ffb408abc583153d496',1,'s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], - ['s2let_5ftransform_5faxisym_5fwav_5ftest_554',['s2let_transform_axisym_wav_test',['../s2let__test_8c.html#a4f77ce64b0ecb6acdfeb8cd03b5b4d19',1,'s2let_test.c']]], - ['s2let_5ftransform_5flm_5fperformance_5fmultires_5ftest_555',['s2let_transform_lm_performance_multires_test',['../s2let__test_8c.html#a601830de99f48906fcfe6b53907bb190',1,'s2let_test.c']]], - ['s2let_5ftransform_5flm_5fperformance_5ftest_556',['s2let_transform_lm_performance_test',['../s2let__test_8c.html#a677d7f0b1315a8f13a3ecd057a928372',1,'s2let_test.c']]], - ['s2let_5ftransform_5fperformance_5fmultires_5ftest_557',['s2let_transform_performance_multires_test',['../s2let__test_8c.html#a6707d377e1f45cf08f165f35f9b4f4cc',1,'s2let_test.c']]], - ['s2let_5ftransform_5fperformance_5ftest_558',['s2let_transform_performance_test',['../s2let__test_8c.html#abf6416ad05d8f169fc6eadb5a9ad537d',1,'s2let_test.c']]], - ['s2let_5fwav_5fanalysis_5fadjoint_5flm_5flmn_5ftest_559',['s2let_wav_analysis_adjoint_lm_lmn_test',['../s2let__test_8c.html#afc35303ba9eb6beeee088d9f08c3444c',1,'s2let_test.c']]], - ['s2let_5fwav_5fanalysis_5fadjoint_5fmw_5freal_5ftest_560',['s2let_wav_analysis_adjoint_mw_real_test',['../s2let__test_8c.html#a07e8d14353d7a404098560c1a9db92fe',1,'s2let_test.c']]], - ['s2let_5fwav_5fanalysis_5fadjoint_5fmw_5ftest_561',['s2let_wav_analysis_adjoint_mw_test',['../s2let__test_8c.html#a4b3a9612e87e483e27bff0888bd964a0',1,'s2let_test.c']]], - ['s2let_5fwav_5fso3_5fforward_5fadjoint_5ftest_562',['s2let_wav_so3_forward_adjoint_test',['../s2let__test_8c.html#ac85f518078a76b2dd77de9ccc9f34f07',1,'s2let_test.c']]], - ['s2let_5fwav_5fsynthesis_5fadjoint_5flm2wav_5ftest_563',['s2let_wav_synthesis_adjoint_lm2wav_test',['../s2let__test_8c.html#ae9c1885807e8ac48440a0b0d3dd2a667',1,'s2let_test.c']]], - ['s2let_5fwav_5fsynthesis_5fadjoint_5flm_5flmn_5ftest_564',['s2let_wav_synthesis_adjoint_lm_lmn_test',['../s2let__test_8c.html#a33ed7d71c1e2543ab0ec5d5034a0269f',1,'s2let_test.c']]], - ['s2let_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_5ftest_565',['s2let_wav_synthesis_adjoint_mw_real_test',['../s2let__test_8c.html#a5185ca4b0f65740ab88242cff55b796d',1,'s2let_test.c']]], - ['s2let_5fwav_5fsynthesis_5fadjoint_5fmw_5ftest_566',['s2let_wav_synthesis_adjoint_mw_test',['../s2let__test_8c.html#a1bb00b26cbe0fbb23f41778220fa5824',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fharmonic_5fmultires_5ftest_567',['s2let_wav_transform_harmonic_multires_test',['../s2let__test_8c.html#a9a6c059a89a24d1faf87c71d4daa0aad',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fharmonic_5ftest_568',['s2let_wav_transform_harmonic_test',['../s2let__test_8c.html#a36c393819821e9d3230f1b611029c03a',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5flm2wav_5fmultires_5freal_5ftest_569',['s2let_wav_transform_lm2wav_multires_real_test',['../s2let__test_8c.html#a97581c49341c7cd099bde20868fc7cd6',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5flm2wav_5fmultires_5ftest_570',['s2let_wav_transform_lm2wav_multires_test',['../s2let__test_8c.html#af37a0a8300c436e3de4404914b06644b',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5flm2wav_5freal_5ftest_571',['s2let_wav_transform_lm2wav_real_test',['../s2let__test_8c.html#a4631a44a831e086e712e9f1aa7ffab62',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5flm2wav_5ftest_572',['s2let_wav_transform_lm2wav_test',['../s2let__test_8c.html#a2cf679450a2ce6ea636c2dc10f7e540a',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmw_5fmultires_5freal_5ftest_573',['s2let_wav_transform_mw_multires_real_test',['../s2let__test_8c.html#a4d1b3d1c528a9251c2f7ca5841b7ea4c',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmw_5fmultires_5ftest_574',['s2let_wav_transform_mw_multires_test',['../s2let__test_8c.html#a8e3ae237fa88d72d1dbd073219148d14',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmw_5freal_5ftest_575',['s2let_wav_transform_mw_real_test',['../s2let__test_8c.html#a8c730406b8d674ce01adf2f00b23a80b',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmw_5ftest_576',['s2let_wav_transform_mw_test',['../s2let__test_8c.html#ac21ea0848f541e57646992df1f019ac6',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmwss_5fmultires_5freal_5ftest_577',['s2let_wav_transform_mwss_multires_real_test',['../s2let__test_8c.html#a98871d63a676332bf18fa0e759ed7b75',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmwss_5fmultires_5ftest_578',['s2let_wav_transform_mwss_multires_test',['../s2let__test_8c.html#a47c841b99612070b47ad9cc82e15381f',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmwss_5freal_5ftest_579',['s2let_wav_transform_mwss_real_test',['../s2let__test_8c.html#a0405e044e4b231f44c78768efa065da2',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fmwss_5ftest_580',['s2let_wav_transform_mwss_test',['../s2let__test_8c.html#a50a13ab98a0345f3d9d66d4252f6b4c6',1,'s2let_test.c']]], - ['s2let_5fwav_5ftransform_5fwavlm_5fmanual_5ftest_581',['s2let_wav_transform_wavlm_manual_test',['../s2let__test_8c.html#a73199654867cc48b0fdfa593987dfecd',1,'s2let_test.c']]], - ['so3_5ftest_5fgen_5fflmn_5fcomplex_582',['so3_test_gen_flmn_complex',['../s2let__test_8c.html#af5b2cded1bb3914d1398df3b65eec310',1,'s2let_test.c']]] + ['s2let_5fallocate_5ff_5fwav_426',['s2let_allocate_f_wav',['../s2let__alloc_8c.html#a04372bb80be30ca4b5442c682c550866',1,'s2let_allocate_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a1e37dc2888e4d40c947e7c7727eb8ad7',1,'s2let_allocate_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_alloc.h']]], + ['s2let_5fallocate_5ff_5fwav_5fmanual_427',['s2let_allocate_f_wav_manual',['../s2let__alloc_8c.html#afb051ec7fd9741b39b184f4b957acd36',1,'s2let_allocate_f_wav_manual(complex double **f_wav, complex double **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#afc97a325f105008a466164506e12c864',1,'s2let_allocate_f_wav_manual(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, int *wav_bandlimits, int scal_bandlimit, int N, int J, const s2let_parameters_t *parameters): s2let_alloc.h']]], + ['s2let_5fallocate_5ff_5fwav_5freal_428',['s2let_allocate_f_wav_real',['../s2let__alloc_8c.html#a979f526f58f72c9c96e16e2ba46e0f63',1,'s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a979f526f58f72c9c96e16e2ba46e0f63',1,'s2let_allocate_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_alloc.c']]], + ['s2let_5fallocate_5flm_429',['s2let_allocate_lm',['../s2let__alloc_8c.html#a8b221a008760c8dbe1a655c74dc2d0d0',1,'s2let_allocate_lm(complex double **flm, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#aa7bc8a069c40873338f1e8c770f34424',1,'s2let_allocate_lm(S2LET_COMPLEX(double) **flm, int L): s2let_alloc.h']]], + ['s2let_5fallocate_5flmn_5ff_5fwav_430',['s2let_allocate_lmn_f_wav',['../s2let__alloc_8c.html#a9dcb24db0b9cd7dd522bead7d61f7960',1,'s2let_allocate_lmn_f_wav(complex double **f_wav_lmn, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_alloc.c'],['../s2let__alloc_8h.html#a8c43cc27f8f2450ae6ec9bb6165dfd8b',1,'s2let_allocate_lmn_f_wav(S2LET_COMPLEX(double) **f_wav_lmn, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_alloc.h']]], + ['s2let_5fallocate_5fmw_431',['s2let_allocate_mw',['../s2let__alloc_8c.html#a83fad2b470cea9f29d8fe104616236dc',1,'s2let_allocate_mw(complex double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#ac042b364686fc53225102c71fc10f797',1,'s2let_allocate_mw(S2LET_COMPLEX(double) **f, int L): s2let_alloc.h']]], + ['s2let_5fallocate_5fmw_5freal_432',['s2let_allocate_mw_real',['../s2let__alloc_8c.html#a22e7d6f3fdc037d975eaad03ef0ece23',1,'s2let_allocate_mw_real(double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#a22e7d6f3fdc037d975eaad03ef0ece23',1,'s2let_allocate_mw_real(double **f, int L): s2let_alloc.c']]], + ['s2let_5fallocate_5fmwss_433',['s2let_allocate_mwss',['../s2let__alloc_8c.html#a4569d2d2e8251c4e65494b1518ebe72e',1,'s2let_allocate_mwss(complex double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#ab914515792a062cc87662d8a6b028b7b',1,'s2let_allocate_mwss(S2LET_COMPLEX(double) **f, int L): s2let_alloc.h']]], + ['s2let_5fallocate_5fmwss_5freal_434',['s2let_allocate_mwss_real',['../s2let__alloc_8c.html#a562dc748f45b20b9791bbca68045c472',1,'s2let_allocate_mwss_real(double **f, int L): s2let_alloc.c'],['../s2let__alloc_8h.html#a562dc748f45b20b9791bbca68045c472',1,'s2let_allocate_mwss_real(double **f, int L): s2let_alloc.c']]], + ['s2let_5fanalysis_5fadjoint_5flmn2lm_435',['s2let_analysis_adjoint_lmn2lm',['../s2let__analysis__adjoint_8c.html#a72146aacc61a608c02b22299d6c61e98',1,'s2let_analysis_adjoint_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a529cb2b3e504faf4cda24b4c6d99d333',1,'s2let_analysis_adjoint_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5flmn2lm_5freal_436',['s2let_analysis_adjoint_lmn2lm_real',['../s2let__analysis__adjoint_8c.html#abee7a1a11683f976937f6ab167a4a2ed',1,'s2let_analysis_adjoint_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a2c83c6835e02811a5d264613391b789e',1,'s2let_analysis_adjoint_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2lm_437',['s2let_analysis_adjoint_wav2lm',['../s2let__analysis__adjoint_8c.html#acbf24f007aab1439f827cafe351db721',1,'s2let_analysis_adjoint_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a6c6a34d9203703ddf27f323109f9dde6',1,'s2let_analysis_adjoint_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2lm_5fmanual_438',['s2let_analysis_adjoint_wav2lm_manual',['../s2let__analysis__adjoint_8c.html#a29d0f211cfd72f240cf53504d0ba12c3',1,'s2let_analysis_adjoint_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a181593f69b4cc0d9d26aa9379dc9bba2',1,'s2let_analysis_adjoint_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2lm_5freal_439',['s2let_analysis_adjoint_wav2lm_real',['../s2let__analysis__adjoint_8c.html#a055b05e4838ea75986215b775a124568',1,'s2let_analysis_adjoint_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a46105f73ba49339a7b5565db46ac3b28',1,'s2let_analysis_adjoint_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2px_440',['s2let_analysis_adjoint_wav2px',['../s2let__analysis__adjoint_8c.html#a4033dce73ff132c2d7f0a23b7b741d85',1,'s2let_analysis_adjoint_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#a8af02104042ed3c6ea7398889483cc45',1,'s2let_analysis_adjoint_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.h']]], + ['s2let_5fanalysis_5fadjoint_5fwav2px_5freal_441',['s2let_analysis_adjoint_wav2px_real',['../s2let__analysis__adjoint_8c.html#ad3c34c9c83b067fb9c350698fd66d5a6',1,'s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c'],['../s2let__analysis__adjoint_8h.html#ad3c34c9c83b067fb9c350698fd66d5a6',1,'s2let_analysis_adjoint_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_analysis_adjoint.c']]], + ['s2let_5fanalysis_5flm2lmn_442',['s2let_analysis_lm2lmn',['../s2let__analysis_8c.html#a9781ec2d11788c9aa5a13bbca0e6ba9c',1,'s2let_analysis_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a1ff7c08702b71c00f79668abbc950d30',1,'s2let_analysis_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5flm2lmn_5freal_443',['s2let_analysis_lm2lmn_real',['../s2let__analysis_8c.html#a08075042a4adb01136d60414fd401a60',1,'s2let_analysis_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a0ae75e5749e9bb978f21d86b674c41b5',1,'s2let_analysis_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5flm2wav_444',['s2let_analysis_lm2wav',['../s2let__analysis_8c.html#ac5d95aed75e346bb48b9249bf80ace23',1,'s2let_analysis_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a2c035e3a62cab8dd9586d6fe75ab8268',1,'s2let_analysis_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5flm2wav_5fmanual_445',['s2let_analysis_lm2wav_manual',['../s2let__analysis_8c.html#a36f06dd57668341905eb038f85c309a2',1,'s2let_analysis_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis.c'],['../s2let__analysis_8h.html#a8af83cfbde6d80b9802c85553aed5828',1,'s2let_analysis_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_analysis.h']]], + ['s2let_5fanalysis_5flm2wav_5freal_446',['s2let_analysis_lm2wav_real',['../s2let__analysis_8c.html#a33928a9b09c9afe216dcf733ae7d1c5f',1,'s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a107abc090af40bf3d9ee37787e9d86c8',1,'s2let_analysis_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5fpx2wav_447',['s2let_analysis_px2wav',['../s2let__analysis_8c.html#a685f469be2016583d3fc15dae0e24c93',1,'s2let_analysis_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a1fc2440d51f5255a14fddd3cc6e25e61',1,'s2let_analysis_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_analysis.h']]], + ['s2let_5fanalysis_5fpx2wav_5freal_448',['s2let_analysis_px2wav_real',['../s2let__analysis_8c.html#a559ce533b1453fddd43b2046323d3abf',1,'s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_analysis.c'],['../s2let__analysis_8h.html#a559ce533b1453fddd43b2046323d3abf',1,'s2let_analysis_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_analysis.c']]], + ['s2let_5fbandlimit_449',['s2let_bandlimit',['../s2let__tiling_8c.html#ac022968b50a5a7a294fd6ae9d792119a',1,'s2let_bandlimit(int j, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ac022968b50a5a7a294fd6ae9d792119a',1,'s2let_bandlimit(int j, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5fbinomial_5fcoefficient_5ftest_450',['s2let_binomial_coefficient_test',['../s2let__test_8c.html#a468603fe2a4ae0176b1a3008b5508ac7',1,'s2let_test.c']]], + ['s2let_5fdot_5fproduct_5fcomplex_451',['s2let_dot_product_complex',['../s2let__test_8c.html#af85961da9316af3f997f88fedd2604d9',1,'s2let_test.c']]], + ['s2let_5fdot_5fproduct_5freal_452',['s2let_dot_product_real',['../s2let__test_8c.html#ab9098753dfdaad47814f9d13a5e838a1',1,'s2let_test.c']]], + ['s2let_5ffits_5fhpx_5fread_5fnside_453',['s2let_fits_hpx_read_nside',['../s2let__fits_8c.html#a332b4542fd283126c1bfd55c6f96d0e9',1,'s2let_fits_hpx_read_nside(char *filename): s2let_fits.c'],['../s2let__fits_8h.html#a332b4542fd283126c1bfd55c6f96d0e9',1,'s2let_fits_hpx_read_nside(char *filename): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fread_5fbandlimit_454',['s2let_fits_mw_read_bandlimit',['../s2let__fits_8c.html#a32b9baca740954e5dd89ff84a873bd5f',1,'s2let_fits_mw_read_bandlimit(char *filename): s2let_fits.c'],['../s2let__fits_8h.html#a32b9baca740954e5dd89ff84a873bd5f',1,'s2let_fits_mw_read_bandlimit(char *filename): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fread_5fmap_455',['s2let_fits_mw_read_map',['../s2let__fits_8c.html#af6db1f82ef3c0d037656ec6ac54e2d19',1,'s2let_fits_mw_read_map(double *f, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a8f3efe334a8689717e3c4af67bfcc182',1,'s2let_fits_mw_read_map(double *f, char *file, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fread_5fspin_5fmaps_456',['s2let_fits_mw_read_spin_maps',['../s2let__fits_8c.html#a76db1cab8202e48ed93378d68d5e1b0f',1,'s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a6452019812d547dc0de6888e76c9f2db',1,'s2let_fits_mw_read_spin_maps(double *fQ, double *fU, char *file, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fwrite_5fmap_457',['s2let_fits_mw_write_map',['../s2let__fits_8c.html#a33e069a17c3116f44eb667a9cba40615',1,'s2let_fits_mw_write_map(char *filename, double *f, int L): s2let_fits.c'],['../s2let__fits_8h.html#ae98dbd904653a070d64f31fa37bfa617',1,'s2let_fits_mw_write_map(char *file, double *f, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmw_5fwrite_5fspin_5fmaps_458',['s2let_fits_mw_write_spin_maps',['../s2let__fits_8c.html#a5c22448360290d72a157eb886a3bb23e',1,'s2let_fits_mw_write_spin_maps(char *filename, double *fQ, double *fU, int L): s2let_fits.c'],['../s2let__fits_8h.html#afe7d32ae54ded848bd7a7cb25d4dba93',1,'s2let_fits_mw_write_spin_maps(char *file, double *fQ, double *fU, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmwss_5fread_5fmap_459',['s2let_fits_mwss_read_map',['../s2let__fits_8c.html#a30d6c0469210655e662bbdf8153d3e3f',1,'s2let_fits_mwss_read_map(double *f, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#ad022bd34785d0cc2d5a2b1f924ba26fd',1,'s2let_fits_mwss_read_map(double *f, char *file, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmwss_5fread_5fspin_5fmaps_460',['s2let_fits_mwss_read_spin_maps',['../s2let__fits_8c.html#abf0138418d23fff52dea5dabb8e2a7fa',1,'s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *filename, int L): s2let_fits.c'],['../s2let__fits_8h.html#a85a1bcdf0dee2673f2d5ffd374f2bdfd',1,'s2let_fits_mwss_read_spin_maps(double *fQ, double *fU, char *file, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmwss_5fwrite_5fmap_461',['s2let_fits_mwss_write_map',['../s2let__fits_8c.html#a7b7613e2e45ffa5e2ff4ef51c88039f7',1,'s2let_fits_mwss_write_map(char *filename, double *f, int L): s2let_fits.c'],['../s2let__fits_8h.html#a22e885366d6e8367fd5afe62679ff42f',1,'s2let_fits_mwss_write_map(char *file, double *f, int L): s2let_fits.c']]], + ['s2let_5ffits_5fmwss_5fwrite_5fspin_5fmaps_462',['s2let_fits_mwss_write_spin_maps',['../s2let__fits_8c.html#ac0aa9a648728c543e0a15490e639b7e7',1,'s2let_fits_mwss_write_spin_maps(char *filename, double *fQ, double *fU, int L): s2let_fits.c'],['../s2let__fits_8h.html#abb0ad8df2666842d52b8b6b724d2688f',1,'s2let_fits_mwss_write_spin_maps(char *file, double *fQ, double *fU, int L): s2let_fits.c']]], + ['s2let_5fhpx_5fallocate_5freal_463',['s2let_hpx_allocate_real',['../s2let__hpx_8c.html#a5fd3f8d1975ab0798c4797665256083a',1,'s2let_hpx_allocate_real(double **f, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a5fd3f8d1975ab0798c4797665256083a',1,'s2let_hpx_allocate_real(double **f, int nside): s2let_hpx.c']]], + ['s2let_5fhpx_5falm2map_5freal_464',['s2let_hpx_alm2map_real',['../s2let__hpx_8c.html#a3a16f082dbd93ca1413282167eb70b78',1,'s2let_hpx_alm2map_real(double *f, const complex double *flm, int nside, int L): s2let_hpx.c'],['../s2let__hpx_8h.html#adfeed42820bd0d0c686c83b87c091050',1,'s2let_hpx_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int nside, int L): s2let_hpx.h']]], + ['s2let_5fhpx_5falm2map_5fspin_5freal_465',['s2let_hpx_alm2map_spin_real',['../s2let__hpx_8c.html#a628694892c6f91d3e04fef9fccf145d9',1,'s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const complex double *flmE, const complex double *flmB, int nside, int L, int spin): s2let_hpx.c'],['../s2let__hpx_8h.html#aeeb308d10fad6609143c7b88add754c1',1,'s2let_hpx_alm2map_spin_real(double *fQ, double *fU, const S2LET_COMPLEX(double) *flmE, const S2LET_COMPLEX(double) *flmB, int nside, int L, int spin): s2let_hpx.h']]], + ['s2let_5fhpx_5fio_5ftest_466',['s2let_hpx_io_test',['../s2let__hpx__test_8c.html#a38519222c90d787d322f0163273466c6',1,'s2let_hpx_test.c']]], + ['s2let_5fhpx_5fmap2alm_5freal_467',['s2let_hpx_map2alm_real',['../s2let__hpx_8c.html#a78d966279d936b4937553e58b88265f3',1,'s2let_hpx_map2alm_real(complex double *flm, const double *f, int nside, int L): s2let_hpx.c'],['../s2let__hpx_8h.html#addf44689d1620ff08e9e623064a3da0f',1,'s2let_hpx_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int nside, int L): s2let_hpx.h']]], + ['s2let_5fhpx_5fmap2alm_5fspin_5freal_468',['s2let_hpx_map2alm_spin_real',['../s2let__hpx_8c.html#a9183b4967c1e5f8a6c973a1697362e91',1,'s2let_hpx_map2alm_spin_real(complex double *flmE, complex double *flmB, const double *fQ, const double *fU, int nside, int L, int spin): s2let_hpx.c'],['../s2let__hpx_8h.html#aa7a27c83a31e71f1fd90bdf0bbb84a8d',1,'s2let_hpx_map2alm_spin_real(S2LET_COMPLEX(double) *flmE, S2LET_COMPLEX(double) *flmB, const double *fQ, const double *fU, int nside, int L, int spin): s2let_hpx.h']]], + ['s2let_5fhpx_5fread_5fmap_469',['s2let_hpx_read_map',['../s2let__hpx_8c.html#a007bb3a6640667248187f9ac38b9d6a4',1,'s2let_hpx_read_map(double *f, char *file, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a007bb3a6640667248187f9ac38b9d6a4',1,'s2let_hpx_read_map(double *f, char *file, int nside): s2let_hpx.c']]], + ['s2let_5fhpx_5fread_5fmaps_470',['s2let_hpx_read_maps',['../s2let__hpx_8c.html#a5c51e9a1cbae07bee6dede794c93470c',1,'s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps): s2let_hpx.c'],['../s2let__hpx_8h.html#a5c51e9a1cbae07bee6dede794c93470c',1,'s2let_hpx_read_maps(double *f, char *file, int nside, int nmaps): s2let_hpx.c']]], + ['s2let_5fhpx_5fspinalm_5ftest_471',['s2let_hpx_spinalm_test',['../s2let__hpx__test_8c.html#a2d59903931d514b42dadfe993b697712',1,'s2let_hpx_test.c']]], + ['s2let_5fhpx_5fwrite_5fmap_472',['s2let_hpx_write_map',['../s2let__hpx_8c.html#a5f03d8745c5e15c0f03c2546464ec042',1,'s2let_hpx_write_map(char *file, const double *f, int nside): s2let_hpx.c'],['../s2let__hpx_8h.html#a5f03d8745c5e15c0f03c2546464ec042',1,'s2let_hpx_write_map(char *file, const double *f, int nside): s2let_hpx.c']]], + ['s2let_5fidl_5faxisym_5fhpx_5fwav_5fanalysis_5freal_473',['s2let_idl_axisym_hpx_wav_analysis_real',['../s2let__idl__hpx_8c.html#a8d5e1acca474c541532a3c249a2f3814',1,'s2let_idl_hpx.c']]], + ['s2let_5fidl_5faxisym_5fhpx_5fwav_5fsynthesis_5freal_474',['s2let_idl_axisym_hpx_wav_synthesis_real',['../s2let__idl__hpx_8c.html#a8bbb1aa9b6b3987cd55b6f6d2ac212f5',1,'s2let_idl_hpx.c']]], + ['s2let_5fidl_5fhpx_5falm2map_5freal_475',['s2let_idl_hpx_alm2map_real',['../s2let__idl__hpx_8c.html#a2405269f6a3905d347497fdd8f8737b2',1,'s2let_idl_hpx_alm2map_real(int argc, void *argv[]): s2let_idl_hpx.c'],['../s2let__idl__hpx_8h.html#a2405269f6a3905d347497fdd8f8737b2',1,'s2let_idl_hpx_alm2map_real(int argc, void *argv[]): s2let_idl_hpx.c']]], + ['s2let_5fidl_5fhpx_5faxisym_5fwav_5fanalysis_5freal_476',['s2let_idl_hpx_axisym_wav_analysis_real',['../s2let__idl__hpx_8h.html#af0b753f2c0d41972ff727e18bbf51490',1,'s2let_idl_hpx.h']]], + ['s2let_5fidl_5fhpx_5faxisym_5fwav_5fsynthesis_5freal_477',['s2let_idl_hpx_axisym_wav_synthesis_real',['../s2let__idl__hpx_8h.html#a780c8d58d24780b54367b2751d456d21',1,'s2let_idl_hpx.h']]], + ['s2let_5fidl_5fhpx_5fmap2alm_5freal_478',['s2let_idl_hpx_map2alm_real',['../s2let__idl__hpx_8c.html#ad34b479c1681a81cc1c707def15d296c',1,'s2let_idl_hpx_map2alm_real(int argc, void *argv[]): s2let_idl_hpx.c'],['../s2let__idl__hpx_8h.html#ad34b479c1681a81cc1c707def15d296c',1,'s2let_idl_hpx_map2alm_real(int argc, void *argv[]): s2let_idl_hpx.c']]], + ['s2let_5fidl_5fmw_5falm2map_479',['s2let_idl_mw_alm2map',['../s2let__idl__mw_8c.html#a4c2ef5574faf8b82ca91295b1321b5e8',1,'s2let_idl_mw.c']]], + ['s2let_5fidl_5fmw_5falm2map_5freal_480',['s2let_idl_mw_alm2map_real',['../s2let__idl__mw_8c.html#af7a317220109dabfc86d0dd5c4b8987c',1,'s2let_idl_mw.c']]], + ['s2let_5fidl_5fmw_5fmap2alm_481',['s2let_idl_mw_map2alm',['../s2let__idl__mw_8c.html#a2e12cdca9f43efd97ab6a93da615599c',1,'s2let_idl_mw.c']]], + ['s2let_5fidl_5fmw_5fmap2alm_5freal_482',['s2let_idl_mw_map2alm_real',['../s2let__idl__mw_8c.html#ac5974e9a553e5ca74bcf2cedf0faa970',1,'s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5falm2map_483',['s2let_idl_transform_alm2map',['../s2let__idl__mw_8h.html#aee50e78b2a8b7521629d086621d23c60',1,'s2let_idl_mw.h']]], + ['s2let_5fidl_5ftransform_5falm2map_5freal_484',['s2let_idl_transform_alm2map_real',['../s2let__idl__mw_8h.html#aceb297101069e992a356fadfc43820d0',1,'s2let_idl_mw.h']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_485',['s2let_idl_transform_axisym_wav_analysis_mw',['../s2let__idl__mw_8c.html#a7fcf1a787d1d465620d3287703e5ce6c',1,'s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a7fcf1a787d1d465620d3287703e5ce6c',1,'s2let_idl_transform_axisym_wav_analysis_mw(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_486',['s2let_idl_transform_axisym_wav_analysis_mw_multires',['../s2let__idl__mw_8c.html#a97466a06e494b38c4d60a7f6839a41e3',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a97466a06e494b38c4d60a7f6839a41e3',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_5freal_487',['s2let_idl_transform_axisym_wav_analysis_mw_multires_real',['../s2let__idl__mw_8c.html#ad1712f32e26d77c9b21b7f3bd62f4609',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad1712f32e26d77c9b21b7f3bd62f4609',1,'s2let_idl_transform_axisym_wav_analysis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5freal_488',['s2let_idl_transform_axisym_wav_analysis_mw_real',['../s2let__idl__mw_8c.html#a168466d81a6d248d0b4280a9687d8172',1,'s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a168466d81a6d248d0b4280a9687d8172',1,'s2let_idl_transform_axisym_wav_analysis_mw_real(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_489',['s2let_idl_transform_axisym_wav_synthesis_mw',['../s2let__idl__mw_8c.html#ad3bd4d2483d2716820eb6b0d107cd75b',1,'s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad3bd4d2483d2716820eb6b0d107cd75b',1,'s2let_idl_transform_axisym_wav_synthesis_mw(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_490',['s2let_idl_transform_axisym_wav_synthesis_mw_multires',['../s2let__idl__mw_8c.html#abb8950501cac08ff378bc0dbf172eb73',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#abb8950501cac08ff378bc0dbf172eb73',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_5freal_491',['s2let_idl_transform_axisym_wav_synthesis_mw_multires_real',['../s2let__idl__mw_8c.html#ad0f7dd4ae05137d49d8e35e4e2dd827e',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#ad0f7dd4ae05137d49d8e35e4e2dd827e',1,'s2let_idl_transform_axisym_wav_synthesis_mw_multires_real(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5freal_492',['s2let_idl_transform_axisym_wav_synthesis_mw_real',['../s2let__idl__mw_8c.html#a61efa315fb01f338ed265b7898c91caa',1,'s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[]): s2let_idl_mw.c'],['../s2let__idl__mw_8h.html#a61efa315fb01f338ed265b7898c91caa',1,'s2let_idl_transform_axisym_wav_synthesis_mw_real(int argc, void *argv[]): s2let_idl_mw.c']]], + ['s2let_5fidl_5ftransform_5fmap2alm_493',['s2let_idl_transform_map2alm',['../s2let__idl__mw_8h.html#a2653d09d0f6ab88cfb2803505da9fd6b',1,'s2let_idl_mw.h']]], + ['s2let_5fidl_5ftransform_5fmap2alm_5freal_494',['s2let_idl_transform_map2alm_real',['../s2let__idl__mw_8h.html#a8e509c9e23c2225aafdc6e77c6b73c58',1,'s2let_idl_mw.h']]], + ['s2let_5fj_5fmax_495',['s2let_j_max',['../s2let__tiling_8c.html#af8e45477d8b8a0bbd2f0dd706ee29f7e',1,'s2let_j_max(const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#af8e45477d8b8a0bbd2f0dd706ee29f7e',1,'s2let_j_max(const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5fl0_496',['s2let_L0',['../s2let__tiling_8c.html#a970c83288da0b2f1b0c783dc32da5d58',1,'s2let_L0(int j, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a970c83288da0b2f1b0c783dc32da5d58',1,'s2let_L0(int j, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5flm_5fpower_497',['s2let_lm_power',['../s2let__lm_8c.html#a520c6e822fd2d004f87b0babf793b93b',1,'s2let_lm_power(complex double *flm, int L): s2let_lm.c'],['../s2let__lm_8h.html#ace994f794328a0338095553fd7e81c2e',1,'s2let_lm_power(S2LET_COMPLEX(double) *flm, int L): s2let_lm.h']]], + ['s2let_5flm_5frandom_5fflm_498',['s2let_lm_random_flm',['../s2let__lm_8c.html#aecdba2ebff470192c677d787331440da',1,'s2let_lm_random_flm(complex double *flm, int L, int spin, int seed): s2let_lm.c'],['../s2let__lm_8h.html#aa1cf89a60a2c297ed93525c7abd36d82',1,'s2let_lm_random_flm(S2LET_COMPLEX(double) *flm, int L, int spin, int seed): s2let_lm.h']]], + ['s2let_5flm_5frandom_5fflm_5freal_499',['s2let_lm_random_flm_real',['../s2let__lm_8c.html#a976ccda30f8c30bfbcd238242deef100',1,'s2let_lm_random_flm_real(complex double *flm, int L, int seed): s2let_lm.c'],['../s2let__lm_8h.html#a52b1d6d06e4ac3b5d386b6a9a9f5d9d1',1,'s2let_lm_random_flm_real(S2LET_COMPLEX(double) *flm, int L, int seed): s2let_lm.h']]], + ['s2let_5flm_5frandom_5fflm_5freal_5fsigma_500',['s2let_lm_random_flm_real_sigma',['../s2let__axisym__denoising__demo_8c.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8c.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_denoising_demo.c'],['../s2let__axisym__denoising__demo_8h.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c'],['../s2let__denoising__demo_8h.html#aecd22408c13042607d49019671ff9168',1,'s2let_lm_random_flm_real_sigma(complex double *flm, int L, int seed, double sigmanoise): s2let_axisym_denoising_demo.c']]], + ['s2let_5flm_5frandom_5fflm_5fsigma_501',['s2let_lm_random_flm_sigma',['../s2let__spin__denoising__demo_8c.html#a8f2d6d26977c37558bd348037fac075f',1,'s2let_spin_denoising_demo.c']]], + ['s2let_5fmath_5fkappa0_5fquadtrap_5fneedlet_502',['s2let_math_kappa0_quadtrap_needlet',['../s2let__math_8c.html#a1ee31db982694aeff4308288cb38e044',1,'s2let_math_kappa0_quadtrap_needlet(double a, double b, int n): s2let_math.c'],['../s2let__math_8h.html#a1ee31db982694aeff4308288cb38e044',1,'s2let_math_kappa0_quadtrap_needlet(double a, double b, int n): s2let_math.c']]], + ['s2let_5fmath_5fkappa0_5fquadtrap_5fs2dw_503',['s2let_math_kappa0_quadtrap_s2dw',['../s2let__math_8c.html#a44eb4f6042bf9dd406b3da22eca7e434',1,'s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B): s2let_math.c'],['../s2let__math_8h.html#a44eb4f6042bf9dd406b3da22eca7e434',1,'s2let_math_kappa0_quadtrap_s2dw(double a, double b, int n, double B): s2let_math.c']]], + ['s2let_5fmath_5fspline_5fscalingfct_504',['s2let_math_spline_scalingfct',['../s2let__math_8c.html#a5a6d036165ebcd79b2c4f5716a42bcd8',1,'s2let_math_spline_scalingfct(double x, double y): s2let_math.c'],['../s2let__math_8h.html#a5a6d036165ebcd79b2c4f5716a42bcd8',1,'s2let_math_spline_scalingfct(double x, double y): s2let_math.c']]], + ['s2let_5fmw_5falm2map_505',['s2let_mw_alm2map',['../s2let__mw_8c.html#a71a1d94b45021758562acb54f7efbadc',1,'s2let_mw_alm2map(complex double *f, const complex double *flm, int L, int spin): s2let_mw.c'],['../s2let__mw_8h.html#adbfa150db5b9bcca2993df5e14cb05b9',1,'s2let_mw_alm2map(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *flm, int L, int spin): s2let_mw.h']]], + ['s2let_5fmw_5falm2map_5freal_506',['s2let_mw_alm2map_real',['../s2let__mw_8c.html#acec65039b721a60d622aa6ccdc57fe58',1,'s2let_mw_alm2map_real(double *f, const complex double *flm, int L): s2let_mw.c'],['../s2let__mw_8h.html#a845b320975dc03e952f28c539da9d426',1,'s2let_mw_alm2map_real(double *f, const S2LET_COMPLEX(double) *flm, int L): s2let_mw.h']]], + ['s2let_5fmw_5fio_5fspin_5ftest_507',['s2let_mw_io_spin_test',['../s2let__hpx__test_8c.html#a2cb09cab436803d8581b6b96959dff9e',1,'s2let_hpx_test.c']]], + ['s2let_5fmw_5fio_5ftest_508',['s2let_mw_io_test',['../s2let__hpx__test_8c.html#af91cc34a400e0f94e570728ac6f6c759',1,'s2let_hpx_test.c']]], + ['s2let_5fmw_5fmap2alm_509',['s2let_mw_map2alm',['../s2let__mw_8c.html#ae2d95be7cf71bfe84060dbdd77c6947b',1,'s2let_mw_map2alm(complex double *flm, const complex double *f, int L, int spin): s2let_mw.c'],['../s2let__mw_8h.html#a727851e328422320a31ef6548631e0dd',1,'s2let_mw_map2alm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f, int L, int spin): s2let_mw.h']]], + ['s2let_5fmw_5fmap2alm_5freal_510',['s2let_mw_map2alm_real',['../s2let__mw_8c.html#adee030c15f2b401361c278a6c6ea6f7c',1,'s2let_mw_map2alm_real(complex double *flm, const double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#a297725ba5e35713e59c0b601a6964942',1,'s2let_mw_map2alm_real(S2LET_COMPLEX(double) *flm, const double *f, int L): s2let_mw.h']]], + ['s2let_5fmw_5fpower_511',['s2let_mw_power',['../s2let__mw_8c.html#a91dbb4ab1556928322986d21d413abdf',1,'s2let_mw_power(complex double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#aceb97384257965caeb908162dae89009',1,'s2let_mw_power(S2LET_COMPLEX(double) *flm, int L): s2let_mw.h']]], + ['s2let_5fmw_5fpower_5freal_512',['s2let_mw_power_real',['../s2let__mw_8c.html#a3520764bba2023b957373df5769f25e8',1,'s2let_mw_power_real(double *f, int L): s2let_mw.c'],['../s2let__mw_8h.html#aa3c531ec00960d928d8d7fca2f6a3108',1,'s2let_mw_power_real(double *flm, int L): s2let_mw.c']]], + ['s2let_5fn_5fgamma_513',['s2let_n_gamma',['../s2let__helper_8c.html#a33cd356d3eca688b51e0a70cc216b3c6',1,'s2let_n_gamma(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a33cd356d3eca688b51e0a70cc216b3c6',1,'s2let_n_gamma(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5flm_514',['s2let_n_lm',['../s2let__helper_8c.html#a31cd45045fa530a8b67db235da15d29f',1,'s2let_n_lm(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a31cd45045fa530a8b67db235da15d29f',1,'s2let_n_lm(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5flm_5fscal_515',['s2let_n_lm_scal',['../s2let__helper_8c.html#aaf6daa1bc9b68e76a247860c57a9e8b9',1,'s2let_n_lm_scal(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aaf6daa1bc9b68e76a247860c57a9e8b9',1,'s2let_n_lm_scal(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5flmn_5fwav_516',['s2let_n_lmn_wav',['../s2let__helper_8c.html#a8db8dd8265358a8501a40fe77c4ab908',1,'s2let_n_lmn_wav(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a8db8dd8265358a8501a40fe77c4ab908',1,'s2let_n_lmn_wav(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fphi_517',['s2let_n_phi',['../s2let__helper_8c.html#aca44ba24618888aa56773d0fa662bb87',1,'s2let_n_phi(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aca44ba24618888aa56773d0fa662bb87',1,'s2let_n_phi(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fpx_518',['s2let_n_px',['../s2let__helper_8c.html#a8de2596044e8dbd481d0d86e1ad8bd44',1,'s2let_n_px(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a8de2596044e8dbd481d0d86e1ad8bd44',1,'s2let_n_px(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fscal_519',['s2let_n_scal',['../s2let__helper_8c.html#a94202177168781d62964cfb09b568d77',1,'s2let_n_scal(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a94202177168781d62964cfb09b568d77',1,'s2let_n_scal(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5ftheta_520',['s2let_n_theta',['../s2let__helper_8c.html#a93ae2fb9184ae2bb35200063113b3db8',1,'s2let_n_theta(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a93ae2fb9184ae2bb35200063113b3db8',1,'s2let_n_theta(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fwav_521',['s2let_n_wav',['../s2let__helper_8c.html#aa267d575405f5aec34f642d7278ea15c',1,'s2let_n_wav(const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#aa267d575405f5aec34f642d7278ea15c',1,'s2let_n_wav(const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fn_5fwav_5fj_522',['s2let_n_wav_j',['../s2let__helper_8c.html#a5489f45f63977ad580729370eeabd3c8',1,'s2let_n_wav_j(int j, const s2let_parameters_t *parameters): s2let_helper.c'],['../s2let__helper_8h.html#a5489f45f63977ad580729370eeabd3c8',1,'s2let_n_wav_j(int j, const s2let_parameters_t *parameters): s2let_helper.c']]], + ['s2let_5fswitch_5fwavtype_523',['s2let_switch_wavtype',['../s2let__tiling_8c.html#a740dd43f4aeae426b96bd4488881297c',1,'s2let_switch_wavtype(int typenum): s2let_tiling.c'],['../s2let__tiling_8h.html#a740dd43f4aeae426b96bd4488881297c',1,'s2let_switch_wavtype(int typenum): s2let_tiling.c']]], + ['s2let_5fsynthesis_5fadjoint_5flm2lmn_524',['s2let_synthesis_adjoint_lm2lmn',['../s2let__synthesis__adjoint_8c.html#aa22074c5b8f3c6f93101bda21dd41477',1,'s2let_synthesis_adjoint_lm2lmn(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#ab2e27bf29fd328e5737010a8e965a392',1,'s2let_synthesis_adjoint_lm2lmn(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5flm2lmn_5freal_525',['s2let_synthesis_adjoint_lm2lmn_real',['../s2let__synthesis__adjoint_8c.html#a3b3ba86b4c6ccbea501743a31f0fbaba',1,'s2let_synthesis_adjoint_lm2lmn_real(complex double *f_wav_lmn, complex double *f_scal_lm, const complex double *flm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a8f619d5750ea69d11f5a8a72e7789c5c',1,'s2let_synthesis_adjoint_lm2lmn_real(S2LET_COMPLEX(double) *f_wav_lmn, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5flm2wav_526',['s2let_synthesis_adjoint_lm2wav',['../s2let__synthesis__adjoint_8c.html#a0ded78fd254dfcf523607af9d6384b04',1,'s2let_synthesis_adjoint_lm2wav(complex double *f_wav, complex double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a076501801b028f2c5a43b703afc55746',1,'s2let_synthesis_adjoint_lm2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5flm2wav_5fmanual_527',['s2let_synthesis_adjoint_lm2wav_manual',['../s2let__synthesis__adjoint_8c.html#af1ad88c078072d2c2f9262ab60664627',1,'s2let_synthesis_adjoint_lm2wav_manual(complex double *f_wav, complex double *f_scal, const complex double *flm, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a80993ff9162a6694085cad936b366c66',1,'s2let_synthesis_adjoint_lm2wav_manual(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *flm, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5flm2wav_5freal_528',['s2let_synthesis_adjoint_lm2wav_real',['../s2let__synthesis__adjoint_8c.html#a3d89c7c0fd47c34293d0c915e8680212',1,'s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const complex double *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a3ca845d22e3f872b584ba8078eebdf2c',1,'s2let_synthesis_adjoint_lm2wav_real(double *f_wav, double *f_scal, const S2LET_COMPLEX(double) *flm, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5fpx2wav_529',['s2let_synthesis_adjoint_px2wav',['../s2let__synthesis__adjoint_8c.html#af92b8ee7a5d7467aca1aadf574101ed1',1,'s2let_synthesis_adjoint_px2wav(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#acb574fe4af36dac2771e323b23f038f5',1,'s2let_synthesis_adjoint_px2wav(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.h']]], + ['s2let_5fsynthesis_5fadjoint_5fpx2wav_5freal_530',['s2let_synthesis_adjoint_px2wav_real',['../s2let__synthesis__adjoint_8c.html#a8ac56364e5e11e70afdc89dcbdfa5e54',1,'s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c'],['../s2let__synthesis__adjoint_8h.html#a8ac56364e5e11e70afdc89dcbdfa5e54',1,'s2let_synthesis_adjoint_px2wav_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_synthesis_adjoint.c']]], + ['s2let_5fsynthesis_5flmn2lm_531',['s2let_synthesis_lmn2lm',['../s2let__synthesis_8c.html#aeab2e51756b722c7fcb0246fa7bcf4e8',1,'s2let_synthesis_lmn2lm(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a07acb11aa82e55efc3af49548de2c595',1,'s2let_synthesis_lmn2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5flmn2lm_5freal_532',['s2let_synthesis_lmn2lm_real',['../s2let__synthesis_8c.html#ae985651ea8c8225166983b660e15648e',1,'s2let_synthesis_lmn2lm_real(complex double *flm, const complex double *f_wav_lmn, const complex double *f_scal_lm, const complex double *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#adfeebcfa8d5032b78dd85634a5c32b1e',1,'s2let_synthesis_lmn2lm_real(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lmn, const S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *wav_lm, const double *scal_l, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2lm_533',['s2let_synthesis_wav2lm',['../s2let__synthesis_8c.html#ad898b41a0d83f31033c87f43339dccc2',1,'s2let_synthesis_wav2lm(complex double *flm, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a69a72f4cf574108a313f7320b093beee',1,'s2let_synthesis_wav2lm(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2lm_5fmanual_534',['s2let_synthesis_wav2lm_manual',['../s2let__synthesis_8c.html#ae32a0ec051091cb18844e51d8d0ad7fd',1,'s2let_synthesis_wav2lm_manual(complex double *flm, const complex double *f_wav, const complex double *f_scal, const double *scal_l, const complex double *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis.c'],['../s2let__synthesis_8h.html#ad3cd8f875820fc345277f57957f6ad40',1,'s2let_synthesis_wav2lm_manual(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const double *scal_l, const S2LET_COMPLEX(double) *wav_lm, const int scal_bandlimit, const int *wav_bandlimits, int J, int L, int spin, int N): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2lm_5freal_535',['s2let_synthesis_wav2lm_real',['../s2let__synthesis_8c.html#ab4592958d2f658ac6711edb3589a0d04',1,'s2let_synthesis_wav2lm_real(complex double *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a21c5e68bb92ff9cb6d50a2fd19213a2e',1,'s2let_synthesis_wav2lm_real(S2LET_COMPLEX(double) *flm, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2px_536',['s2let_synthesis_wav2px',['../s2let__synthesis_8c.html#a171869de60c6dba907994e24eb1ad568',1,'s2let_synthesis_wav2px(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#aa051be81ee272ce0291f78b66170c5db',1,'s2let_synthesis_wav2px(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.h']]], + ['s2let_5fsynthesis_5fwav2px_5freal_537',['s2let_synthesis_wav2px_real',['../s2let__synthesis_8c.html#a4ef1adffb439379ca652533588879ab5',1,'s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c'],['../s2let__synthesis_8h.html#a4ef1adffb439379ca652533588879ab5',1,'s2let_synthesis_wav2px_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_synthesis.c']]], + ['s2let_5ftiling_5faxisym_538',['s2let_tiling_axisym',['../s2let__tiling_8c.html#a2dcc3541cd5003f7c20189b5f1e569b0',1,'s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a2dcc3541cd5003f7c20189b5f1e569b0',1,'s2let_tiling_axisym(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5ftiling_5faxisym_5fallocate_539',['s2let_tiling_axisym_allocate',['../s2let__tiling_8c.html#acfff04a4e1d0f2c422b2c0a22a01c9a9',1,'s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#acfff04a4e1d0f2c422b2c0a22a01c9a9',1,'s2let_tiling_axisym_allocate(double **kappa, double **kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5ftiling_5faxisym_5fcheck_5fidentity_540',['s2let_tiling_axisym_check_identity',['../s2let__tiling_8c.html#a895b0a2aed140ef5591af7ac630d6113',1,'s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a895b0a2aed140ef5591af7ac630d6113',1,'s2let_tiling_axisym_check_identity(double *kappa, double *kappa0, const s2let_parameters_t *parameters): s2let_tiling.c']]], + ['s2let_5ftiling_5faxisym_5ftest_541',['s2let_tiling_axisym_test',['../s2let__test_8c.html#a72ed78cf85c9437d0a2545c8e3a61cf2',1,'s2let_test.c']]], + ['s2let_5ftiling_5fdirection_542',['s2let_tiling_direction',['../s2let__tiling_8c.html#a4811cf4eadbebb73245f54b676734b17',1,'s2let_tiling_direction(complex double *s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ae2b1be4ee6ee593ccc3673bb8c8119a0',1,'s2let_tiling_direction(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fdirection_5fallocate_543',['s2let_tiling_direction_allocate',['../s2let__tiling_8c.html#a10fa29a59b170d6ade97303878faf7ef',1,'s2let_tiling_direction_allocate(complex double **s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a14a6f342214def49e0a4007425a85885',1,'s2let_tiling_direction_allocate(S2LET_COMPLEX(double) **s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fdirection_5fcheck_5fidentity_544',['s2let_tiling_direction_check_identity',['../s2let__tiling_8c.html#ab69e82a484169f248873ae9ccb5bb89a',1,'s2let_tiling_direction_check_identity(complex double *s_elm, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a57fea5748d955b5caa9ddf46cda3036b',1,'s2let_tiling_direction_check_identity(S2LET_COMPLEX(double) *s_elm, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fdirection_5ftest_545',['s2let_tiling_direction_test',['../s2let__test_8c.html#a84ab4ae94142563376cc58ce9b3f0529',1,'s2let_test.c']]], + ['s2let_5ftiling_5fphi2_5fneedlet_546',['s2let_tiling_phi2_needlet',['../s2let__tiling_8c.html#aa9f045a72ccf0df8bff4a8a245ecc52a',1,'s2let_tiling.c']]], + ['s2let_5ftiling_5fphi2_5fs2dw_547',['s2let_tiling_phi2_s2dw',['../s2let__tiling_8c.html#a255c8db4bb8f33e546d44e2b96fd4eb5',1,'s2let_tiling.c']]], + ['s2let_5ftiling_5fphi2_5fspline_548',['s2let_tiling_phi2_spline',['../s2let__tiling_8c.html#afd4de938c00ee3cbde3e6e10944a496b',1,'s2let_tiling.c']]], + ['s2let_5ftiling_5fwavelet_549',['s2let_tiling_wavelet',['../s2let__tiling_8c.html#a9878fae074371b64e7de24ebfdbd752c',1,'s2let_tiling_wavelet(complex double *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#ae0e09c45e6d87dee84f94bb04b6215d8',1,'s2let_tiling_wavelet(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fwavelet_5fallocate_550',['s2let_tiling_wavelet_allocate',['../s2let__tiling_8c.html#af1770bfbe7ff5ead2769089867a03fbb',1,'s2let_tiling_wavelet_allocate(complex double **psi, double **phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#af5491812d40095dfbab3c08edf4d9fa5',1,'s2let_tiling_wavelet_allocate(S2LET_COMPLEX(double) **psi, double **phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fwavelet_5fcheck_5fidentity_551',['s2let_tiling_wavelet_check_identity',['../s2let__tiling_8c.html#abd52d0b819985f55fe6fca8259597b48',1,'s2let_tiling_wavelet_check_identity(complex double *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.c'],['../s2let__tiling_8h.html#a9a4117a039022f6fff78939c4e0f3a86',1,'s2let_tiling_wavelet_check_identity(S2LET_COMPLEX(double) *psi, double *phi, const s2let_parameters_t *parameters): s2let_tiling.h']]], + ['s2let_5ftiling_5fwavelet_5ftest_552',['s2let_tiling_wavelet_test',['../s2let__test_8c.html#ad612b1930b2a90f6bb8b507f6dc2ae4d',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fhpx_5ff_5fwav_5freal_553',['s2let_transform_axisym_allocate_hpx_f_wav_real',['../s2let__transform__axisym__hpx_8c.html#a8d0f962069938cdf19c4ad1cce2862f8',1,'s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#a8d0f962069938cdf19c4ad1cce2862f8',1,'s2let_transform_axisym_allocate_hpx_f_wav_real(double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_554',['s2let_transform_axisym_allocate_mw_f_wav',['../s2let__transform__axisym__mw_8c.html#abdb0070e4e2f67007c6755020cbf3f76',1,'s2let_transform_axisym_allocate_mw_f_wav(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aa0ce4a50c9b076757a1360030dc00c9e',1,'s2let_transform_axisym_allocate_mw_f_wav(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5fmultires_555',['s2let_transform_axisym_allocate_mw_f_wav_multires',['../s2let__transform__axisym__mw_8c.html#a34f35be55f0d7920e66ffa96948b7132',1,'s2let_transform_axisym_allocate_mw_f_wav_multires(complex double **f_wav, complex double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a0c9e93d33296d57f7722d91288606268',1,'s2let_transform_axisym_allocate_mw_f_wav_multires(S2LET_COMPLEX(double) **f_wav, S2LET_COMPLEX(double) **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5fmultires_5freal_556',['s2let_transform_axisym_allocate_mw_f_wav_multires_real',['../s2let__transform__axisym__mw_8c.html#aaf2dc03fea7d12bf85c36ecb827c67f1',1,'s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aaf2dc03fea7d12bf85c36ecb827c67f1',1,'s2let_transform_axisym_allocate_mw_f_wav_multires_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fallocate_5fmw_5ff_5fwav_5freal_557',['s2let_transform_axisym_allocate_mw_f_wav_real',['../s2let__transform__axisym__mw_8c.html#a71d7ea7def45be0508e37eb4789a42be',1,'s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a71d7ea7def45be0508e37eb4789a42be',1,'s2let_transform_axisym_allocate_mw_f_wav_real(double **f_wav, double **f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fhpx_5ftest_558',['s2let_transform_axisym_hpx_test',['../s2let__hpx__test_8c.html#a967b49df6d8f162875b8fd691fc5673e',1,'s2let_hpx_test.c']]], + ['s2let_5ftransform_5faxisym_5fhpx_5fwav_5ftest_559',['s2let_transform_axisym_hpx_wav_test',['../s2let__hpx__test_8c.html#ae0c6235281f47c3580a082a8ff6442a0',1,'s2let_hpx_test.c']]], + ['s2let_5ftransform_5faxisym_5flm_5fallocate_5ff_5fwav_560',['s2let_transform_axisym_lm_allocate_f_wav',['../s2let__transform__axisym__lm_8c.html#a27717c57665b77ad3f6f5aef35c1c9e4',1,'s2let_transform_axisym_lm_allocate_f_wav(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a6ed8eae362ffc710e4f256f4a2c7a59c',1,'s2let_transform_axisym_lm_allocate_f_wav(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fallocate_5ff_5fwav_5fmultires_561',['s2let_transform_axisym_lm_allocate_f_wav_multires',['../s2let__transform__axisym__lm_8c.html#a53fc1d52b6e959e2d2a23319237c9087',1,'s2let_transform_axisym_lm_allocate_f_wav_multires(complex double **f_wav_lm, complex double **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a49deaad455c0f37f085794a95bc2cc8f',1,'s2let_transform_axisym_lm_allocate_f_wav_multires(S2LET_COMPLEX(double) **f_wav_lm, S2LET_COMPLEX(double) **f_scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fallocate_5fwav_562',['s2let_transform_axisym_lm_allocate_wav',['../s2let__transform__axisym__lm_8c.html#ae5c57282bb1116eababa279c2f8757a9',1,'s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#ae5c57282bb1116eababa279c2f8757a9',1,'s2let_transform_axisym_lm_allocate_wav(double **wav_lm, double **scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_563',['s2let_transform_axisym_lm_wav',['../s2let__transform__axisym__lm_8c.html#a2efd3fe3938b0f6cb3166804f0ca62bc',1,'s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a2efd3fe3938b0f6cb3166804f0ca62bc',1,'s2let_transform_axisym_lm_wav(double *wav_lm, double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fanalysis_564',['s2let_transform_axisym_lm_wav_analysis',['../s2let__transform__axisym__lm_8c.html#a1363fa22f22fe3faf9601fc4d8dc2185',1,'s2let_transform_axisym_lm_wav_analysis(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#ac7bd36f0e12ae8e06d7f1e8c4c0c1f9e',1,'s2let_transform_axisym_lm_wav_analysis(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fanalysis_5fmultires_565',['s2let_transform_axisym_lm_wav_analysis_multires',['../s2let__transform__axisym__lm_8c.html#ac55ab672138aa0703ba3b3d24a6673c0',1,'s2let_transform_axisym_lm_wav_analysis_multires(complex double *f_wav_lm, complex double *f_scal_lm, const complex double *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a41cd8c62327019175b700208d2891464',1,'s2let_transform_axisym_lm_wav_analysis_multires(S2LET_COMPLEX(double) *f_wav_lm, S2LET_COMPLEX(double) *f_scal_lm, const S2LET_COMPLEX(double) *flm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fmultires_5ftest_566',['s2let_transform_axisym_lm_wav_multires_test',['../s2let__test_8c.html#a6490580b66410b64846b31124ae5a0f4',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fsynthesis_567',['s2let_transform_axisym_lm_wav_synthesis',['../s2let__transform__axisym__lm_8c.html#a288f88b4dd18d732a0d6819c4d06e3f4',1,'s2let_transform_axisym_lm_wav_synthesis(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#acaad9856b9ff5ea5588fff2a796a8ecf',1,'s2let_transform_axisym_lm_wav_synthesis(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5fsynthesis_5fmultires_568',['s2let_transform_axisym_lm_wav_synthesis_multires',['../s2let__transform__axisym__lm_8c.html#ad31585dbae5edde3fc3704a59cbe1034',1,'s2let_transform_axisym_lm_wav_synthesis_multires(complex double *flm, const complex double *f_wav_lm, const complex double *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.c'],['../s2let__transform__axisym__lm_8h.html#a1cf1b759d1947fea4f100a80d8a420aa',1,'s2let_transform_axisym_lm_wav_synthesis_multires(S2LET_COMPLEX(double) *flm, const S2LET_COMPLEX(double) *f_wav_lm, const S2LET_COMPLEX(double) *f_scal_lm, const double *wav_lm, const double *scal_lm, const s2let_parameters_t *parameters): s2let_transform_axisym_lm.h']]], + ['s2let_5ftransform_5faxisym_5flm_5fwav_5ftest_569',['s2let_transform_axisym_lm_wav_test',['../s2let__test_8c.html#a21e0d56f5074c798cb77ee9ccf081e3c',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5fmultires_5ftest_570',['s2let_transform_axisym_vs_directional_mw_multires_test',['../s2let__test_8c.html#a4942f2f69c0519399f61579dc47d98d2',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5ftest_571',['s2let_transform_axisym_vs_directional_mw_test',['../s2let__test_8c.html#a45c632c898e73d473bcc38e492847182',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_572',['s2let_transform_axisym_wav_analysis_adjoint_mw',['../s2let__transform__axisym__mw_8c.html#a73b9085432c8673c6fde059b708dea46',1,'s2let_transform_axisym_wav_analysis_adjoint_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#afca147888501702b34ca4e1767c78710',1,'s2let_transform_axisym_wav_analysis_adjoint_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5fmultires_573',['s2let_transform_axisym_wav_analysis_adjoint_mw_multires',['../s2let__transform__axisym__mw_8c.html#abbbb0b8729b4b4d936723f57fa133bde',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a516ee27f27eb79de7c3214cab7271779',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5fmultires_5freal_574',['s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#ad16f124ef82ba5422107d53991578e2b',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ad16f124ef82ba5422107d53991578e2b',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fadjoint_5fmw_5freal_575',['s2let_transform_axisym_wav_analysis_adjoint_mw_real',['../s2let__transform__axisym__mw_8c.html#a9d190e3dc17c1e73036fa7def51baf44',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a9d190e3dc17c1e73036fa7def51baf44',1,'s2let_transform_axisym_wav_analysis_adjoint_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fhpx_5freal_576',['s2let_transform_axisym_wav_analysis_hpx_real',['../s2let__transform__axisym__hpx_8c.html#a3f69c1366658007590fc63877230d1a7',1,'s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#a3f69c1366658007590fc63877230d1a7',1,'s2let_transform_axisym_wav_analysis_hpx_real(double *f_wav, double *f_scal, const double *f, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_577',['s2let_transform_axisym_wav_analysis_mw',['../s2let__transform__axisym__mw_8c.html#a866080c7ca98673e75acaf8f384ea936',1,'s2let_transform_axisym_wav_analysis_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ac768b473723b5e525c959deb48e08825',1,'s2let_transform_axisym_wav_analysis_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_578',['s2let_transform_axisym_wav_analysis_mw_multires',['../s2let__transform__axisym__mw_8c.html#a272edc957f57772f4af7161c4776f118',1,'s2let_transform_axisym_wav_analysis_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#aec92f0a5f1bf3d14ed9dcdadd96153c3',1,'s2let_transform_axisym_wav_analysis_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5fmultires_5freal_579',['s2let_transform_axisym_wav_analysis_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#abbaca141c3699c766e341c5ceee14cdb',1,'s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abbaca141c3699c766e341c5ceee14cdb',1,'s2let_transform_axisym_wav_analysis_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fanalysis_5fmw_5freal_580',['s2let_transform_axisym_wav_analysis_mw_real',['../s2let__transform__axisym__mw_8c.html#abab7d46ecc4813503ab0fd5f09d8bfa7',1,'s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abab7d46ecc4813503ab0fd5f09d8bfa7',1,'s2let_transform_axisym_wav_analysis_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fhardthreshold_5fmultires_5freal_581',['s2let_transform_axisym_wav_hardthreshold_multires_real',['../s2let__transform__axisym__mw_8c.html#ab3b3272365c739034b2c5c8fc00613a9',1,'s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ab3b3272365c739034b2c5c8fc00613a9',1,'s2let_transform_axisym_wav_hardthreshold_multires_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fhardthreshold_5freal_582',['s2let_transform_axisym_wav_hardthreshold_real',['../s2let__transform__axisym__mw_8c.html#af2f861872a0b6640d8e24202a451272f',1,'s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#af2f861872a0b6640d8e24202a451272f',1,'s2let_transform_axisym_wav_hardthreshold_real(double *g_wav, const double *threshold, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fmultires_5freal_5ftest_583',['s2let_transform_axisym_wav_multires_real_test',['../s2let__test_8c.html#a30b6b4ec19a7bc9c3bb7fb3b933e6c94',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fmultires_5ftest_584',['s2let_transform_axisym_wav_multires_test',['../s2let__test_8c.html#ac20052515fa751c919b54fb6bfb7b5a1',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5freal_5ftest_585',['s2let_transform_axisym_wav_real_test',['../s2let__test_8c.html#a42ef36d238046edb1b4a03e2269797f2',1,'s2let_test.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_586',['s2let_transform_axisym_wav_synthesis_adjoint_mw',['../s2let__transform__axisym__mw_8c.html#a333120eb88ad818a3e360c1004c3d1e8',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a595657bb4bf8ac9d99afe415539eff8e',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5fmultires_587',['s2let_transform_axisym_wav_synthesis_adjoint_mw_multires',['../s2let__transform__axisym__mw_8c.html#a9d4cb0b9b608e1956058899cfba58280',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(complex double *f_wav, complex double *f_scal, const complex double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#ac2b1764294b14d89aad77c8473d70e92',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires(S2LET_COMPLEX(double) *f_wav, S2LET_COMPLEX(double) *f_scal, const S2LET_COMPLEX(double) *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5fmultires_5freal_588',['s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#abcfc455a2b4dfd52f52d095227ff67c3',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#abcfc455a2b4dfd52f52d095227ff67c3',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_multires_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_589',['s2let_transform_axisym_wav_synthesis_adjoint_mw_real',['../s2let__transform__axisym__mw_8c.html#a202737e2b30d90af7984051d82e6b55a',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a202737e2b30d90af7984051d82e6b55a',1,'s2let_transform_axisym_wav_synthesis_adjoint_mw_real(double *f_wav, double *f_scal, const double *f, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fhpx_5freal_590',['s2let_transform_axisym_wav_synthesis_hpx_real',['../s2let__transform__axisym__hpx_8c.html#ad1987cd08f8add08bba681aa26c32b77',1,'s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c'],['../s2let__transform__axisym__hpx_8h.html#ad1987cd08f8add08bba681aa26c32b77',1,'s2let_transform_axisym_wav_synthesis_hpx_real(double *f, const double *f_wav, const double *f_scal, int nside, const s2let_parameters_t *parameters): s2let_transform_axisym_hpx.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_591',['s2let_transform_axisym_wav_synthesis_mw',['../s2let__transform__axisym__mw_8c.html#ab2dba22615138e520985ca58ead38e28',1,'s2let_transform_axisym_wav_synthesis_mw(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a26507106a70d5143e76fba3bb298f7e7',1,'s2let_transform_axisym_wav_synthesis_mw(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_592',['s2let_transform_axisym_wav_synthesis_mw_multires',['../s2let__transform__axisym__mw_8c.html#a002718ed6a64a6d7268626e01931ecba',1,'s2let_transform_axisym_wav_synthesis_mw_multires(complex double *f, const complex double *f_wav, const complex double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a988074918fff2d3f06b6898542ba1072',1,'s2let_transform_axisym_wav_synthesis_mw_multires(S2LET_COMPLEX(double) *f, const S2LET_COMPLEX(double) *f_wav, const S2LET_COMPLEX(double) *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.h']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5fmultires_5freal_593',['s2let_transform_axisym_wav_synthesis_mw_multires_real',['../s2let__transform__axisym__mw_8c.html#a9a77993fec7b5b26a0290ade7623c1ea',1,'s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a9a77993fec7b5b26a0290ade7623c1ea',1,'s2let_transform_axisym_wav_synthesis_mw_multires_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5fsynthesis_5fmw_5freal_594',['s2let_transform_axisym_wav_synthesis_mw_real',['../s2let__transform__axisym__mw_8c.html#a5eec6f7cb23d0ffb408abc583153d496',1,'s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c'],['../s2let__transform__axisym__mw_8h.html#a5eec6f7cb23d0ffb408abc583153d496',1,'s2let_transform_axisym_wav_synthesis_mw_real(double *f, const double *f_wav, const double *f_scal, const s2let_parameters_t *parameters): s2let_transform_axisym_mw.c']]], + ['s2let_5ftransform_5faxisym_5fwav_5ftest_595',['s2let_transform_axisym_wav_test',['../s2let__test_8c.html#a4f77ce64b0ecb6acdfeb8cd03b5b4d19',1,'s2let_test.c']]], + ['s2let_5ftransform_5flm_5fperformance_5fmultires_5ftest_596',['s2let_transform_lm_performance_multires_test',['../s2let__test_8c.html#a601830de99f48906fcfe6b53907bb190',1,'s2let_test.c']]], + ['s2let_5ftransform_5flm_5fperformance_5ftest_597',['s2let_transform_lm_performance_test',['../s2let__test_8c.html#a677d7f0b1315a8f13a3ecd057a928372',1,'s2let_test.c']]], + ['s2let_5ftransform_5fperformance_5fmultires_5ftest_598',['s2let_transform_performance_multires_test',['../s2let__test_8c.html#a6707d377e1f45cf08f165f35f9b4f4cc',1,'s2let_test.c']]], + ['s2let_5ftransform_5fperformance_5ftest_599',['s2let_transform_performance_test',['../s2let__test_8c.html#abf6416ad05d8f169fc6eadb5a9ad537d',1,'s2let_test.c']]], + ['s2let_5fwav_5fanalysis_5fadjoint_5flm_5flmn_5ftest_600',['s2let_wav_analysis_adjoint_lm_lmn_test',['../s2let__test_8c.html#afc35303ba9eb6beeee088d9f08c3444c',1,'s2let_test.c']]], + ['s2let_5fwav_5fanalysis_5fadjoint_5fmw_5freal_5ftest_601',['s2let_wav_analysis_adjoint_mw_real_test',['../s2let__test_8c.html#a07e8d14353d7a404098560c1a9db92fe',1,'s2let_test.c']]], + ['s2let_5fwav_5fanalysis_5fadjoint_5fmw_5ftest_602',['s2let_wav_analysis_adjoint_mw_test',['../s2let__test_8c.html#a4b3a9612e87e483e27bff0888bd964a0',1,'s2let_test.c']]], + ['s2let_5fwav_5fso3_5fforward_5fadjoint_5ftest_603',['s2let_wav_so3_forward_adjoint_test',['../s2let__test_8c.html#ac85f518078a76b2dd77de9ccc9f34f07',1,'s2let_test.c']]], + ['s2let_5fwav_5fsynthesis_5fadjoint_5flm2wav_5ftest_604',['s2let_wav_synthesis_adjoint_lm2wav_test',['../s2let__test_8c.html#ae9c1885807e8ac48440a0b0d3dd2a667',1,'s2let_test.c']]], + ['s2let_5fwav_5fsynthesis_5fadjoint_5flm_5flmn_5ftest_605',['s2let_wav_synthesis_adjoint_lm_lmn_test',['../s2let__test_8c.html#a33ed7d71c1e2543ab0ec5d5034a0269f',1,'s2let_test.c']]], + ['s2let_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_5ftest_606',['s2let_wav_synthesis_adjoint_mw_real_test',['../s2let__test_8c.html#a5185ca4b0f65740ab88242cff55b796d',1,'s2let_test.c']]], + ['s2let_5fwav_5fsynthesis_5fadjoint_5fmw_5ftest_607',['s2let_wav_synthesis_adjoint_mw_test',['../s2let__test_8c.html#a1bb00b26cbe0fbb23f41778220fa5824',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fharmonic_5fmultires_5ftest_608',['s2let_wav_transform_harmonic_multires_test',['../s2let__test_8c.html#a9a6c059a89a24d1faf87c71d4daa0aad',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fharmonic_5ftest_609',['s2let_wav_transform_harmonic_test',['../s2let__test_8c.html#a36c393819821e9d3230f1b611029c03a',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5flm2wav_5fmultires_5freal_5ftest_610',['s2let_wav_transform_lm2wav_multires_real_test',['../s2let__test_8c.html#a97581c49341c7cd099bde20868fc7cd6',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5flm2wav_5fmultires_5ftest_611',['s2let_wav_transform_lm2wav_multires_test',['../s2let__test_8c.html#af37a0a8300c436e3de4404914b06644b',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5flm2wav_5freal_5ftest_612',['s2let_wav_transform_lm2wav_real_test',['../s2let__test_8c.html#a4631a44a831e086e712e9f1aa7ffab62',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5flm2wav_5ftest_613',['s2let_wav_transform_lm2wav_test',['../s2let__test_8c.html#a2cf679450a2ce6ea636c2dc10f7e540a',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmw_5fmultires_5freal_5ftest_614',['s2let_wav_transform_mw_multires_real_test',['../s2let__test_8c.html#a4d1b3d1c528a9251c2f7ca5841b7ea4c',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmw_5fmultires_5ftest_615',['s2let_wav_transform_mw_multires_test',['../s2let__test_8c.html#a8e3ae237fa88d72d1dbd073219148d14',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmw_5freal_5ftest_616',['s2let_wav_transform_mw_real_test',['../s2let__test_8c.html#a8c730406b8d674ce01adf2f00b23a80b',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmw_5ftest_617',['s2let_wav_transform_mw_test',['../s2let__test_8c.html#ac21ea0848f541e57646992df1f019ac6',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmwss_5fmultires_5freal_5ftest_618',['s2let_wav_transform_mwss_multires_real_test',['../s2let__test_8c.html#a98871d63a676332bf18fa0e759ed7b75',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmwss_5fmultires_5ftest_619',['s2let_wav_transform_mwss_multires_test',['../s2let__test_8c.html#a47c841b99612070b47ad9cc82e15381f',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmwss_5freal_5ftest_620',['s2let_wav_transform_mwss_real_test',['../s2let__test_8c.html#a0405e044e4b231f44c78768efa065da2',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fmwss_5ftest_621',['s2let_wav_transform_mwss_test',['../s2let__test_8c.html#a50a13ab98a0345f3d9d66d4252f6b4c6',1,'s2let_test.c']]], + ['s2let_5fwav_5ftransform_5fwavlm_5fmanual_5ftest_622',['s2let_wav_transform_wavlm_manual_test',['../s2let__test_8c.html#a73199654867cc48b0fdfa593987dfecd',1,'s2let_test.c']]], + ['so3_5ftest_5fgen_5fflmn_5fcomplex_623',['so3_test_gen_flmn_complex',['../s2let__test_8c.html#af5b2cded1bb3914d1398df3b65eec310',1,'s2let_test.c']]] ]; diff --git a/docs/c/search/functions_9.js b/docs/c/search/functions_9.js index 49ca9158..5a640844 100644 --- a/docs/c/search/functions_9.js +++ b/docs/c/search/functions_9.js @@ -1,5 +1,31 @@ var searchData= [ - ['waveletpower_583',['waveletpower',['../s2let__denoising__demo_8c.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_denoising_demo.c'],['../s2let__spin__denoising__demo_8c.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_spin_denoising_demo.c'],['../s2let__denoising__demo_8h.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_denoising_demo.c']]], - ['write_5fhealpix_5fmap_5f_584',['write_healpix_map_',['../s2let__hpx_8c.html#a8b5ed98a88a7f8a79c0d31338f972b19',1,'s2let_hpx.c']]] + ['test_5fbinomial_5fcoefficient_624',['test_binomial_coefficient',['../test__tiling_8c.html#ae9633e0907423f3621ab89db8eedb2cf',1,'test_tiling.c']]], + ['test_5ftiling_5faxisym_625',['test_tiling_axisym',['../test__tiling_8c.html#a766f233806aaf9dd4e5fd864a2d810ee',1,'test_tiling.c']]], + ['test_5ftiling_5fdirection_626',['test_tiling_direction',['../test__tiling_8c.html#a4426878c26a0df52d562feb10a53a245',1,'test_tiling.c']]], + ['test_5ftiling_5fwavelet_627',['test_tiling_wavelet',['../test__tiling_8c.html#af21971543325f94b463757410edb0934',1,'test_tiling.c']]], + ['test_5ftransform_5faxisym_5flm_5fwav_628',['test_transform_axisym_lm_wav',['../test__back__and__forth_8c.html#ac9fcf3f5e4a2970da3b8e26e9b74c793',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5flm_5fwav_5fmultires_629',['test_transform_axisym_lm_wav_multires',['../test__back__and__forth_8c.html#a8ad18ca9179f167ba7a0d2515d8342f1',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_630',['test_transform_axisym_vs_directional_mw',['../test__axisym__vs__directional_8c.html#a74a283fc358f339a01d275f417c18e5d',1,'test_axisym_vs_directional.c']]], + ['test_5ftransform_5faxisym_5fvs_5fdirectional_5fmw_5fmultires_631',['test_transform_axisym_vs_directional_mw_multires',['../test__axisym__vs__directional_8c.html#ac97d3aa9eae5e240ca1d26dfda792e53',1,'test_axisym_vs_directional.c']]], + ['test_5ftransform_5faxisym_5fwav_632',['test_transform_axisym_wav',['../test__back__and__forth_8c.html#ab2e4e00c1d588b41ac24a8f4a94d6ad3',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5fwav_5fmultires_633',['test_transform_axisym_wav_multires',['../test__back__and__forth_8c.html#a0256cd509855748cdc48a79b423a041f',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5fwav_5fmultires_5freal_634',['test_transform_axisym_wav_multires_real',['../test__back__and__forth_8c.html#a7961f39862c9aa8a6fc65bd464b35bde',1,'test_back_and_forth.c']]], + ['test_5ftransform_5faxisym_5fwav_5freal_635',['test_transform_axisym_wav_real',['../test__back__and__forth_8c.html#a85921a6d1ef89b58d29ba1af7850bcd9',1,'test_back_and_forth.c']]], + ['test_5fwav_5fanalysis_5fadjoint_5flm_5flmn_636',['test_wav_analysis_adjoint_lm_lmn',['../test__adjoint_8c.html#ab09db2e87f3420892c200883fb9b9832',1,'test_adjoint.c']]], + ['test_5fwav_5fanalysis_5fadjoint_5fmw_637',['test_wav_analysis_adjoint_mw',['../test__adjoint_8c.html#a3d8bdd542273324689a6fccc7825992c',1,'test_adjoint.c']]], + ['test_5fwav_5fanalysis_5fadjoint_5fmw_5freal_638',['test_wav_analysis_adjoint_mw_real',['../test__adjoint_8c.html#a2d8f0d747f020308b003fdeb2d4b71cb',1,'test_adjoint.c']]], + ['test_5fwav_5fso3_5fforward_5fadjoint_639',['test_wav_so3_forward_adjoint',['../test__adjoint_8c.html#a0f720411753473e254fa74262847339a',1,'test_adjoint.c']]], + ['test_5fwav_5fsynthesis_5fadjoint_5flm2wav_640',['test_wav_synthesis_adjoint_lm2wav',['../test__adjoint_8c.html#ab774b4e999bca9dab81e71421ec1b260',1,'test_adjoint.c']]], + ['test_5fwav_5fsynthesis_5fadjoint_5flm_5flmn_641',['test_wav_synthesis_adjoint_lm_lmn',['../test__adjoint_8c.html#a6bdc8ebb47ecadfb1e927559bebcf640',1,'test_adjoint.c']]], + ['test_5fwav_5fsynthesis_5fadjoint_5fmw_642',['test_wav_synthesis_adjoint_mw',['../test__adjoint_8c.html#aab877161b784a8fc242165b4173a5946',1,'test_adjoint.c']]], + ['test_5fwav_5fsynthesis_5fadjoint_5fmw_5freal_643',['test_wav_synthesis_adjoint_mw_real',['../test__adjoint_8c.html#aed4d5ce08f37d79963730384439d5374',1,'test_adjoint.c']]], + ['test_5fwav_5ftransform_5fharmonic_644',['test_wav_transform_harmonic',['../test__back__and__forth_8c.html#abd77fc8c1591ee0376ac0cec3e0d9885',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5flm2wav_645',['test_wav_transform_lm2wav',['../test__back__and__forth_8c.html#aebab0b3d5193306db3a6e582c0d64a60',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5flm2wav_5freal_646',['test_wav_transform_lm2wav_real',['../test__back__and__forth_8c.html#a15d9a645d273a8487b2600d0a2d3f9b2',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fmw_647',['test_wav_transform_mw',['../test__back__and__forth_8c.html#a67571ae3b17fc9049b368e3c7b143689',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fmw_5freal_648',['test_wav_transform_mw_real',['../test__back__and__forth_8c.html#adedc312c4297f635233796f342a4f18e',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fmwss_649',['test_wav_transform_mwss',['../test__back__and__forth_8c.html#a96352af103febda3ace5d6484941b55a',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fmwss_5freal_650',['test_wav_transform_mwss_real',['../test__back__and__forth_8c.html#acd882d430247a801681dc151fd3a6189',1,'test_back_and_forth.c']]], + ['test_5fwav_5ftransform_5fwavlm_5fmanual_651',['test_wav_transform_wavlm_manual',['../test__back__and__forth_8c.html#aed300dd664e565c23cb0bf24a0eecc47',1,'test_back_and_forth.c']]] ]; diff --git a/docs/c/search/functions_a.html b/docs/c/search/functions_a.html new file mode 100644 index 00000000..df9ec09b --- /dev/null +++ b/docs/c/search/functions_a.html @@ -0,0 +1,36 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/c/search/functions_a.js b/docs/c/search/functions_a.js new file mode 100644 index 00000000..ba94c746 --- /dev/null +++ b/docs/c/search/functions_a.js @@ -0,0 +1,5 @@ +var searchData= +[ + ['waveletpower_652',['waveletpower',['../s2let__denoising__demo_8c.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_denoising_demo.c'],['../s2let__spin__denoising__demo_8c.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_spin_denoising_demo.c'],['../s2let__denoising__demo_8h.html#aa037f9325b8399e224222f8d5b9a2788',1,'waveletpower(complex double *wav_lm, int L): s2let_denoising_demo.c']]], + ['write_5fhealpix_5fmap_5f_653',['write_healpix_map_',['../s2let__hpx_8c.html#a8b5ed98a88a7f8a79c0d31338f972b19',1,'s2let_hpx.c']]] +]; diff --git a/docs/c/search/searchdata.js b/docs/c/search/searchdata.js index e7e4ca82..c7e3b708 100644 --- a/docs/c/search/searchdata.js +++ b/docs/c/search/searchdata.js @@ -1,9 +1,9 @@ var indexSectionsWithContent = { - 0: "abdfghijlmnoprsuvw", + 0: "abdfghijlmnoprstuvw", 1: "s", - 2: "s", - 3: "bfghmnprsw", + 2: "st", + 3: "bfghmnprstw", 4: "bdjlnorsuv", 5: "i", 6: "s", diff --git a/docs/c/search/typedefs_0.js b/docs/c/search/typedefs_0.js index 2811b13e..b5f28734 100644 --- a/docs/c/search/typedefs_0.js +++ b/docs/c/search/typedefs_0.js @@ -1,7 +1,7 @@ var searchData= [ - ['idl_5fint_597',['IDL_INT',['../s2let__idl__hpx_8c.html#a02b9546523fe5ea064e9cc44ce4ad751',1,'IDL_INT(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a02b9546523fe5ea064e9cc44ce4ad751',1,'IDL_INT(): s2let_idl_mw.c']]], - ['idl_5flong_598',['IDL_LONG',['../s2let__idl__hpx_8c.html#a2d29aee49d7de2cb7d11978dd8dfe4a3',1,'IDL_LONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a2d29aee49d7de2cb7d11978dd8dfe4a3',1,'IDL_LONG(): s2let_idl_mw.c']]], - ['idl_5fuint_599',['IDL_UINT',['../s2let__idl__hpx_8c.html#a5a626e989d3e813bd723db23edabbe08',1,'IDL_UINT(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a5a626e989d3e813bd723db23edabbe08',1,'IDL_UINT(): s2let_idl_mw.c']]], - ['idl_5fulong_600',['IDL_ULONG',['../s2let__idl__hpx_8c.html#abac63fddf94105cf1190b69730bb6a1c',1,'IDL_ULONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#abac63fddf94105cf1190b69730bb6a1c',1,'IDL_ULONG(): s2let_idl_mw.c']]] + ['idl_5fint_667',['IDL_INT',['../s2let__idl__hpx_8c.html#a02b9546523fe5ea064e9cc44ce4ad751',1,'IDL_INT(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a02b9546523fe5ea064e9cc44ce4ad751',1,'IDL_INT(): s2let_idl_mw.c']]], + ['idl_5flong_668',['IDL_LONG',['../s2let__idl__hpx_8c.html#a2d29aee49d7de2cb7d11978dd8dfe4a3',1,'IDL_LONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a2d29aee49d7de2cb7d11978dd8dfe4a3',1,'IDL_LONG(): s2let_idl_mw.c']]], + ['idl_5fuint_669',['IDL_UINT',['../s2let__idl__hpx_8c.html#a5a626e989d3e813bd723db23edabbe08',1,'IDL_UINT(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#a5a626e989d3e813bd723db23edabbe08',1,'IDL_UINT(): s2let_idl_mw.c']]], + ['idl_5fulong_670',['IDL_ULONG',['../s2let__idl__hpx_8c.html#abac63fddf94105cf1190b69730bb6a1c',1,'IDL_ULONG(): s2let_idl_hpx.c'],['../s2let__idl__mw_8c.html#abac63fddf94105cf1190b69730bb6a1c',1,'IDL_ULONG(): s2let_idl_mw.c']]] ]; diff --git a/docs/c/search/variables_0.js b/docs/c/search/variables_0.js index 43f9c972..c1f9c8c2 100644 --- a/docs/c/search/variables_0.js +++ b/docs/c/search/variables_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['b_585',['B',['../structs2let__parameters__t.html#a5aa59dd22d193213c138188e4a85282a',1,'s2let_parameters_t']]] + ['b_654',['B',['../structs2let__parameters__t.html#a5aa59dd22d193213c138188e4a85282a',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/variables_1.js b/docs/c/search/variables_1.js index 6ec79f2f..d15d4785 100644 --- a/docs/c/search/variables_1.js +++ b/docs/c/search/variables_1.js @@ -1,4 +1,4 @@ var searchData= [ - ['dl_5fmethod_586',['dl_method',['../structs2let__parameters__t.html#a6d39d3d306f418f81d599d2fad31158d',1,'s2let_parameters_t']]] + ['dl_5fmethod_655',['dl_method',['../structs2let__parameters__t.html#a6d39d3d306f418f81d599d2fad31158d',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/variables_2.js b/docs/c/search/variables_2.js index 9b47e125..3f9fe7ba 100644 --- a/docs/c/search/variables_2.js +++ b/docs/c/search/variables_2.js @@ -1,4 +1,4 @@ var searchData= [ - ['j_5fmin_587',['J_min',['../structs2let__parameters__t.html#a9146ca6b1dd496925173a0ab1feeccf7',1,'s2let_parameters_t']]] + ['j_5fmin_656',['J_min',['../structs2let__parameters__t.html#a9146ca6b1dd496925173a0ab1feeccf7',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/variables_3.js b/docs/c/search/variables_3.js index 1fb99469..1e7799e2 100644 --- a/docs/c/search/variables_3.js +++ b/docs/c/search/variables_3.js @@ -1,4 +1,4 @@ var searchData= [ - ['l_588',['L',['../structs2let__parameters__t.html#a018fcd55bd13a231c2c71f16cca5c53b',1,'s2let_parameters_t']]] + ['l_657',['L',['../structs2let__parameters__t.html#a018fcd55bd13a231c2c71f16cca5c53b',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/variables_4.js b/docs/c/search/variables_4.js index 27ca55fe..6e52f4b0 100644 --- a/docs/c/search/variables_4.js +++ b/docs/c/search/variables_4.js @@ -1,4 +1,4 @@ var searchData= [ - ['n_589',['N',['../structs2let__parameters__t.html#a93d528e7cc428bfc6783e9a01567b748',1,'s2let_parameters_t']]] + ['n_658',['N',['../structs2let__parameters__t.html#a93d528e7cc428bfc6783e9a01567b748',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/variables_5.js b/docs/c/search/variables_5.js index b605baed..9f0ad48c 100644 --- a/docs/c/search/variables_5.js +++ b/docs/c/search/variables_5.js @@ -1,4 +1,4 @@ var searchData= [ - ['original_5fspin_590',['original_spin',['../structs2let__parameters__t.html#a9b083a6f2ac9139fbe25605685c97b4e',1,'s2let_parameters_t']]] + ['original_5fspin_659',['original_spin',['../structs2let__parameters__t.html#a9b083a6f2ac9139fbe25605685c97b4e',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/variables_6.js b/docs/c/search/variables_6.js index cbd74fd2..e15d0e14 100644 --- a/docs/c/search/variables_6.js +++ b/docs/c/search/variables_6.js @@ -1,4 +1,4 @@ var searchData= [ - ['reality_591',['reality',['../structs2let__parameters__t.html#a7718737039d19e05501792535b32ef6d',1,'s2let_parameters_t']]] + ['reality_660',['reality',['../structs2let__parameters__t.html#a7718737039d19e05501792535b32ef6d',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/variables_7.js b/docs/c/search/variables_7.js index 65e0c100..cb28ec56 100644 --- a/docs/c/search/variables_7.js +++ b/docs/c/search/variables_7.js @@ -1,6 +1,7 @@ var searchData= [ - ['s2let_5fkernel_592',['s2let_kernel',['../s2let__tiling_8c.html#ab2ff4854b8611353b7ba607e99a742f3',1,'s2let_tiling.c']]], - ['sampling_5fscheme_593',['sampling_scheme',['../structs2let__parameters__t.html#a32942243b855116a10cc6b8b81a90b87',1,'s2let_parameters_t']]], - ['spin_594',['spin',['../structs2let__parameters__t.html#a4fd720e3d7a947dab5bbfd0f51c3dcf7',1,'s2let_parameters_t']]] + ['s2let_5fkernel_661',['s2let_kernel',['../s2let__tiling_8c.html#ab2ff4854b8611353b7ba607e99a742f3',1,'s2let_tiling.c']]], + ['sampling_5fscheme_662',['sampling_scheme',['../structs2let__parameters__t.html#a32942243b855116a10cc6b8b81a90b87',1,'s2let_parameters_t']]], + ['seed_663',['seed',['../test__adjoint_8c.html#ab1633aa266a0a720540840343194b2cf',1,'seed(): test_adjoint.c'],['../test__axisym__vs__directional_8c.html#ab1633aa266a0a720540840343194b2cf',1,'seed(): test_axisym_vs_directional.c'],['../test__back__and__forth_8c.html#ab1633aa266a0a720540840343194b2cf',1,'seed(): test_back_and_forth.c'],['../test__tiling_8c.html#ab1633aa266a0a720540840343194b2cf',1,'seed(): test_tiling.c']]], + ['spin_664',['spin',['../structs2let__parameters__t.html#a4fd720e3d7a947dab5bbfd0f51c3dcf7',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/variables_8.js b/docs/c/search/variables_8.js index 9ea4173a..381e75da 100644 --- a/docs/c/search/variables_8.js +++ b/docs/c/search/variables_8.js @@ -1,4 +1,4 @@ var searchData= [ - ['upsample_595',['upsample',['../structs2let__parameters__t.html#aec567c0f2af65ec246fd92169ae66216',1,'s2let_parameters_t']]] + ['upsample_665',['upsample',['../structs2let__parameters__t.html#aec567c0f2af65ec246fd92169ae66216',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/search/variables_9.js b/docs/c/search/variables_9.js index aba0cc33..e5dbbce3 100644 --- a/docs/c/search/variables_9.js +++ b/docs/c/search/variables_9.js @@ -1,4 +1,4 @@ var searchData= [ - ['verbosity_596',['verbosity',['../structs2let__parameters__t.html#a6198529ad111be476461d3d249d3fa0a',1,'s2let_parameters_t']]] + ['verbosity_666',['verbosity',['../structs2let__parameters__t.html#a6198529ad111be476461d3d249d3fa0a',1,'s2let_parameters_t']]] ]; diff --git a/docs/c/structs2let__parameters__t-members.html b/docs/c/structs2let__parameters__t-members.html new file mode 100644 index 00000000..fc825747 --- /dev/null +++ b/docs/c/structs2let__parameters__t-members.html @@ -0,0 +1,91 @@ + + + + + + + +s2let: Member List + + + + + + + + + +
    +
    +
    -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    + + + + + + +
    +
    s2let +  2.2.0 +
    +
    Fast wavelets on the sphere
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + +
    +
    +
    +
    s2let_parameters_t Member List
    +
    +
    + +

    This is the complete list of members for s2let_parameters_t, including all inherited members.

    + + + + + + + + + + + + +
    Bs2let_parameters_t
    dl_methods2let_parameters_t
    J_mins2let_parameters_t
    Ls2let_parameters_t
    Ns2let_parameters_t
    original_spins2let_parameters_t
    realitys2let_parameters_t
    sampling_schemes2let_parameters_t
    spins2let_parameters_t
    upsamples2let_parameters_t
    verbositys2let_parameters_t
    + +
    +Generated by doxygen 1.8.19 +
    + + diff --git a/docs/c/structs2let__parameters__t.html b/docs/c/structs2let__parameters__t.html index 414fe472..e66ddb6a 100644 --- a/docs/c/structs2let__parameters__t.html +++ b/docs/c/structs2let__parameters__t.html @@ -5,7 +5,7 @@ -S2LET: s2let_parameters_t Struct Reference +s2let: s2let_parameters_t Struct Reference @@ -22,10 +22,10 @@ Logo -
    S2LET -  1.2.0 +
    s2let +  2.2.0
    -
    Exact wavelets on the sphere
    +
    Fast wavelets on the sphere
    @@ -101,8 +101,6 @@

    Detailed Description

    A struct with all parameters that are common to several functions of the API. In general only one struct needs to be created and a const pointer to it is passed around.

    Attention
    Make sure to use an initializer upon declaration, even if it is left empty. This ensures that all fields are initialized to zero (even if in non-static storage). This way, your code will remain backwards compatible if more fields are added to this struct in the future:
    s2let_parameters_t parameters = {};
    - -

    Definition at line 56 of file s2let_types.h.

    Field Documentation

    ◆ B

    @@ -117,8 +115,6 @@

    Wavelet parameter which determines the scale factor between consecutive wavelet scales.

    -

    Definition at line 89 of file s2let_types.h.

    -

    @@ -134,8 +130,6 @@

    Recursion method to use for computing Wigner functions.

    -

    Definition at line 135 of file s2let_types.h.

    - @@ -151,8 +145,6 @@

    First wavelet scale to be used.

    -

    Definition at line 102 of file s2let_types.h.

    - @@ -168,8 +160,6 @@

    Upper harmonic band-limit. Only flmn with l < L will be stored and considered.

    -

    Definition at line 96 of file s2let_types.h.

    - @@ -185,8 +175,6 @@

    Upper azimuthal band-limit. Only flmn with n < N will be stored.

    -

    Definition at line 109 of file s2let_types.h.

    - @@ -202,8 +190,6 @@

    If normalization has value S2LET_WAV_NORM_SPIN_LOWERED this parameter indicates which spin number the wavelets were lowered from. Otherwise, it is ignored.

    -

    Definition at line 122 of file s2let_types.h.

    - @@ -219,8 +205,6 @@

    A non-zero value indicates that the signal f is real. Not all functions respect this value - instead there may be separate complex and real functions. See the documentation of each function for details.

    -

    Definition at line 70 of file s2let_types.h.

    - @@ -236,8 +220,6 @@

    Sampling scheme to use for samples of the signal f as well as the wavelets.

    -

    Definition at line 129 of file s2let_types.h.

    - @@ -253,8 +235,6 @@

    Spin number of the signal f.

    -

    Definition at line 115 of file s2let_types.h.

    - @@ -270,8 +250,6 @@

    A non-zero value indicates that the signal is stored in a full-resolution format, where each wavelet scale is upsampled to use the same amount of pixels. A zero-value indicates that the signal uses only as many pixels as necessary for each wavelet scale's upper harmonic bandlimit. This can lead to significant storage and time savings and is the default behaviour.

    -

    Definition at line 82 of file s2let_types.h.

    - @@ -287,18 +265,16 @@

    Detail level for diagnostic console output in range [0,5].

    -

    Definition at line 61 of file s2let_types.h.

    -
    The documentation for this struct was generated from the following file: -
    s2let_parameters_t
    Definition: s2let_types.h:56
    +
    s2let_parameters_t
    Definition: s2let_types.h:56
    -Generated on Fri Sep 18 2020 11:29:20 for S2LET by doxygen 1.8.19 +Generated by doxygen 1.8.19
    diff --git a/docs/c/test__adjoint_8c.html b/docs/c/test__adjoint_8c.html new file mode 100644 index 00000000..d6b4b121 --- /dev/null +++ b/docs/c/test__adjoint_8c.html @@ -0,0 +1,368 @@ + + + + + + + +s2let: src/test/c/test_adjoint.c File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    s2let +  2.2.0 +
    +
    Fast wavelets on the sphere
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Functions | +Variables
    +
    +
    test_adjoint.c File Reference
    +
    +
    +
    #include <setjmp.h>
    +#include <stdarg.h>
    +#include <stddef.h>
    +#include "s2let.h"
    +#include <cmocka.h>
    +
    +Include dependency graph for test_adjoint.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    +Functions

    void test_wav_analysis_adjoint_lm_lmn (void **state)
     
    void test_wav_synthesis_adjoint_lm_lmn (void **state)
     
    void test_wav_analysis_adjoint_mw (void **state)
     
    void test_wav_analysis_adjoint_mw_real (void **state)
     
    void test_wav_synthesis_adjoint_lm2wav (void **state)
     
    void test_wav_synthesis_adjoint_mw (void **state)
     
    void test_wav_synthesis_adjoint_mw_real (void **state)
     
    void gen_flmn_complex (complex double *flmn, const so3_parameters_t *parameters, int seed)
     
    void test_wav_so3_forward_adjoint (void **state)
     
    int main (void)
     
    + + + +

    +Variables

    const int seed = 1
     
    +

    Function Documentation

    + +

    ◆ gen_flmn_complex()

    + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + +
    void gen_flmn_complex (complex double * flmn,
    const so3_parameters_t * parameters,
    int seed 
    )
    +
    + +
    +
    + +

    ◆ main()

    + +
    +
    + + + + + + + + +
    int main (void )
    +
    + +
    +
    + +

    ◆ test_wav_analysis_adjoint_lm_lmn()

    + +
    +
    + + + + + + + + +
    void test_wav_analysis_adjoint_lm_lmn (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_analysis_adjoint_mw()

    + +
    +
    + + + + + + + + +
    void test_wav_analysis_adjoint_mw (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_analysis_adjoint_mw_real()

    + +
    +
    + + + + + + + + +
    void test_wav_analysis_adjoint_mw_real (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_so3_forward_adjoint()

    + +
    +
    + + + + + + + + +
    void test_wav_so3_forward_adjoint (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_synthesis_adjoint_lm2wav()

    + +
    +
    + + + + + + + + +
    void test_wav_synthesis_adjoint_lm2wav (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_synthesis_adjoint_lm_lmn()

    + +
    +
    + + + + + + + + +
    void test_wav_synthesis_adjoint_lm_lmn (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_synthesis_adjoint_mw()

    + +
    +
    + + + + + + + + +
    void test_wav_synthesis_adjoint_mw (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_synthesis_adjoint_mw_real()

    + +
    +
    + + + + + + + + +
    void test_wav_synthesis_adjoint_mw_real (void ** state)
    +
    + +
    +
    +

    Variable Documentation

    + +

    ◆ seed

    + +
    +
    + + + + +
    const int seed = 1
    +
    + +
    +
    +
    + +
    +Generated by doxygen 1.8.19 +
    + + diff --git a/docs/c/test__adjoint_8c__incl.map b/docs/c/test__adjoint_8c__incl.map new file mode 100644 index 00000000..1f7037ef --- /dev/null +++ b/docs/c/test__adjoint_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/test__adjoint_8c__incl.md5 b/docs/c/test__adjoint_8c__incl.md5 new file mode 100644 index 00000000..29553262 --- /dev/null +++ b/docs/c/test__adjoint_8c__incl.md5 @@ -0,0 +1 @@ +ebcfb84e6dc6253819f88f2a741bb825 \ No newline at end of file diff --git a/docs/c/test__axisym__vs__directional_8c.html b/docs/c/test__axisym__vs__directional_8c.html new file mode 100644 index 00000000..55ec2c18 --- /dev/null +++ b/docs/c/test__axisym__vs__directional_8c.html @@ -0,0 +1,242 @@ + + + + + + + +s2let: src/test/c/test_axisym_vs_directional.c File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    s2let +  2.2.0 +
    +
    Fast wavelets on the sphere
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Functions | +Variables
    +
    +
    test_axisym_vs_directional.c File Reference
    +
    +
    +
    #include <setjmp.h>
    +#include <stdarg.h>
    +#include <stddef.h>
    +#include "s2let.h"
    +#include <cmocka.h>
    +
    +Include dependency graph for test_axisym_vs_directional.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    + + + + + + + + + +

    +Functions

    _Bool min (int a, int b)
     
    void test_transform_axisym_vs_directional_mw (void **state)
     
    void test_transform_axisym_vs_directional_mw_multires (void **state)
     
    int main (void)
     
    + + + +

    +Variables

    const int seed = 1
     
    +

    Function Documentation

    + +

    ◆ main()

    + +
    +
    + + + + + + + + +
    int main (void )
    +
    + +
    +
    + +

    ◆ min()

    + +
    +
    + + + + + + + + + + + + + + + + + + +
    _Bool min (int a,
    int b 
    )
    +
    + +
    +
    + +

    ◆ test_transform_axisym_vs_directional_mw()

    + +
    +
    + + + + + + + + +
    void test_transform_axisym_vs_directional_mw (void ** state)
    +
    + +
    +
    + +

    ◆ test_transform_axisym_vs_directional_mw_multires()

    + +
    +
    + + + + + + + + +
    void test_transform_axisym_vs_directional_mw_multires (void ** state)
    +
    + +
    +
    +

    Variable Documentation

    + +

    ◆ seed

    + +
    +
    + + + + +
    const int seed = 1
    +
    + +
    +
    +
    + +
    +Generated by doxygen 1.8.19 +
    + + diff --git a/docs/c/test__axisym__vs__directional_8c__incl.map b/docs/c/test__axisym__vs__directional_8c__incl.map new file mode 100644 index 00000000..401a6183 --- /dev/null +++ b/docs/c/test__axisym__vs__directional_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/test__axisym__vs__directional_8c__incl.md5 b/docs/c/test__axisym__vs__directional_8c__incl.md5 new file mode 100644 index 00000000..eeb03552 --- /dev/null +++ b/docs/c/test__axisym__vs__directional_8c__incl.md5 @@ -0,0 +1 @@ +cd933301d2675200d5d39887dcf80b25 \ No newline at end of file diff --git a/docs/c/test__back__and__forth_8c.html b/docs/c/test__back__and__forth_8c.html new file mode 100644 index 00000000..e26c559c --- /dev/null +++ b/docs/c/test__back__and__forth_8c.html @@ -0,0 +1,501 @@ + + + + + + + +s2let: src/test/c/test_back_and_forth.c File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    s2let +  2.2.0 +
    +
    Fast wavelets on the sphere
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Macros | +Functions | +Variables
    +
    +
    test_back_and_forth.c File Reference
    +
    +
    +
    #include <setjmp.h>
    +#include <stdarg.h>
    +#include <stddef.h>
    +#include "s2let.h"
    +#include <cmocka.h>
    +
    +Include dependency graph for test_back_and_forth.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    + + + + + +

    +Macros

    #define S2LET_TESTS(name)
     
    #define S2LET_TESTS(name)   cmocka_unit_test_prestate(name, (void *)&spinzero)
     
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +Functions

    void test_transform_axisym_lm_wav (void **state)
     
    void test_transform_axisym_lm_wav_multires (void **state)
     
    void test_wav_transform_wavlm_manual (void **state)
     
    void test_wav_transform_harmonic (void **state)
     
    void test_transform_axisym_wav (void **state)
     
    void test_transform_axisym_wav_real (void **state)
     
    void test_transform_axisym_wav_multires (void **state)
     
    void test_transform_axisym_wav_multires_real (void **state)
     
    void test_wav_transform_mw (void **state)
     
    void test_wav_transform_mw_real (void **state)
     
    void test_wav_transform_mwss (void **state)
     
    void test_wav_transform_mwss_real (void **state)
     
    void test_wav_transform_lm2wav (void **state)
     
    void test_wav_transform_lm2wav_real (void **state)
     
    int main (void)
     
    + + + +

    +Variables

    const int seed = 1
     
    +

    Macro Definition Documentation

    + +

    ◆ S2LET_TESTS [1/2]

    + +
    +
    + + + + + + + + +
    #define S2LET_TESTS( name)
    +
    +Value:
    cmocka_unit_test_prestate(name, (void *)&spinzero_noupsample), \
    +
    cmocka_unit_test_prestate(name, (void *)&spinzero), \
    +
    cmocka_unit_test_prestate(name, (void *)&spintwo), \
    +
    cmocka_unit_test_prestate(name, (void *)&spintwo_noupsample)
    +
    +
    +
    + +

    ◆ S2LET_TESTS [2/2]

    + +
    +
    + + + + + + + + +
    #define S2LET_TESTS( name)   cmocka_unit_test_prestate(name, (void *)&spinzero)
    +
    + +
    +
    +

    Function Documentation

    + +

    ◆ main()

    + +
    +
    + + + + + + + + +
    int main (void )
    +
    + +
    +
    + +

    ◆ test_transform_axisym_lm_wav()

    + +
    +
    + + + + + + + + +
    void test_transform_axisym_lm_wav (void ** state)
    +
    + +
    +
    + +

    ◆ test_transform_axisym_lm_wav_multires()

    + +
    +
    + + + + + + + + +
    void test_transform_axisym_lm_wav_multires (void ** state)
    +
    + +
    +
    + +

    ◆ test_transform_axisym_wav()

    + +
    +
    + + + + + + + + +
    void test_transform_axisym_wav (void ** state)
    +
    + +
    +
    + +

    ◆ test_transform_axisym_wav_multires()

    + +
    +
    + + + + + + + + +
    void test_transform_axisym_wav_multires (void ** state)
    +
    + +
    +
    + +

    ◆ test_transform_axisym_wav_multires_real()

    + +
    +
    + + + + + + + + +
    void test_transform_axisym_wav_multires_real (void ** state)
    +
    + +
    +
    + +

    ◆ test_transform_axisym_wav_real()

    + +
    +
    + + + + + + + + +
    void test_transform_axisym_wav_real (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_transform_harmonic()

    + +
    +
    + + + + + + + + +
    void test_wav_transform_harmonic (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_transform_lm2wav()

    + +
    +
    + + + + + + + + +
    void test_wav_transform_lm2wav (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_transform_lm2wav_real()

    + +
    +
    + + + + + + + + +
    void test_wav_transform_lm2wav_real (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_transform_mw()

    + +
    +
    + + + + + + + + +
    void test_wav_transform_mw (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_transform_mw_real()

    + +
    +
    + + + + + + + + +
    void test_wav_transform_mw_real (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_transform_mwss()

    + +
    +
    + + + + + + + + +
    void test_wav_transform_mwss (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_transform_mwss_real()

    + +
    +
    + + + + + + + + +
    void test_wav_transform_mwss_real (void ** state)
    +
    + +
    +
    + +

    ◆ test_wav_transform_wavlm_manual()

    + +
    +
    + + + + + + + + +
    void test_wav_transform_wavlm_manual (void ** state)
    +
    + +
    +
    +

    Variable Documentation

    + +

    ◆ seed

    + +
    +
    + + + + +
    const int seed = 1
    +
    + +
    +
    +
    + +
    +Generated by doxygen 1.8.19 +
    + + diff --git a/docs/c/test__back__and__forth_8c__incl.map b/docs/c/test__back__and__forth_8c__incl.map new file mode 100644 index 00000000..3b3a4f81 --- /dev/null +++ b/docs/c/test__back__and__forth_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/test__back__and__forth_8c__incl.md5 b/docs/c/test__back__and__forth_8c__incl.md5 new file mode 100644 index 00000000..a080d0d2 --- /dev/null +++ b/docs/c/test__back__and__forth_8c__incl.md5 @@ -0,0 +1 @@ +02367e0e5e5b8026cec31efc1be7ec25 \ No newline at end of file diff --git a/docs/c/test__tiling_8c.html b/docs/c/test__tiling_8c.html new file mode 100644 index 00000000..634bb192 --- /dev/null +++ b/docs/c/test__tiling_8c.html @@ -0,0 +1,255 @@ + + + + + + + +s2let: src/test/c/test_tiling.c File Reference + + + + + + + + + +
    +
    + + + + + + + +
    +
    s2let +  2.2.0 +
    +
    Fast wavelets on the sphere
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Functions | +Variables
    +
    +
    test_tiling.c File Reference
    +
    +
    +
    #include <setjmp.h>
    +#include <stdarg.h>
    +#include <stddef.h>
    +#include "s2let.h"
    +#include <cmocka.h>
    +
    +Include dependency graph for test_tiling.c:
    +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    + + + + + + + + + + + +

    +Functions

    void test_tiling_axisym (void **state)
     
    void test_tiling_direction (void **state)
     
    void test_tiling_wavelet (void **state)
     
    void test_binomial_coefficient (void **state)
     
    int main (void)
     
    + + + +

    +Variables

    const int seed = 1
     
    +

    Function Documentation

    + +

    ◆ main()

    + +
    +
    + + + + + + + + +
    int main (void )
    +
    + +
    +
    + +

    ◆ test_binomial_coefficient()

    + +
    +
    + + + + + + + + +
    void test_binomial_coefficient (void ** state)
    +
    + +
    +
    + +

    ◆ test_tiling_axisym()

    + +
    +
    + + + + + + + + +
    void test_tiling_axisym (void ** state)
    +
    +

    Identity relation of the wavelet tiling in harmonic space

    + +
    +
    + +

    ◆ test_tiling_direction()

    + +
    +
    + + + + + + + + +
    void test_tiling_direction (void ** state)
    +
    +

    Identity relation of the directionality components for tiling in harmonic space.

    + +
    +
    + +

    ◆ test_tiling_wavelet()

    + +
    +
    + + + + + + + + +
    void test_tiling_wavelet (void ** state)
    +
    +

    Identity relation of the directional wavelets for tiling in harmonic space.

    + +
    +
    +

    Variable Documentation

    + +

    ◆ seed

    + +
    +
    + + + + +
    const int seed = 1
    +
    + +
    +
    +
    + +
    +Generated by doxygen 1.8.19 +
    + + diff --git a/docs/c/test__tiling_8c__incl.map b/docs/c/test__tiling_8c__incl.map new file mode 100644 index 00000000..46589c28 --- /dev/null +++ b/docs/c/test__tiling_8c__incl.map @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/c/test__tiling_8c__incl.md5 b/docs/c/test__tiling_8c__incl.md5 new file mode 100644 index 00000000..7b4fba01 --- /dev/null +++ b/docs/c/test__tiling_8c__incl.md5 @@ -0,0 +1 @@ +1744cabd7ec65d29977456c39e873e0d \ No newline at end of file From 40b06f574b4e0ef854f802b2fc2d8543fea37a28 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Thu, 15 Oct 2020 23:18:27 +0100 Subject: [PATCH 08/23] :robot: update python and conan workflows --- .github/workflows/conan.yml | 58 ++++++++++++++ .github/workflows/python.yml | 144 +++++++++++++++++++++++++++++------ setup.cfg | 4 +- 3 files changed, 180 insertions(+), 26 deletions(-) create mode 100644 .github/workflows/conan.yml diff --git a/.github/workflows/conan.yml b/.github/workflows/conan.yml new file mode 100644 index 00000000..926fb81d --- /dev/null +++ b/.github/workflows/conan.yml @@ -0,0 +1,58 @@ +name: Conan Packaging + +on: + push: + branches: ["main"] + tags: + - "v[0-9]+.[0-9]+.[0-9]+" + - "v[0-9]+.[0-9]+.[0-9]+rc[0-9]+" + pull_request: + +jobs: + conan: + name: conan packaging and publication on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest] + build_type: ["Release"] + fpic: ["True", "False"] + cfitsio: ["True", "False"] + + steps: + - uses: actions/checkout@v2 + + - uses: actions/setup-python@v2 + with: + python-version: 3.8 + + - name: install conan + run: | + python3 -m pip install --upgrade pip wheel + python3 -m pip install conan + conan remote add astro-informatics \ + https://api.bintray.com/conan/astro-informatics/astro-informatics + + - name: create stable or testing package + shell: bash + run: | + if [ "${{ github.ref }}" = "refs/tags/v1.3.0" ]; then + channel="stable" + else + channel="testing" + fi + conan create . astro-informatics/${channel} \ + --build missing \ + -o s2let:fPIC=${{matrix.fpic}} \ + -o s2let:with_cfitsio=${{matrix.cfitsio}} \ + -s build_type=${{matrix.build_type}} \ + + - name: upload to bintray + if: ${{ startsWith(github.ref, 'refs/tags') }} + shell: bash + env: + CONAN_PASSWORD: ${{secrets.BINTRAY_TOKEN}} + CONAN_LOGIN_USERNAME: astroinformaticsci + CONAN_REMOTE_URL: https://api.bintray.com/conan/astro-informatics/astro-informatics + run: conan upload s2let/2.1.0 -c --all -r=astro-informatics diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index 879339f6..4d5ad9e4 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -1,36 +1,132 @@ -name: python +name: Python Build -on: +"on": push: - branches: ["main"] + branches: ["main"] + tags: + - "v[0-9]+.[0-9]+.[0-9]+" + - "v[0-9]+.[0-9]+.[0-9]+rc[0-9]+" pull_request: jobs: - testing: + development-mode: + name: pip development mode on ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: - os: [ubuntu-latest, macos-latest] + os: [macos-latest] python-version: [3.8] steps: - - uses: actions/checkout@v2 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - - name: Install build packages - run: python -m pip install --upgrade pip scikit-build wheel - - - name: Create sdist package - run: python setup.py sdist - - - name: Install pys2let - run: pip install dist/pys2let-2.1.0.tar.gz - - - name: Run pytest - run: | - pip install pytest - pytest src/test/python + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - name: Install build packages and pytest + run: | + python -m pip install --upgrade pip wheel + python -m pip install scikit-build + + - name: Install python s2let + run: pip install -e .[dev] + + - name: run pytest + run: pytest tests/ + + from-sdist: + name: python source distribution + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.8 + uses: actions/setup-python@v2 + with: + python-version: 3.8 + + - name: Install build packages and pytest + run: | + python -m pip install --upgrade pip wheel setuptools + python -m pip install conan scikit-build pytest cython numpy + + - name: Create sdist + run: python setup.py sdist + + - name: Install python s2let + run: "pip install dist/s2let-*.tar.gz" + + - name: run pytest + run: pytest tests/ + + - uses: actions/upload-artifact@v2 + if: ${{ startsWith(github.ref, 'refs/tags') }} + with: + path: ./dist/*.tar.gz + name: source-distribution + + + build_wheels: + name: Build wheels on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [macos-latest] + python-version: [3.8] + + steps: + - uses: actions/checkout@v2 + + - uses: actions/setup-python@v2 + name: Install Python + with: + python-version: ${{ matrix.python-version }} + + - name: Setup environment + run: | + python -m pip install --upgrade pip wheel + python -m pip install conan pytest + conan profile new default --detect + + - name: Build wheels + run: pip wheel . --use-pep517 --no-deps -w dist + + - name: install wheel + run: "pip install dist/*.whl" + + - name: run pytests + run: pytest tests + + - uses: actions/upload-artifact@v2 + if: ${{ startsWith(github.ref, 'refs/tags') }} + with: + path: ./dist/*.whl + name: wheel-${{matrix.os}}-${{matrix.python-version}} + + publication: + name: publish to pypi + if: ${{ startsWith(github.ref, 'refs/tags') }} + runs-on: ubuntu-latest + needs: [build_wheels, from-sdist] + steps: + - name: Download wheels and sdist + uses: actions/download-artifact@v2 + + - name: Move wheels and source distribution to dist/ + run: | + mkdir -p dist + mv source-distribution/*.tar.gz wheel-*/*.whl dist + + - name: Publish distribution 📦 to Test PyPI + if: ${{ github.ref != 'refs/tags/v2.1.0' }} + uses: pypa/gh-action-pypi-publish@master + with: + password: ${{ secrets.TEST_PYPI_TOKEN }} + repository_url: https://test.pypi.org/legacy/ + + - name: Publish distribution 📦 to PyPI + if: ${{ github.ref == 'refs/tags/v2.1.0' }} + uses: pypa/gh-action-pypi-publish@master + with: + password: ${{ secrets.PYPI_TOKEN }} diff --git a/setup.cfg b/setup.cfg index 652c8636..ba08aef8 100644 --- a/setup.cfg +++ b/setup.cfg @@ -16,8 +16,8 @@ tag = False [bumpversion:file:conanfile.py] [bumpversion:file:.github/workflows/python.yml] -search = dist/pys2let-{current_version}.tar.gz -replace = dist/pys2let-{new_version}.tar.gz + +[bumpversion:file:.github/workflows/conan.yml] [flake8] max-line-length = 88 From ab78792d5b17a19fac21eb3d513f22451b1ea7cc Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Thu, 15 Oct 2020 23:21:25 +0100 Subject: [PATCH 09/23] Update bintray address to astro-informatics --- README.md | 4 ++-- conanfile.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index c9382428..90ffc79c 100644 --- a/README.md +++ b/README.md @@ -2,8 +2,8 @@ [docs-img]: https://img.shields.io/badge/docs-stable-blue.svg [docs-url]: https://astro-informatics.github.io/s2let/ -[bintray-img]: https://img.shields.io/bintray/v/mdavezac/AstroFizz/s2let:AstroFizz?label=C%20package -[bintray-url]: https://bintray.com/mdavezac/AstroFizz/s2let:AstroFizz/2.1.0:stable/link +[bintray-img]: https://img.shields.io/bintray/v/astro-informatics/astro-informatics/s2let:astro-informactics?label=C%20package +[bintray-url]: https://bintray.com/astro-informatics/astro-informatics/s2let:astro-informatics/2.1.0:stable/link [pypi-img]: https://badge.fury.io/py/pys2let.svg [pypi-url]: https://badge.fury.io/py/pys2let diff --git a/conanfile.py b/conanfile.py index 8327fc66..22508659 100644 --- a/conanfile.py +++ b/conanfile.py @@ -31,7 +31,7 @@ def configure(self): del self.settings.compiler.libcxx def requirements(self): - self.requires("so3/1.2.1@AstroFizz/stable") + self.requires("so3/1.3.0@astro-informatics/stable") if self.options.with_cfitsio: self.requires("cfitsio/3.480") From eede4bc483ba458b3bce797733cd13f470b911ac Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Fri, 16 Oct 2020 10:08:36 +0100 Subject: [PATCH 10/23] Update conanfile for out-of-source build Because otherwise it dies one cmocka --- conanfile.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/conanfile.py b/conanfile.py index 22508659..7a63e349 100644 --- a/conanfile.py +++ b/conanfile.py @@ -43,10 +43,16 @@ def cmake(self): self._cmake.definitions["conan_deps"] = True self._cmake.definitions["python"] = False self._cmake.definitions["fPIC"] = self.options.fPIC - self._cmake.configure(source_folder=".") + self._cmake.configure(build_folder="build") return self._cmake def build(self): + from pathlib import Path + + path = Path(self.source_folder) + build = Path(self.source_folder) / "build" + build.mkdir(exist_ok=True) + (path / "conanbuildinfo.cmake").rename(path / "build" / "conanbuildinfo.cmake") self.cmake.build() self.cmake.test() From 1d74e7ab60b378e18353631e08b340ac9681d31d Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Fri, 16 Oct 2020 10:31:32 +0100 Subject: [PATCH 11/23] :robot: point to right places for pytest --- .github/workflows/python.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index 4d5ad9e4..ac361fc8 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -34,7 +34,7 @@ jobs: run: pip install -e .[dev] - name: run pytest - run: pytest tests/ + run: pytest src/test/python/ from-sdist: name: python source distribution @@ -58,7 +58,7 @@ jobs: run: "pip install dist/s2let-*.tar.gz" - name: run pytest - run: pytest tests/ + run: pytest src/test/python/ - uses: actions/upload-artifact@v2 if: ${{ startsWith(github.ref, 'refs/tags') }} @@ -96,7 +96,7 @@ jobs: run: "pip install dist/*.whl" - name: run pytests - run: pytest tests + run: pytest src/test/python/ - uses: actions/upload-artifact@v2 if: ${{ startsWith(github.ref, 'refs/tags') }} From cd6b48c606cd5f67a29dae84372fc0ba7a8dcbee Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Fri, 16 Oct 2020 10:43:41 +0100 Subject: [PATCH 12/23] :robot: try and figure out which conan package fail --- .github/workflows/conan.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/conan.yml b/.github/workflows/conan.yml index 926fb81d..782dcf9f 100644 --- a/.github/workflows/conan.yml +++ b/.github/workflows/conan.yml @@ -34,7 +34,7 @@ jobs: conan remote add astro-informatics \ https://api.bintray.com/conan/astro-informatics/astro-informatics - - name: create stable or testing package + - name: create package with fpic=${{matrix.fpic}} cfitsio=${{matrix.cfitsio}} shell: bash run: | if [ "${{ github.ref }}" = "refs/tags/v1.3.0" ]; then From af199b440e2a877013f5f2ff53fc6c31f8e90b00 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Fri, 16 Oct 2020 22:05:34 +0100 Subject: [PATCH 13/23] Move headers to include/s2let --- MANIFEST.in | 2 +- conanfile.py | 7 ++++--- include/{ => s2let}/s2let.h | 0 include/{ => s2let}/s2let_alloc.h | 0 include/{ => s2let}/s2let_analysis.h | 0 include/{ => s2let}/s2let_analysis_adjoint.h | 0 include/{ => s2let}/s2let_axisym_denoising_demo.h | 0 include/{ => s2let}/s2let_denoising_demo.h | 0 include/{ => s2let}/s2let_error.h | 0 include/{ => s2let}/s2let_fits.h | 0 include/{ => s2let}/s2let_helper.h | 0 include/{ => s2let}/s2let_hpx.h | 0 include/{ => s2let}/s2let_idl_hpx.h | 0 include/{ => s2let}/s2let_idl_mw.h | 0 include/{ => s2let}/s2let_lm.h | 0 include/{ => s2let}/s2let_math.h | 0 include/{ => s2let}/s2let_mex.h | 0 include/{ => s2let}/s2let_mw.h | 0 include/{ => s2let}/s2let_so3.h | 0 include/{ => s2let}/s2let_synthesis.h | 0 include/{ => s2let}/s2let_synthesis_adjoint.h | 0 include/{ => s2let}/s2let_tiling.h | 0 include/{ => s2let}/s2let_transform_axisym_hpx.h | 0 include/{ => s2let}/s2let_transform_axisym_lm.h | 0 include/{ => s2let}/s2let_transform_axisym_mw.h | 0 include/{ => s2let}/s2let_types.h | 0 src/main/c/CMakeLists.txt | 12 +++--------- src/main/c/s2let_alloc.c | 2 +- src/main/c/s2let_analysis.c | 2 +- src/main/c/s2let_analysis_adjoint.c | 2 +- src/main/c/s2let_axisym_denoising_demo.c | 2 +- src/main/c/s2let_denoising_demo.c | 2 +- src/main/c/s2let_fits.c | 2 +- src/main/c/s2let_helper.c | 2 +- src/main/c/s2let_hpx.c | 2 +- src/main/c/s2let_hpx_demo.c | 2 +- src/main/c/s2let_idl_hpx.c | 2 +- src/main/c/s2let_idl_mw.c | 2 +- src/main/c/s2let_lm.c | 2 +- src/main/c/s2let_math.c | 2 +- src/main/c/s2let_mw.c | 2 +- src/main/c/s2let_spin_denoising_demo.c | 2 +- src/main/c/s2let_synthesis.c | 2 +- src/main/c/s2let_synthesis_adjoint.c | 2 +- src/main/c/s2let_tiling.c | 2 +- .../c/s2let_transform_axisym_analysis_hpx_real.c | 2 +- src/main/c/s2let_transform_axisym_analysis_mw_real.c | 2 +- src/main/c/s2let_transform_axisym_hpx.c | 2 +- src/main/c/s2let_transform_axisym_lm.c | 2 +- src/main/c/s2let_transform_axisym_mw.c | 2 +- .../c/s2let_transform_axisym_synthesis_hpx_real.c | 2 +- .../c/s2let_transform_axisym_synthesis_mw_real.c | 2 +- src/test/c/test_adjoint.c | 2 +- src/test/c/test_axisym_vs_directional.c | 2 +- src/test/c/test_back_and_forth.c | 2 +- src/test/c/test_tiling.c | 2 +- 56 files changed, 37 insertions(+), 42 deletions(-) rename include/{ => s2let}/s2let.h (100%) rename include/{ => s2let}/s2let_alloc.h (100%) rename include/{ => s2let}/s2let_analysis.h (100%) rename include/{ => s2let}/s2let_analysis_adjoint.h (100%) rename include/{ => s2let}/s2let_axisym_denoising_demo.h (100%) rename include/{ => s2let}/s2let_denoising_demo.h (100%) rename include/{ => s2let}/s2let_error.h (100%) rename include/{ => s2let}/s2let_fits.h (100%) rename include/{ => s2let}/s2let_helper.h (100%) rename include/{ => s2let}/s2let_hpx.h (100%) rename include/{ => s2let}/s2let_idl_hpx.h (100%) rename include/{ => s2let}/s2let_idl_mw.h (100%) rename include/{ => s2let}/s2let_lm.h (100%) rename include/{ => s2let}/s2let_math.h (100%) rename include/{ => s2let}/s2let_mex.h (100%) rename include/{ => s2let}/s2let_mw.h (100%) rename include/{ => s2let}/s2let_so3.h (100%) rename include/{ => s2let}/s2let_synthesis.h (100%) rename include/{ => s2let}/s2let_synthesis_adjoint.h (100%) rename include/{ => s2let}/s2let_tiling.h (100%) rename include/{ => s2let}/s2let_transform_axisym_hpx.h (100%) rename include/{ => s2let}/s2let_transform_axisym_lm.h (100%) rename include/{ => s2let}/s2let_transform_axisym_mw.h (100%) rename include/{ => s2let}/s2let_types.h (100%) diff --git a/MANIFEST.in b/MANIFEST.in index 9fa8bdff..e4c476ed 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -3,5 +3,5 @@ include setup.py setup.cfg pyproject.toml include COPYRIGHT.txt LICENSE.md README.md include cmake/*.cmake recursive-include src/main/c *.c CMakeLists.txt -recursive-include include *.h +recursive-include include/s2let *.h recursive-include src/main/pys2let .py *.pyx *.md CMakeLists.txt diff --git a/conanfile.py b/conanfile.py index 7a63e349..69f6396f 100644 --- a/conanfile.py +++ b/conanfile.py @@ -1,4 +1,4 @@ -from conans import ConanFile, CMake +from conans import CMake, ConanFile class S2letConan(ConanFile): @@ -16,7 +16,7 @@ class S2letConan(ConanFile): exports_sources = [ "src/main/c/*", "src/test/c/*", - "include/*", + "include/s2let/*", "CMakeLists.txt", "cmake/*.cmake", ] @@ -31,7 +31,8 @@ def configure(self): del self.settings.compiler.libcxx def requirements(self): - self.requires("so3/1.3.0@astro-informatics/stable") + location = "astro-informatics/stable" if self.in_local_cache else "user/testing" + self.requires(f"so3/1.3.0@{location}") if self.options.with_cfitsio: self.requires("cfitsio/3.480") diff --git a/include/s2let.h b/include/s2let/s2let.h similarity index 100% rename from include/s2let.h rename to include/s2let/s2let.h diff --git a/include/s2let_alloc.h b/include/s2let/s2let_alloc.h similarity index 100% rename from include/s2let_alloc.h rename to include/s2let/s2let_alloc.h diff --git a/include/s2let_analysis.h b/include/s2let/s2let_analysis.h similarity index 100% rename from include/s2let_analysis.h rename to include/s2let/s2let_analysis.h diff --git a/include/s2let_analysis_adjoint.h b/include/s2let/s2let_analysis_adjoint.h similarity index 100% rename from include/s2let_analysis_adjoint.h rename to include/s2let/s2let_analysis_adjoint.h diff --git a/include/s2let_axisym_denoising_demo.h b/include/s2let/s2let_axisym_denoising_demo.h similarity index 100% rename from include/s2let_axisym_denoising_demo.h rename to include/s2let/s2let_axisym_denoising_demo.h diff --git a/include/s2let_denoising_demo.h b/include/s2let/s2let_denoising_demo.h similarity index 100% rename from include/s2let_denoising_demo.h rename to include/s2let/s2let_denoising_demo.h diff --git a/include/s2let_error.h b/include/s2let/s2let_error.h similarity index 100% rename from include/s2let_error.h rename to include/s2let/s2let_error.h diff --git a/include/s2let_fits.h b/include/s2let/s2let_fits.h similarity index 100% rename from include/s2let_fits.h rename to include/s2let/s2let_fits.h diff --git a/include/s2let_helper.h b/include/s2let/s2let_helper.h similarity index 100% rename from include/s2let_helper.h rename to include/s2let/s2let_helper.h diff --git a/include/s2let_hpx.h b/include/s2let/s2let_hpx.h similarity index 100% rename from include/s2let_hpx.h rename to include/s2let/s2let_hpx.h diff --git a/include/s2let_idl_hpx.h b/include/s2let/s2let_idl_hpx.h similarity index 100% rename from include/s2let_idl_hpx.h rename to include/s2let/s2let_idl_hpx.h diff --git a/include/s2let_idl_mw.h b/include/s2let/s2let_idl_mw.h similarity index 100% rename from include/s2let_idl_mw.h rename to include/s2let/s2let_idl_mw.h diff --git a/include/s2let_lm.h b/include/s2let/s2let_lm.h similarity index 100% rename from include/s2let_lm.h rename to include/s2let/s2let_lm.h diff --git a/include/s2let_math.h b/include/s2let/s2let_math.h similarity index 100% rename from include/s2let_math.h rename to include/s2let/s2let_math.h diff --git a/include/s2let_mex.h b/include/s2let/s2let_mex.h similarity index 100% rename from include/s2let_mex.h rename to include/s2let/s2let_mex.h diff --git a/include/s2let_mw.h b/include/s2let/s2let_mw.h similarity index 100% rename from include/s2let_mw.h rename to include/s2let/s2let_mw.h diff --git a/include/s2let_so3.h b/include/s2let/s2let_so3.h similarity index 100% rename from include/s2let_so3.h rename to include/s2let/s2let_so3.h diff --git a/include/s2let_synthesis.h b/include/s2let/s2let_synthesis.h similarity index 100% rename from include/s2let_synthesis.h rename to include/s2let/s2let_synthesis.h diff --git a/include/s2let_synthesis_adjoint.h b/include/s2let/s2let_synthesis_adjoint.h similarity index 100% rename from include/s2let_synthesis_adjoint.h rename to include/s2let/s2let_synthesis_adjoint.h diff --git a/include/s2let_tiling.h b/include/s2let/s2let_tiling.h similarity index 100% rename from include/s2let_tiling.h rename to include/s2let/s2let_tiling.h diff --git a/include/s2let_transform_axisym_hpx.h b/include/s2let/s2let_transform_axisym_hpx.h similarity index 100% rename from include/s2let_transform_axisym_hpx.h rename to include/s2let/s2let_transform_axisym_hpx.h diff --git a/include/s2let_transform_axisym_lm.h b/include/s2let/s2let_transform_axisym_lm.h similarity index 100% rename from include/s2let_transform_axisym_lm.h rename to include/s2let/s2let_transform_axisym_lm.h diff --git a/include/s2let_transform_axisym_mw.h b/include/s2let/s2let_transform_axisym_mw.h similarity index 100% rename from include/s2let_transform_axisym_mw.h rename to include/s2let/s2let_transform_axisym_mw.h diff --git a/include/s2let_types.h b/include/s2let/s2let_types.h similarity index 100% rename from include/s2let_types.h rename to include/s2let/s2let_types.h diff --git a/src/main/c/CMakeLists.txt b/src/main/c/CMakeLists.txt index 51410f9e..f331433f 100644 --- a/src/main/c/CMakeLists.txt +++ b/src/main/c/CMakeLists.txt @@ -11,7 +11,6 @@ set(C_SRC s2let_helper.c s2let_analysis.c s2let_analysis_adjoint.c) -set(HEADER_PREFIX ${PROJECT_SOURCE_DIR}/include) set(C_HEADERS s2let.h s2let_error.h @@ -39,11 +38,12 @@ set(C_HEADERS if(cfitsio) list(APPEND C_SRC s2let_fits.c) endif() -list(TRANSFORM C_HEADERS PREPEND "${PROJECT_SOURCE_DIR}/include/") +list(TRANSFORM C_HEADERS PREPEND "${PROJECT_SOURCE_DIR}/include/s2let") add_library(s2let STATIC ${C_SRC}) target_link_libraries(s2let PUBLIC ${SO3_TARGET} ${CFITSIO_TARGET}) -set_target_properties(s2let PROPERTIES C_STANDARD 99) +set_target_properties(s2let PROPERTIES C_STANDARD 99 ARCHIVE_OUTPUT_DIRECTORY + ${PROJECT_BINARY_DIR}/lib) target_include_directories( s2let PUBLIC $ $) @@ -52,12 +52,6 @@ if(fPIC) endif() if(NOT python) - add_executable(s2let_about s2let_about.c) - target_compile_definitions( - s2let_about PRIVATE S2LET_VERSION="${PROJECT_VERSION}" S2LET_BUILD="CMake") - set_target_properties(s2let_about PROPERTIES RUNTIME_OUTPUT_DIRECTORY - ${PROJECT_BINARY_DIR}) - install( TARGETS s2let EXPORT S2letTargets diff --git a/src/main/c/s2let_alloc.c b/src/main/c/s2let_alloc.c index ea0a9319..82a65536 100644 --- a/src/main/c/s2let_alloc.c +++ b/src/main/c/s2let_alloc.c @@ -9,7 +9,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * Allocate map for a complex signal in pixel space using MW sampling. diff --git a/src/main/c/s2let_analysis.c b/src/main/c/s2let_analysis.c index 1f6e9970..d7986535 100644 --- a/src/main/c/s2let_analysis.c +++ b/src/main/c/s2let_analysis.c @@ -9,7 +9,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * Wavelet analysis from harmonic space to Wigner space for complex signals. diff --git a/src/main/c/s2let_analysis_adjoint.c b/src/main/c/s2let_analysis_adjoint.c index 4540cf6f..8e839ef1 100644 --- a/src/main/c/s2let_analysis_adjoint.c +++ b/src/main/c/s2let_analysis_adjoint.c @@ -9,7 +9,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * Wavelet analysis adjoint from Wigner space to harmonic space for complex signals. diff --git a/src/main/c/s2let_axisym_denoising_demo.c b/src/main/c/s2let_axisym_denoising_demo.c index 1c6ed8c9..b7499e1f 100644 --- a/src/main/c/s2let_axisym_denoising_demo.c +++ b/src/main/c/s2let_axisym_denoising_demo.c @@ -11,7 +11,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" void s2let_lm_random_flm_real_sigma( complex double *flm, int L, int seed, double sigmanoise) { diff --git a/src/main/c/s2let_denoising_demo.c b/src/main/c/s2let_denoising_demo.c index e152e13a..fa4df6b8 100644 --- a/src/main/c/s2let_denoising_demo.c +++ b/src/main/c/s2let_denoising_demo.c @@ -11,7 +11,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" void s2let_lm_random_flm_real_sigma( complex double *flm, int L, int seed, double sigmanoise) { diff --git a/src/main/c/s2let_fits.c b/src/main/c/s2let_fits.c index cc66ede1..17fe892b 100644 --- a/src/main/c/s2let_fits.c +++ b/src/main/c/s2let_fits.c @@ -4,7 +4,7 @@ #include -#include "s2let.h" +#include "s2let/s2let.h" void printerror(int status) { if (status) { diff --git a/src/main/c/s2let_helper.c b/src/main/c/s2let_helper.c index 2bb7dcca..97c53eda 100644 --- a/src/main/c/s2let_helper.c +++ b/src/main/c/s2let_helper.c @@ -1,6 +1,6 @@ #include -#include "s2let.h" +#include "s2let/s2let.h" int s2let_n_phi(const s2let_parameters_t *parameters) { if (parameters->sampling_scheme == S2LET_SAMPLING_MW_SS) diff --git a/src/main/c/s2let_hpx.c b/src/main/c/s2let_hpx.c index 57ab98b9..7c966e9d 100644 --- a/src/main/c/s2let_hpx.c +++ b/src/main/c/s2let_hpx.c @@ -6,7 +6,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" // Fortran interfaces to Healpix F90 library ; see s2let_hpx.f90 extern void healpix_inverse_real_(); diff --git a/src/main/c/s2let_hpx_demo.c b/src/main/c/s2let_hpx_demo.c index 80ff1a16..d945fcaa 100644 --- a/src/main/c/s2let_hpx_demo.c +++ b/src/main/c/s2let_hpx_demo.c @@ -11,7 +11,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * PROGRAM : s2let_hpx_demo diff --git a/src/main/c/s2let_idl_hpx.c b/src/main/c/s2let_idl_hpx.c index df4e8db4..b2592b15 100644 --- a/src/main/c/s2let_idl_hpx.c +++ b/src/main/c/s2let_idl_hpx.c @@ -2,7 +2,7 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" +#include "s2let/s2let.h" /* * IDL integer types. For historical reasons, we use UCHAR for TYP_BYTE diff --git a/src/main/c/s2let_idl_mw.c b/src/main/c/s2let_idl_mw.c index 55f25b1b..100f2367 100644 --- a/src/main/c/s2let_idl_mw.c +++ b/src/main/c/s2let_idl_mw.c @@ -2,7 +2,7 @@ // Copyright (C) 2012 // Boris Leistedt & Jason McEwen -#include "s2let.h" +#include "s2let/s2let.h" /* * IDL integer types. For historical reasons, we use UCHAR for TYP_BYTE diff --git a/src/main/c/s2let_lm.c b/src/main/c/s2let_lm.c index b89bb5fb..b6968c94 100644 --- a/src/main/c/s2let_lm.c +++ b/src/main/c/s2let_lm.c @@ -9,7 +9,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * Compute power for a signal in harmonic space. diff --git a/src/main/c/s2let_math.c b/src/main/c/s2let_math.c index 84c7d784..338ad980 100644 --- a/src/main/c/s2let_math.c +++ b/src/main/c/s2let_math.c @@ -7,7 +7,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * Tiling function for S2DW wavelets diff --git a/src/main/c/s2let_mw.c b/src/main/c/s2let_mw.c index 12968c4d..c0c1f956 100644 --- a/src/main/c/s2let_mw.c +++ b/src/main/c/s2let_mw.c @@ -7,7 +7,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * Interface to SSHT (required by the Java interface to S2LET) diff --git a/src/main/c/s2let_spin_denoising_demo.c b/src/main/c/s2let_spin_denoising_demo.c index 293c5359..98a5e34f 100644 --- a/src/main/c/s2let_spin_denoising_demo.c +++ b/src/main/c/s2let_spin_denoising_demo.c @@ -10,7 +10,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" void s2let_lm_random_flm_sigma( complex double *flm, int L, int spin, int seed, double sigmanoise) { diff --git a/src/main/c/s2let_synthesis.c b/src/main/c/s2let_synthesis.c index 9ba8dcaa..d22ed159 100644 --- a/src/main/c/s2let_synthesis.c +++ b/src/main/c/s2let_synthesis.c @@ -9,7 +9,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * Wavelet synthesis from Wigner space to harmonic space for complex signals. diff --git a/src/main/c/s2let_synthesis_adjoint.c b/src/main/c/s2let_synthesis_adjoint.c index 2b727c85..d23b28bd 100644 --- a/src/main/c/s2let_synthesis_adjoint.c +++ b/src/main/c/s2let_synthesis_adjoint.c @@ -9,7 +9,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * Wavelet synthesis adjoint from harmonic space to Wigner space for complex signals. diff --git a/src/main/c/s2let_tiling.c b/src/main/c/s2let_tiling.c index 31b589e4..3939f130 100644 --- a/src/main/c/s2let_tiling.c +++ b/src/main/c/s2let_tiling.c @@ -6,7 +6,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" // // diff --git a/src/main/c/s2let_transform_axisym_analysis_hpx_real.c b/src/main/c/s2let_transform_axisym_analysis_hpx_real.c index 7ef0f177..88977067 100644 --- a/src/main/c/s2let_transform_axisym_analysis_hpx_real.c +++ b/src/main/c/s2let_transform_axisym_analysis_hpx_real.c @@ -10,7 +10,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * PROGRAM : s2let_transform_axisym_hpx_analysis_real diff --git a/src/main/c/s2let_transform_axisym_analysis_mw_real.c b/src/main/c/s2let_transform_axisym_analysis_mw_real.c index bfd08fdd..6fc6f2ca 100644 --- a/src/main/c/s2let_transform_axisym_analysis_mw_real.c +++ b/src/main/c/s2let_transform_axisym_analysis_mw_real.c @@ -10,7 +10,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * PROGRAM : s2let_transform_axisym_mw_analysis_real diff --git a/src/main/c/s2let_transform_axisym_hpx.c b/src/main/c/s2let_transform_axisym_hpx.c index f58d91c2..5e0482f6 100644 --- a/src/main/c/s2let_transform_axisym_hpx.c +++ b/src/main/c/s2let_transform_axisym_hpx.c @@ -5,7 +5,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" void s2let_transform_axisym_allocate_hpx_f_wav_real( double **f_wav, double **f_scal, int nside, const s2let_parameters_t *parameters) { diff --git a/src/main/c/s2let_transform_axisym_lm.c b/src/main/c/s2let_transform_axisym_lm.c index 69067e8d..69e97229 100644 --- a/src/main/c/s2let_transform_axisym_lm.c +++ b/src/main/c/s2let_transform_axisym_lm.c @@ -6,7 +6,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" static inline int lm2ind(int el, int m) { return el * el + el + m; } diff --git a/src/main/c/s2let_transform_axisym_mw.c b/src/main/c/s2let_transform_axisym_mw.c index f3f8d701..50cd42b9 100644 --- a/src/main/c/s2let_transform_axisym_mw.c +++ b/src/main/c/s2let_transform_axisym_mw.c @@ -7,7 +7,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * Allocates arrays for final wavelets and scaling functions in pixel space (MW diff --git a/src/main/c/s2let_transform_axisym_synthesis_hpx_real.c b/src/main/c/s2let_transform_axisym_synthesis_hpx_real.c index 90186d42..b17b151c 100644 --- a/src/main/c/s2let_transform_axisym_synthesis_hpx_real.c +++ b/src/main/c/s2let_transform_axisym_synthesis_hpx_real.c @@ -10,7 +10,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * PROGRAM : s2let_transform_axisym_hpx_synthesis_real diff --git a/src/main/c/s2let_transform_axisym_synthesis_mw_real.c b/src/main/c/s2let_transform_axisym_synthesis_mw_real.c index 48555b31..50279496 100644 --- a/src/main/c/s2let_transform_axisym_synthesis_mw_real.c +++ b/src/main/c/s2let_transform_axisym_synthesis_mw_real.c @@ -10,7 +10,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" /*! * PROGRAM : s2let_transform_axisym_mw_synthesis_real diff --git a/src/test/c/test_adjoint.c b/src/test/c/test_adjoint.c index 0fb08a42..50746798 100644 --- a/src/test/c/test_adjoint.c +++ b/src/test/c/test_adjoint.c @@ -2,7 +2,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" #include diff --git a/src/test/c/test_axisym_vs_directional.c b/src/test/c/test_axisym_vs_directional.c index 9096d37c..7525c6e2 100644 --- a/src/test/c/test_axisym_vs_directional.c +++ b/src/test/c/test_axisym_vs_directional.c @@ -2,7 +2,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" #include diff --git a/src/test/c/test_back_and_forth.c b/src/test/c/test_back_and_forth.c index 849494d9..aae669fa 100644 --- a/src/test/c/test_back_and_forth.c +++ b/src/test/c/test_back_and_forth.c @@ -2,7 +2,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" #include diff --git a/src/test/c/test_tiling.c b/src/test/c/test_tiling.c index 95b65ed8..c894e689 100644 --- a/src/test/c/test_tiling.c +++ b/src/test/c/test_tiling.c @@ -2,7 +2,7 @@ #include #include -#include "s2let.h" +#include "s2let/s2let.h" #include From f76f261700d043c8611a8616117b3a1e45de5eab Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Fri, 16 Oct 2020 22:06:15 +0100 Subject: [PATCH 14/23] Add sanitizers to tests --- CMakeLists.txt | 1 + cmake/fetch_cmocka.cmake | 1 + cmake/sanitizers.cmake | 25 +++++++++++++++++++++++++ src/test/c/CMakeLists.txt | 8 ++++---- 4 files changed, 31 insertions(+), 4 deletions(-) create mode 100644 cmake/sanitizers.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index 92c718c8..d6aa08f9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -21,6 +21,7 @@ if(NOT CMAKE_BUILD_TYPE) endif() list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) +include("sanitizers") if(conan_deps) include("conan_dependencies") set(SO3_TARGET CONAN_PKG::so3) diff --git a/cmake/fetch_cmocka.cmake b/cmake/fetch_cmocka.cmake index 62a820b5..4f05969d 100644 --- a/cmake/fetch_cmocka.cmake +++ b/cmake/fetch_cmocka.cmake @@ -5,6 +5,7 @@ FetchContent_Declare( GIT_REPOSITORY https://gitlab.com/cmocka/cmocka.git GIT_TAG cmocka-1.1.5) +FetchContent_GetProperties("cmocka") if(NOT cmocka_POPULATED) # Fetch the content using previously declared details FetchContent_Populate("cmocka") diff --git a/cmake/sanitizers.cmake b/cmake/sanitizers.cmake new file mode 100644 index 00000000..c83cfe96 --- /dev/null +++ b/cmake/sanitizers.cmake @@ -0,0 +1,25 @@ +function(target_add_sanitizers TARGET_NAME) + get_target_property(target_type ${TARGET_NAME} TYPE) + if(target_type MATCHES "LIBRARY") + set(linker_name "SHARED_LINKER") + elseif(target_type MATCHES "EXECUTABLE") + set(linker_name "EXEC_LINKER") + elseif(target_type MATCHES "MODULE") + set(linker_name "MODULE_LINKER") + endif() + foreach(sanitizer ${ARGN}) + string(TOUPPER "${sanitizer}" sanitizer) + set(sanitizer_name CMAKE_C_FLAGS_${sanitizer}SANITIZER) + if(${sanitizer_name}) + string(REPLACE " " ";" compile ${${sanitizer_name}}) + target_compile_options(${TARGET_NAME} PUBLIC ${compile}) + else() + message(FATAL_ERROR "Uknown sanitizer ${sanitizer}") + endif() + set(sanitizer_name CMAKE_${linker_name}_FLAGS_${sanitizer}SANITIZER) + if(${sanitizer_name}) + string(REPLACE " " ";" compile ${${sanitizer_name}}) + target_link_options(${TARGET_NAME} PUBLIC ${compile}) + endif() + endforeach() +endfunction() diff --git a/src/test/c/CMakeLists.txt b/src/test/c/CMakeLists.txt index 1caf6b49..af967826 100644 --- a/src/test/c/CMakeLists.txt +++ b/src/test/c/CMakeLists.txt @@ -1,9 +1,9 @@ -add_executable(s2let_test s2let_test.c) -target_link_libraries(s2let_test PUBLIC s2let) -add_test(NAME s2let_test COMMAND s2let_test) - foreach(name tiling adjoint back_and_forth axisym_vs_directional) add_executable(test_${name} test_${name}.c) target_link_libraries(test_${name} PUBLIC s2let cmocka) add_test(NAME test_${name} COMMAND test_${name}) + target_add_sanitizers(test_${name} ${SANITIZERS}) + set_target_properties( + test_${name} PROPERTIES C_STANDARD 11 RUNTIME_OUTPUT_DIRECTORY + ${PROJECT_BINARY_DIR}/bin) endforeach() From 1183be9a7667745846eaa4feafcd7a55e9b4f8c2 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Fri, 16 Oct 2020 22:06:56 +0100 Subject: [PATCH 15/23] Avoid including docs target in subprojects --- CMakeLists.txt | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index d6aa08f9..36d3a075 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -57,10 +57,13 @@ else() add_subdirectory(src/main/pys2let) endif() -find_package(Doxygen) -if(DOXYGEN_FOUND) - set(DOXYGEN_PROJECT_LOGO ${PROJECT_SOURCE_DIR}/docs/images/wav.png) - set(DOXYGEN_OPTIMIZE_OUTPUT_FOR_C "YES") - set(DOXYGEN_EXTRACT_ALL "YES") +# only run documentation if this is not a sub-project +if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR) + find_package(Doxygen) + if(DOXYGEN_FOUND) + set(DOXYGEN_PROJECT_LOGO ${PROJECT_SOURCE_DIR}/docs/images/wav.png) + set(DOXYGEN_OPTIMIZE_OUTPUT_FOR_C "YES") + set(DOXYGEN_EXTRACT_ALL "YES") doxygen_add_docs(docs src/main/c src/test/c include) + endif() endif() From 24de7a7d756a439690f3717088602c620e6045cd Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Fri, 16 Oct 2020 22:35:38 +0100 Subject: [PATCH 16/23] Add CONAN_EDITABLE_MODE option --- CMakeLists.txt | 13 ++++++++----- cmake/conan_dependencies.cmake | 13 ++++++++----- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 36d3a075..87cc5a53 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -22,19 +22,22 @@ endif() list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) include("sanitizers") -if(conan_deps) +if(conan_deps OR CONAN_EDITABLE_MODE) include("conan_dependencies") - set(SO3_TARGET CONAN_PKG::so3) + if(NOT CONAN_EDITABLE_MODE) + set(SO3_TARGET CONAN_PKG::so3) + endif() if(cfitsio) set(CFITSIO_TARGET CONAN_PKG::cfitsio) endif() -else() +endif() +if(NOT conan_deps) find_package(So3 REQUIRED) - if(cfitsio) + set(SO3_TARGET so3) + if(cfitsio AND NOT CONAN_EDITABLE_MODE) find_package(CFITSIO REQUIRED) set(CFITSIO_TARGET cfitsio::cfitsio) endif() - set(SO3_TARGET So3) endif() add_subdirectory(src/main/c) diff --git a/cmake/conan_dependencies.cmake b/cmake/conan_dependencies.cmake index 18ba5475..7119b64f 100644 --- a/cmake/conan_dependencies.cmake +++ b/cmake/conan_dependencies.cmake @@ -12,10 +12,12 @@ if(fPIC AND NOT CONAN_OPTIONS) elseif(NOT CONAN_OPTIONS) set(fpic_value "False") endif() -if(NOT CONAN_DEPS) - set(CONAN_DEPS "so3/1.3.0@astro-informatics/stable") +if(NOT CONAN_EDITABLE_MODE) + if(NOT CONAN_DEPS) + set(CONAN_DEPS "so3/1.3.0@astro-informatics/stable") + endif() + list(APPEND CONAN_OPTIONS "so3:fPIC=${fpic_value}") endif() -list(APPEND CONAN_OPTIONS "so3:fPIC=${fpic_value}") if(cfitsio) list(APPEND CONAN_DEPS "cfitsio/3.480") list(APPEND CONAN_OPTIONS "cfitsio:shared=False" "cfitsio:fPIC=${fpic_value}") @@ -25,8 +27,9 @@ if(NOT CONAN_BUILD) endif() conan_check(REQUIRED) -conan_add_remote(NAME astro-informatics URL - https://api.bintray.com/conan/astro-informatics/astro-informatics) +conan_add_remote( + NAME astro-informatics URL + https://api.bintray.com/conan/astro-informatics/astro-informatics) conan_cmake_run( REQUIRES ${CONAN_DEPS} From 044b3922b1cc687dfd210b5469ad989dbc951a73 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Fri, 16 Oct 2020 22:47:45 +0100 Subject: [PATCH 17/23] :bug: variable not set in fill_so3_parameters --- include/s2let/s2let_so3.h | 1 + 1 file changed, 1 insertion(+) diff --git a/include/s2let/s2let_so3.h b/include/s2let/s2let_so3.h index 7d0698b7..770c06af 100644 --- a/include/s2let/s2let_so3.h +++ b/include/s2let/s2let_so3.h @@ -32,6 +32,7 @@ static inline void fill_so3_parameters(so3_parameters_t *so3_parameters, const s so3_parameters->dl_method = parameters->dl_method; so3_parameters->reality = parameters->reality; so3_parameters->steerable = 0; // When direct routines support steerable so3 change this to 1. + so3_parameters->L0 = 0; if (parameters->N % 2) so3_parameters->n_mode = SO3_N_MODE_EVEN; From e34faa11422a7f92a5b0972dd115576c8e86429b Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Sat, 17 Oct 2020 14:26:10 +0100 Subject: [PATCH 18/23] Add s2let version info to headers --- include/s2let/s2let_version.in.h | 25 +++++++++++++++++++++++++ src/main/c/CMakeLists.txt | 11 +++++++++++ src/main/c/s2let_about.c | 8 +++++++- 3 files changed, 43 insertions(+), 1 deletion(-) create mode 100644 include/s2let/s2let_version.in.h diff --git a/include/s2let/s2let_version.in.h b/include/s2let/s2let_version.in.h new file mode 100644 index 00000000..0ed1b290 --- /dev/null +++ b/include/s2let/s2let_version.in.h @@ -0,0 +1,25 @@ +#ifndef S2LET_VERSION_H +#define S2LET_VERSION_H +inline const char *s2let_version_string() { return "@PROJECT_VERSION@"; } +inline const char *s2let_info() { + return "package:\n" + " name: S2LET\n" + " description: Scale-discretised axisymmetric and direction wavelets\n" + " authors:\n" + " - Boris Leistedt\n" + " - Martin Büttner\n" + " - Jennifer Chan\n" + " - Jason McEwen\n" + " license: GPL-3\n" + " url: https://astro-informatics.github.io/s2let\n" + " version: @PROJECT_VERSION@\n"; +}; +// clang-format off +inline int s2let_version_major() { return @PROJECT_VERSION_MAJOR@; } +inline int s2let_version_minor() { return @PROJECT_VERSION_MINOR@; } +inline int s2let_version_patch() { return @PROJECT_VERSION_PATCH@; } +#define S2LET_VERSION_MAJOR @PROJECT_VERSION_MAJOR@ +#define S2LET_VERSION_MINOR @PROJECT_VERSION_MINOR@ +#define S2LET_VERSION_PATCH @PROJECT_VERSION_PATCH@ +// clang-format on +#endif diff --git a/src/main/c/CMakeLists.txt b/src/main/c/CMakeLists.txt index f331433f..007d2404 100644 --- a/src/main/c/CMakeLists.txt +++ b/src/main/c/CMakeLists.txt @@ -40,6 +40,10 @@ if(cfitsio) endif() list(TRANSFORM C_HEADERS PREPEND "${PROJECT_SOURCE_DIR}/include/s2let") +configure_file(${PROJECT_SOURCE_DIR}/include/s2let/s2let_version.in.h + ${PROJECT_BINARY_DIR}/include/s2let/s2let_version.h) +list(APPEND C_HEADERS ${PROJECT_BINARY_DIR}/include/s2let/s2let_version.h) + add_library(s2let STATIC ${C_SRC}) target_link_libraries(s2let PUBLIC ${SO3_TARGET} ${CFITSIO_TARGET}) set_target_properties(s2let PROPERTIES C_STANDARD 99 ARCHIVE_OUTPUT_DIRECTORY @@ -52,6 +56,13 @@ if(fPIC) endif() if(NOT python) + add_executable(s2let_about s2let_about.c) + target_compile_definitions(s2let_about + PRIVATE S2LET_VERSION="${PROJECT_VERSION}") + target_include_directories(s2let_about PUBLIC ${PROJECT_BINARY_DIR}/include/s2let) + target_compile_definitions(s2let_about PUBLIC BUILT_WITH_CMAKE) + set_target_properties(s2let_about PROPERTIES RUNTIME_OUTPUT_DIRECTORY + ${PROJECT_BINARY_DIR}/bin) install( TARGETS s2let EXPORT S2letTargets diff --git a/src/main/c/s2let_about.c b/src/main/c/s2let_about.c index 0a27510a..2526e81e 100644 --- a/src/main/c/s2let_about.c +++ b/src/main/c/s2let_about.c @@ -12,9 +12,14 @@ */ #include +#ifdef BUILT_WITH_CMAKE +#include "s2let_version.h" +#endif int main(int argc, char *argv[]) { - +#ifdef BUILT_WITH_CMAKE + printf("%s", s2let_info()); +#else printf("%s\n", "=========================================================="); printf("%s\n", " S2LET package"); printf("%s\n", " Fast Wavelets on the Sphere"); @@ -25,6 +30,7 @@ int main(int argc, char *argv[]) { printf("%s%s\n", " Version: ", S2LET_VERSION); printf("%s%s\n", " Build: ", S2LET_BUILD); printf("%s\n", "=========================================================="); +#endif return 0; } From 4ae3b98827efec2de52ddf514367ce623f0d8b2f Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Sat, 17 Oct 2020 14:26:31 +0100 Subject: [PATCH 19/23] Remove s2let_about --- src/main/c/CMakeLists.txt | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/main/c/CMakeLists.txt b/src/main/c/CMakeLists.txt index 007d2404..90639f35 100644 --- a/src/main/c/CMakeLists.txt +++ b/src/main/c/CMakeLists.txt @@ -56,13 +56,6 @@ if(fPIC) endif() if(NOT python) - add_executable(s2let_about s2let_about.c) - target_compile_definitions(s2let_about - PRIVATE S2LET_VERSION="${PROJECT_VERSION}") - target_include_directories(s2let_about PUBLIC ${PROJECT_BINARY_DIR}/include/s2let) - target_compile_definitions(s2let_about PUBLIC BUILT_WITH_CMAKE) - set_target_properties(s2let_about PROPERTIES RUNTIME_OUTPUT_DIRECTORY - ${PROJECT_BINARY_DIR}/bin) install( TARGETS s2let EXPORT S2letTargets From b6922de2b9b377d48b085452e9c3386902166c77 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Mon, 19 Oct 2020 21:46:56 +0100 Subject: [PATCH 20/23] Typo in build files --- src/main/c/CMakeLists.txt | 2 +- src/main/pys2let/pys2let.pyx | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/c/CMakeLists.txt b/src/main/c/CMakeLists.txt index 90639f35..560ea6fd 100644 --- a/src/main/c/CMakeLists.txt +++ b/src/main/c/CMakeLists.txt @@ -38,7 +38,7 @@ set(C_HEADERS if(cfitsio) list(APPEND C_SRC s2let_fits.c) endif() -list(TRANSFORM C_HEADERS PREPEND "${PROJECT_SOURCE_DIR}/include/s2let") +list(TRANSFORM C_HEADERS PREPEND "${PROJECT_SOURCE_DIR}/include/s2let/") configure_file(${PROJECT_SOURCE_DIR}/include/s2let/s2let_version.in.h ${PROJECT_BINARY_DIR}/include/s2let/s2let_version.h) diff --git a/src/main/pys2let/pys2let.pyx b/src/main/pys2let/pys2let.pyx index 39a52344..4ae572a2 100644 --- a/src/main/pys2let/pys2let.pyx +++ b/src/main/pys2let/pys2let.pyx @@ -46,7 +46,7 @@ cdef extern from "ssht/ssht.h": #----------------------------------------------------------------------------------------------------# -cdef extern from "s2let.h": +cdef extern from "s2let/s2let.h": void fill_so3_parameters(so3_parameters_t *parameters1, s2let_parameters_t *parameters2) int s2let_n_phi(const s2let_parameters_t *parameters) From 23c9e1d487d664aec174700f02ab8e8dac7ab393 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Mon, 19 Oct 2020 21:57:03 +0100 Subject: [PATCH 21/23] Make test file discoverable by pytest --- .../python/{tests_axisym_adjoints.py => test_axisym_adjoints.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/test/python/{tests_axisym_adjoints.py => test_axisym_adjoints.py} (100%) diff --git a/src/test/python/tests_axisym_adjoints.py b/src/test/python/test_axisym_adjoints.py similarity index 100% rename from src/test/python/tests_axisym_adjoints.py rename to src/test/python/test_axisym_adjoints.py From c0442f5967d41705a8ac459320e18e7aa8832644 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Mon, 19 Oct 2020 21:58:14 +0100 Subject: [PATCH 22/23] :books: Update readme badges --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 90ffc79c..30f6dec8 100644 --- a/README.md +++ b/README.md @@ -6,10 +6,14 @@ [bintray-url]: https://bintray.com/astro-informatics/astro-informatics/s2let:astro-informatics/2.1.0:stable/link [pypi-img]: https://badge.fury.io/py/pys2let.svg [pypi-url]: https://badge.fury.io/py/pys2let +[codefactor-img]: https://www.codefactor.io/repository/github/astro-informatics/s2let/badge/main +[codefactor-url]: https://www.codefactor.io/repository/github/astro-informatics/s2let/overview/main [![][docs-img]][docs-url] [![][bintray-img]][bintray-url] [![][pypi-img]][pypi-url] +![CMake Build](https://github.com/astro-informatics/s2let/workflows/CMake%20Build/badge.svg) +![Python Build](https://github.com/astro-informatics/s2let/workflows/Python%20Build/badge.svg) ## DESCRIPTION From dada014b87162aba75f8c994f052bb9196fffd22 Mon Sep 17 00:00:00 2001 From: Mayeul d'Avezac <2745737+mdavezac@users.noreply.github.com> Date: Mon, 19 Oct 2020 22:03:10 +0100 Subject: [PATCH 23/23] :robot: minor issues in github actions --- .github/workflows/cmake.yml | 2 +- .github/workflows/python.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml index c723809e..3f247679 100644 --- a/.github/workflows/cmake.yml +++ b/.github/workflows/cmake.yml @@ -1,4 +1,4 @@ -name: CMake +name: CMake Build on: push: diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index ac361fc8..770df5b8 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -55,7 +55,7 @@ jobs: run: python setup.py sdist - name: Install python s2let - run: "pip install dist/s2let-*.tar.gz" + run: "pip install dist/pys2let-*.tar.gz" - name: run pytest run: pytest src/test/python/