Showing preview only (7,591K chars total). Download the full file or copy to clipboard to get everything.
Repository: xthebat/optolithium
Branch: master
Commit: b3b38a93fdcf
Files: 671
Total size: 7.1 MB
Directory structure:
gitextract_kvc5fbke/
├── .hgignore
├── COPYRIGHT
├── LICENSE.TXT
├── OptolithiumC/
│ ├── CMakeLists.txt
│ ├── FindFFTW.cmake
│ ├── FindNumPy.cmake
│ ├── clipper.i
│ ├── examples/
│ │ ├── aerial_image_various_source_shapes.py
│ │ └── resist_images_and_contours.py
│ ├── include/
│ │ ├── opl_capi.h
│ │ ├── opl_contours.h
│ │ ├── opl_conv.h
│ │ ├── opl_eikonal.h
│ │ ├── opl_fft.h
│ │ ├── opl_geometry.h
│ │ ├── opl_interp.h
│ │ ├── opl_iter.h
│ │ ├── opl_log.h
│ │ ├── opl_misc.h
│ │ ├── opl_physc.h
│ │ ├── opl_sim.h
│ │ └── optolithium.h
│ ├── libs/
│ │ ├── armadillo/
│ │ │ ├── include/
│ │ │ │ ├── armadillo
│ │ │ │ └── armadillo_bits/
│ │ │ │ ├── BaseCube_bones.hpp
│ │ │ │ ├── BaseCube_meat.hpp
│ │ │ │ ├── Base_bones.hpp
│ │ │ │ ├── Base_meat.hpp
│ │ │ │ ├── Col_bones.hpp
│ │ │ │ ├── Col_meat.hpp
│ │ │ │ ├── Cube_bones.hpp
│ │ │ │ ├── Cube_meat.hpp
│ │ │ │ ├── GenCube_bones.hpp
│ │ │ │ ├── GenCube_meat.hpp
│ │ │ │ ├── Gen_bones.hpp
│ │ │ │ ├── Gen_meat.hpp
│ │ │ │ ├── GlueCube_bones.hpp
│ │ │ │ ├── GlueCube_meat.hpp
│ │ │ │ ├── Glue_bones.hpp
│ │ │ │ ├── Glue_meat.hpp
│ │ │ │ ├── Mat_bones.hpp
│ │ │ │ ├── Mat_meat.hpp
│ │ │ │ ├── OpCube_bones.hpp
│ │ │ │ ├── OpCube_meat.hpp
│ │ │ │ ├── Op_bones.hpp
│ │ │ │ ├── Op_meat.hpp
│ │ │ │ ├── Proxy.hpp
│ │ │ │ ├── ProxyCube.hpp
│ │ │ │ ├── Row_bones.hpp
│ │ │ │ ├── Row_meat.hpp
│ │ │ │ ├── SizeCube_bones.hpp
│ │ │ │ ├── SizeCube_meat.hpp
│ │ │ │ ├── SizeMat_bones.hpp
│ │ │ │ ├── SizeMat_meat.hpp
│ │ │ │ ├── SpBase_bones.hpp
│ │ │ │ ├── SpBase_meat.hpp
│ │ │ │ ├── SpCol_bones.hpp
│ │ │ │ ├── SpCol_meat.hpp
│ │ │ │ ├── SpGlue_bones.hpp
│ │ │ │ ├── SpGlue_meat.hpp
│ │ │ │ ├── SpMat_bones.hpp
│ │ │ │ ├── SpMat_iterators_meat.hpp
│ │ │ │ ├── SpMat_meat.hpp
│ │ │ │ ├── SpOp_bones.hpp
│ │ │ │ ├── SpOp_meat.hpp
│ │ │ │ ├── SpProxy.hpp
│ │ │ │ ├── SpRow_bones.hpp
│ │ │ │ ├── SpRow_meat.hpp
│ │ │ │ ├── SpSubview_bones.hpp
│ │ │ │ ├── SpSubview_iterators_meat.hpp
│ │ │ │ ├── SpSubview_meat.hpp
│ │ │ │ ├── SpValProxy_bones.hpp
│ │ │ │ ├── SpValProxy_meat.hpp
│ │ │ │ ├── access.hpp
│ │ │ │ ├── arma_boost.hpp
│ │ │ │ ├── arma_cmath.hpp
│ │ │ │ ├── arma_config.hpp
│ │ │ │ ├── arma_ostream_bones.hpp
│ │ │ │ ├── arma_ostream_meat.hpp
│ │ │ │ ├── arma_rng.hpp
│ │ │ │ ├── arma_rng_cxx11.hpp
│ │ │ │ ├── arma_rng_cxx98.hpp
│ │ │ │ ├── arma_static_check.hpp
│ │ │ │ ├── arma_version.hpp
│ │ │ │ ├── arpack_bones.hpp
│ │ │ │ ├── arpack_wrapper.hpp
│ │ │ │ ├── arrayops_bones.hpp
│ │ │ │ ├── arrayops_meat.hpp
│ │ │ │ ├── atlas_bones.hpp
│ │ │ │ ├── atlas_wrapper.hpp
│ │ │ │ ├── auxlib_bones.hpp
│ │ │ │ ├── auxlib_meat.hpp
│ │ │ │ ├── blas_bones.hpp
│ │ │ │ ├── blas_wrapper.hpp
│ │ │ │ ├── compiler_setup.hpp
│ │ │ │ ├── compiler_setup_post.hpp
│ │ │ │ ├── cond_rel_bones.hpp
│ │ │ │ ├── cond_rel_meat.hpp
│ │ │ │ ├── config.hpp
│ │ │ │ ├── config.hpp.cmake
│ │ │ │ ├── constants.hpp
│ │ │ │ ├── constants_compat.hpp
│ │ │ │ ├── debug.hpp
│ │ │ │ ├── diagmat_proxy.hpp
│ │ │ │ ├── diagview_bones.hpp
│ │ │ │ ├── diagview_meat.hpp
│ │ │ │ ├── diskio_bones.hpp
│ │ │ │ ├── diskio_meat.hpp
│ │ │ │ ├── distr_param.hpp
│ │ │ │ ├── eGlueCube_bones.hpp
│ │ │ │ ├── eGlueCube_meat.hpp
│ │ │ │ ├── eGlue_bones.hpp
│ │ │ │ ├── eGlue_meat.hpp
│ │ │ │ ├── eOpCube_bones.hpp
│ │ │ │ ├── eOpCube_meat.hpp
│ │ │ │ ├── eOp_bones.hpp
│ │ │ │ ├── eOp_meat.hpp
│ │ │ │ ├── eglue_core_bones.hpp
│ │ │ │ ├── eglue_core_meat.hpp
│ │ │ │ ├── eop_aux.hpp
│ │ │ │ ├── eop_core_bones.hpp
│ │ │ │ ├── eop_core_meat.hpp
│ │ │ │ ├── fft_engine.hpp
│ │ │ │ ├── field_bones.hpp
│ │ │ │ ├── field_meat.hpp
│ │ │ │ ├── fn_accu.hpp
│ │ │ │ ├── fn_all.hpp
│ │ │ │ ├── fn_any.hpp
│ │ │ │ ├── fn_as_scalar.hpp
│ │ │ │ ├── fn_chol.hpp
│ │ │ │ ├── fn_clamp.hpp
│ │ │ │ ├── fn_cond.hpp
│ │ │ │ ├── fn_conv.hpp
│ │ │ │ ├── fn_conv_to.hpp
│ │ │ │ ├── fn_cor.hpp
│ │ │ │ ├── fn_cov.hpp
│ │ │ │ ├── fn_cross.hpp
│ │ │ │ ├── fn_cumsum.hpp
│ │ │ │ ├── fn_det.hpp
│ │ │ │ ├── fn_diagmat.hpp
│ │ │ │ ├── fn_diagvec.hpp
│ │ │ │ ├── fn_dot.hpp
│ │ │ │ ├── fn_eig_gen.hpp
│ │ │ │ ├── fn_eig_pair.hpp
│ │ │ │ ├── fn_eig_sym.hpp
│ │ │ │ ├── fn_eigs_gen.hpp
│ │ │ │ ├── fn_eigs_sym.hpp
│ │ │ │ ├── fn_elem.hpp
│ │ │ │ ├── fn_eps.hpp
│ │ │ │ ├── fn_expmat.hpp
│ │ │ │ ├── fn_eye.hpp
│ │ │ │ ├── fn_fft.hpp
│ │ │ │ ├── fn_fft2.hpp
│ │ │ │ ├── fn_find.hpp
│ │ │ │ ├── fn_flip.hpp
│ │ │ │ ├── fn_hist.hpp
│ │ │ │ ├── fn_histc.hpp
│ │ │ │ ├── fn_inplace_strans.hpp
│ │ │ │ ├── fn_inplace_trans.hpp
│ │ │ │ ├── fn_interp1.hpp
│ │ │ │ ├── fn_inv.hpp
│ │ │ │ ├── fn_join.hpp
│ │ │ │ ├── fn_kron.hpp
│ │ │ │ ├── fn_log_det.hpp
│ │ │ │ ├── fn_lu.hpp
│ │ │ │ ├── fn_max.hpp
│ │ │ │ ├── fn_mean.hpp
│ │ │ │ ├── fn_median.hpp
│ │ │ │ ├── fn_min.hpp
│ │ │ │ ├── fn_misc.hpp
│ │ │ │ ├── fn_n_unique.hpp
│ │ │ │ ├── fn_nonzeros.hpp
│ │ │ │ ├── fn_norm.hpp
│ │ │ │ ├── fn_norm_sparse.hpp
│ │ │ │ ├── fn_normalise.hpp
│ │ │ │ ├── fn_numel.hpp
│ │ │ │ ├── fn_ones.hpp
│ │ │ │ ├── fn_pinv.hpp
│ │ │ │ ├── fn_princomp.hpp
│ │ │ │ ├── fn_prod.hpp
│ │ │ │ ├── fn_qr.hpp
│ │ │ │ ├── fn_qz.hpp
│ │ │ │ ├── fn_randg.hpp
│ │ │ │ ├── fn_randi.hpp
│ │ │ │ ├── fn_randn.hpp
│ │ │ │ ├── fn_randu.hpp
│ │ │ │ ├── fn_rank.hpp
│ │ │ │ ├── fn_repmat.hpp
│ │ │ │ ├── fn_reshape.hpp
│ │ │ │ ├── fn_resize.hpp
│ │ │ │ ├── fn_shuffle.hpp
│ │ │ │ ├── fn_size.hpp
│ │ │ │ ├── fn_solve.hpp
│ │ │ │ ├── fn_sort.hpp
│ │ │ │ ├── fn_sort_index.hpp
│ │ │ │ ├── fn_speye.hpp
│ │ │ │ ├── fn_spones.hpp
│ │ │ │ ├── fn_sprandn.hpp
│ │ │ │ ├── fn_sprandu.hpp
│ │ │ │ ├── fn_spsolve.hpp
│ │ │ │ ├── fn_stddev.hpp
│ │ │ │ ├── fn_strans.hpp
│ │ │ │ ├── fn_sum.hpp
│ │ │ │ ├── fn_svd.hpp
│ │ │ │ ├── fn_svds.hpp
│ │ │ │ ├── fn_syl_lyap.hpp
│ │ │ │ ├── fn_symmat.hpp
│ │ │ │ ├── fn_toeplitz.hpp
│ │ │ │ ├── fn_trace.hpp
│ │ │ │ ├── fn_trans.hpp
│ │ │ │ ├── fn_trig.hpp
│ │ │ │ ├── fn_trimat.hpp
│ │ │ │ ├── fn_trunc_exp.hpp
│ │ │ │ ├── fn_trunc_log.hpp
│ │ │ │ ├── fn_unique.hpp
│ │ │ │ ├── fn_var.hpp
│ │ │ │ ├── fn_vectorise.hpp
│ │ │ │ ├── fn_zeros.hpp
│ │ │ │ ├── forward_bones.hpp
│ │ │ │ ├── glue_conv_bones.hpp
│ │ │ │ ├── glue_conv_meat.hpp
│ │ │ │ ├── glue_cor_bones.hpp
│ │ │ │ ├── glue_cor_meat.hpp
│ │ │ │ ├── glue_cov_bones.hpp
│ │ │ │ ├── glue_cov_meat.hpp
│ │ │ │ ├── glue_cross_bones.hpp
│ │ │ │ ├── glue_cross_meat.hpp
│ │ │ │ ├── glue_hist_bones.hpp
│ │ │ │ ├── glue_hist_meat.hpp
│ │ │ │ ├── glue_histc_bones.hpp
│ │ │ │ ├── glue_histc_meat.hpp
│ │ │ │ ├── glue_join_bones.hpp
│ │ │ │ ├── glue_join_meat.hpp
│ │ │ │ ├── glue_kron_bones.hpp
│ │ │ │ ├── glue_kron_meat.hpp
│ │ │ │ ├── glue_max_bones.hpp
│ │ │ │ ├── glue_max_meat.hpp
│ │ │ │ ├── glue_min_bones.hpp
│ │ │ │ ├── glue_min_meat.hpp
│ │ │ │ ├── glue_mixed_bones.hpp
│ │ │ │ ├── glue_mixed_meat.hpp
│ │ │ │ ├── glue_relational_bones.hpp
│ │ │ │ ├── glue_relational_meat.hpp
│ │ │ │ ├── glue_solve_bones.hpp
│ │ │ │ ├── glue_solve_meat.hpp
│ │ │ │ ├── glue_times_bones.hpp
│ │ │ │ ├── glue_times_meat.hpp
│ │ │ │ ├── glue_toeplitz_bones.hpp
│ │ │ │ ├── glue_toeplitz_meat.hpp
│ │ │ │ ├── gmm_diag_bones.hpp
│ │ │ │ ├── gmm_diag_meat.hpp
│ │ │ │ ├── gmm_misc_bones.hpp
│ │ │ │ ├── gmm_misc_meat.hpp
│ │ │ │ ├── hdf5_bones.hpp
│ │ │ │ ├── hdf5_misc.hpp
│ │ │ │ ├── include_atlas.hpp
│ │ │ │ ├── include_hdf5.hpp
│ │ │ │ ├── include_superlu.hpp
│ │ │ │ ├── injector_bones.hpp
│ │ │ │ ├── injector_meat.hpp
│ │ │ │ ├── lapack_bones.hpp
│ │ │ │ ├── lapack_wrapper.hpp
│ │ │ │ ├── memory.hpp
│ │ │ │ ├── mtGlueCube_bones.hpp
│ │ │ │ ├── mtGlueCube_meat.hpp
│ │ │ │ ├── mtGlue_bones.hpp
│ │ │ │ ├── mtGlue_meat.hpp
│ │ │ │ ├── mtOpCube_bones.hpp
│ │ │ │ ├── mtOpCube_meat.hpp
│ │ │ │ ├── mtOp_bones.hpp
│ │ │ │ ├── mtOp_meat.hpp
│ │ │ │ ├── mtSpOp_bones.hpp
│ │ │ │ ├── mtSpOp_meat.hpp
│ │ │ │ ├── mul_gemm.hpp
│ │ │ │ ├── mul_gemm_mixed.hpp
│ │ │ │ ├── mul_gemv.hpp
│ │ │ │ ├── mul_herk.hpp
│ │ │ │ ├── mul_syrk.hpp
│ │ │ │ ├── op_all_bones.hpp
│ │ │ │ ├── op_all_meat.hpp
│ │ │ │ ├── op_any_bones.hpp
│ │ │ │ ├── op_any_meat.hpp
│ │ │ │ ├── op_chol_bones.hpp
│ │ │ │ ├── op_chol_meat.hpp
│ │ │ │ ├── op_clamp_bones.hpp
│ │ │ │ ├── op_clamp_meat.hpp
│ │ │ │ ├── op_cor_bones.hpp
│ │ │ │ ├── op_cor_meat.hpp
│ │ │ │ ├── op_cov_bones.hpp
│ │ │ │ ├── op_cov_meat.hpp
│ │ │ │ ├── op_cumsum_bones.hpp
│ │ │ │ ├── op_cumsum_meat.hpp
│ │ │ │ ├── op_cx_scalar_bones.hpp
│ │ │ │ ├── op_cx_scalar_meat.hpp
│ │ │ │ ├── op_diagmat_bones.hpp
│ │ │ │ ├── op_diagmat_meat.hpp
│ │ │ │ ├── op_diagvec_bones.hpp
│ │ │ │ ├── op_diagvec_meat.hpp
│ │ │ │ ├── op_dot_bones.hpp
│ │ │ │ ├── op_dot_meat.hpp
│ │ │ │ ├── op_dotext_bones.hpp
│ │ │ │ ├── op_dotext_meat.hpp
│ │ │ │ ├── op_expmat_bones.hpp
│ │ │ │ ├── op_expmat_meat.hpp
│ │ │ │ ├── op_fft_bones.hpp
│ │ │ │ ├── op_fft_meat.hpp
│ │ │ │ ├── op_find_bones.hpp
│ │ │ │ ├── op_find_meat.hpp
│ │ │ │ ├── op_flip_bones.hpp
│ │ │ │ ├── op_flip_meat.hpp
│ │ │ │ ├── op_hist_bones.hpp
│ │ │ │ ├── op_hist_meat.hpp
│ │ │ │ ├── op_htrans_bones.hpp
│ │ │ │ ├── op_htrans_meat.hpp
│ │ │ │ ├── op_inv_bones.hpp
│ │ │ │ ├── op_inv_meat.hpp
│ │ │ │ ├── op_max_bones.hpp
│ │ │ │ ├── op_max_meat.hpp
│ │ │ │ ├── op_mean_bones.hpp
│ │ │ │ ├── op_mean_meat.hpp
│ │ │ │ ├── op_median_bones.hpp
│ │ │ │ ├── op_median_meat.hpp
│ │ │ │ ├── op_min_bones.hpp
│ │ │ │ ├── op_min_meat.hpp
│ │ │ │ ├── op_misc_bones.hpp
│ │ │ │ ├── op_misc_meat.hpp
│ │ │ │ ├── op_nonzeros_bones.hpp
│ │ │ │ ├── op_nonzeros_meat.hpp
│ │ │ │ ├── op_normalise_bones.hpp
│ │ │ │ ├── op_normalise_meat.hpp
│ │ │ │ ├── op_pinv_bones.hpp
│ │ │ │ ├── op_pinv_meat.hpp
│ │ │ │ ├── op_princomp_bones.hpp
│ │ │ │ ├── op_princomp_meat.hpp
│ │ │ │ ├── op_prod_bones.hpp
│ │ │ │ ├── op_prod_meat.hpp
│ │ │ │ ├── op_relational_bones.hpp
│ │ │ │ ├── op_relational_meat.hpp
│ │ │ │ ├── op_repmat_bones.hpp
│ │ │ │ ├── op_repmat_meat.hpp
│ │ │ │ ├── op_reshape_bones.hpp
│ │ │ │ ├── op_reshape_meat.hpp
│ │ │ │ ├── op_resize_bones.hpp
│ │ │ │ ├── op_resize_meat.hpp
│ │ │ │ ├── op_shuffle_bones.hpp
│ │ │ │ ├── op_shuffle_meat.hpp
│ │ │ │ ├── op_sort_bones.hpp
│ │ │ │ ├── op_sort_index_bones.hpp
│ │ │ │ ├── op_sort_index_meat.hpp
│ │ │ │ ├── op_sort_meat.hpp
│ │ │ │ ├── op_stddev_bones.hpp
│ │ │ │ ├── op_stddev_meat.hpp
│ │ │ │ ├── op_strans_bones.hpp
│ │ │ │ ├── op_strans_meat.hpp
│ │ │ │ ├── op_sum_bones.hpp
│ │ │ │ ├── op_sum_meat.hpp
│ │ │ │ ├── op_symmat_bones.hpp
│ │ │ │ ├── op_symmat_meat.hpp
│ │ │ │ ├── op_toeplitz_bones.hpp
│ │ │ │ ├── op_toeplitz_meat.hpp
│ │ │ │ ├── op_trimat_bones.hpp
│ │ │ │ ├── op_trimat_meat.hpp
│ │ │ │ ├── op_unique_bones.hpp
│ │ │ │ ├── op_unique_meat.hpp
│ │ │ │ ├── op_var_bones.hpp
│ │ │ │ ├── op_var_meat.hpp
│ │ │ │ ├── op_vectorise_bones.hpp
│ │ │ │ ├── op_vectorise_meat.hpp
│ │ │ │ ├── operator_cube_div.hpp
│ │ │ │ ├── operator_cube_minus.hpp
│ │ │ │ ├── operator_cube_plus.hpp
│ │ │ │ ├── operator_cube_relational.hpp
│ │ │ │ ├── operator_cube_schur.hpp
│ │ │ │ ├── operator_cube_times.hpp
│ │ │ │ ├── operator_div.hpp
│ │ │ │ ├── operator_minus.hpp
│ │ │ │ ├── operator_ostream.hpp
│ │ │ │ ├── operator_plus.hpp
│ │ │ │ ├── operator_relational.hpp
│ │ │ │ ├── operator_schur.hpp
│ │ │ │ ├── operator_times.hpp
│ │ │ │ ├── podarray_bones.hpp
│ │ │ │ ├── podarray_meat.hpp
│ │ │ │ ├── promote_type.hpp
│ │ │ │ ├── restrictors.hpp
│ │ │ │ ├── running_stat_bones.hpp
│ │ │ │ ├── running_stat_meat.hpp
│ │ │ │ ├── running_stat_vec_bones.hpp
│ │ │ │ ├── running_stat_vec_meat.hpp
│ │ │ │ ├── sp_auxlib_bones.hpp
│ │ │ │ ├── sp_auxlib_meat.hpp
│ │ │ │ ├── span.hpp
│ │ │ │ ├── spdiagview_bones.hpp
│ │ │ │ ├── spdiagview_meat.hpp
│ │ │ │ ├── spglue_join_bones.hpp
│ │ │ │ ├── spglue_join_meat.hpp
│ │ │ │ ├── spglue_minus_bones.hpp
│ │ │ │ ├── spglue_minus_meat.hpp
│ │ │ │ ├── spglue_plus_bones.hpp
│ │ │ │ ├── spglue_plus_meat.hpp
│ │ │ │ ├── spglue_times_bones.hpp
│ │ │ │ ├── spglue_times_meat.hpp
│ │ │ │ ├── spop_htrans_bones.hpp
│ │ │ │ ├── spop_htrans_meat.hpp
│ │ │ │ ├── spop_max_bones.hpp
│ │ │ │ ├── spop_max_meat.hpp
│ │ │ │ ├── spop_mean_bones.hpp
│ │ │ │ ├── spop_mean_meat.hpp
│ │ │ │ ├── spop_min_bones.hpp
│ │ │ │ ├── spop_min_meat.hpp
│ │ │ │ ├── spop_misc_bones.hpp
│ │ │ │ ├── spop_misc_meat.hpp
│ │ │ │ ├── spop_strans_bones.hpp
│ │ │ │ ├── spop_strans_meat.hpp
│ │ │ │ ├── spop_sum_bones.hpp
│ │ │ │ ├── spop_sum_meat.hpp
│ │ │ │ ├── spop_var_bones.hpp
│ │ │ │ ├── spop_var_meat.hpp
│ │ │ │ ├── strip.hpp
│ │ │ │ ├── subview_bones.hpp
│ │ │ │ ├── subview_cube_bones.hpp
│ │ │ │ ├── subview_cube_meat.hpp
│ │ │ │ ├── subview_each_bones.hpp
│ │ │ │ ├── subview_each_meat.hpp
│ │ │ │ ├── subview_elem1_bones.hpp
│ │ │ │ ├── subview_elem1_meat.hpp
│ │ │ │ ├── subview_elem2_bones.hpp
│ │ │ │ ├── subview_elem2_meat.hpp
│ │ │ │ ├── subview_field_bones.hpp
│ │ │ │ ├── subview_field_meat.hpp
│ │ │ │ ├── subview_meat.hpp
│ │ │ │ ├── superlu_bones.hpp
│ │ │ │ ├── superlu_wrapper.hpp
│ │ │ │ ├── traits.hpp
│ │ │ │ ├── typedef_elem.hpp
│ │ │ │ ├── typedef_elem_check.hpp
│ │ │ │ ├── typedef_mat.hpp
│ │ │ │ ├── typedef_mat_fixed.hpp
│ │ │ │ ├── unwrap.hpp
│ │ │ │ ├── unwrap_cube.hpp
│ │ │ │ ├── unwrap_spmat.hpp
│ │ │ │ ├── upgrade_val.hpp
│ │ │ │ ├── wall_clock_bones.hpp
│ │ │ │ ├── wall_clock_meat.hpp
│ │ │ │ ├── xtrans_mat_bones.hpp
│ │ │ │ ├── xtrans_mat_meat.hpp
│ │ │ │ ├── xvec_htrans_bones.hpp
│ │ │ │ └── xvec_htrans_meat.hpp
│ │ │ └── src/
│ │ │ └── wrapper.cpp
│ │ ├── armanpy/
│ │ │ ├── example/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── FindNumPy.cmake
│ │ │ │ ├── example.cpp
│ │ │ │ ├── example.hpp
│ │ │ │ ├── example.i
│ │ │ │ └── example.py
│ │ │ └── include/
│ │ │ ├── armanpy.hpp
│ │ │ ├── armanpy.i
│ │ │ ├── armanpy_1d.i
│ │ │ ├── armanpy_2d.i
│ │ │ ├── armanpy_3d.i
│ │ │ └── numpy.i
│ │ ├── clipper/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── include/
│ │ │ │ └── clipper.hpp
│ │ │ └── src/
│ │ │ └── clipper.cpp
│ │ ├── easylogging/
│ │ │ └── easylogging++.h
│ │ ├── eikonal/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── include/
│ │ │ │ ├── FMM_API.h
│ │ │ │ ├── FMM_Config2d.h
│ │ │ │ ├── FMM_Config3d.h
│ │ │ │ ├── FMM_Core.h
│ │ │ │ ├── FMM_Heap.h
│ │ │ │ └── FMM_Macros.h
│ │ │ └── src/
│ │ │ ├── FMM_Core.c
│ │ │ ├── FMM_Heap.c
│ │ │ ├── FMM_eikonal2d.c
│ │ │ └── FMM_eikonal3d.c
│ │ ├── fftw3-win32/
│ │ │ ├── fftw3.f
│ │ │ ├── fftw3.f03
│ │ │ ├── fftw3.h
│ │ │ ├── fftw3l.f03
│ │ │ ├── fftw3q.f03
│ │ │ ├── libfftw3-3.def
│ │ │ ├── libfftw3.a
│ │ │ ├── libfftw3f-3.def
│ │ │ └── libfftw3l-3.def
│ │ ├── fourier/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── include/
│ │ │ │ ├── basics.h
│ │ │ │ ├── fourier.h
│ │ │ │ └── primes.h
│ │ │ ├── src/
│ │ │ │ ├── check.c
│ │ │ │ ├── fourier.c
│ │ │ │ └── primes.c
│ │ │ └── tools/
│ │ │ └── generate_twiddles.m
│ │ └── kissfft/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ ├── _kiss_fft_guts.h
│ │ │ ├── kiss_fft.h
│ │ │ └── kiss_fftnd.h
│ │ └── src/
│ │ ├── kiss_fft.c
│ │ └── kiss_fftnd.c
│ ├── optolithiumc.i
│ ├── plugins/
│ │ ├── CMakeLists.txt
│ │ └── src/
│ │ ├── dev_models/
│ │ │ ├── enhanced.c
│ │ │ ├── enhanced_notch.c
│ │ │ ├── mack.c
│ │ │ ├── notch.c
│ │ │ └── notch_depth.c
│ │ ├── masks/
│ │ │ ├── fiveBarLine.c
│ │ │ ├── line1D.c
│ │ │ ├── line1D_SRAF.c
│ │ │ └── space1D.c
│ │ ├── pupil_filters/
│ │ │ └── central_obscuration.c
│ │ └── source_shapes/
│ │ ├── annular.c
│ │ ├── coherent.c
│ │ └── convenient.c
│ └── src/
│ ├── opl_capi.cpp
│ ├── opl_contours.cpp
│ ├── opl_geometry.cpp
│ ├── opl_interp.cpp
│ ├── opl_log.cpp
│ └── opl_sim.cpp
├── OptolithiumGui/
│ ├── auxmath.py
│ ├── config.py
│ ├── core.py
│ ├── database/
│ │ ├── Enum.py
│ │ ├── __init__.py
│ │ ├── base.py
│ │ ├── common.py
│ │ ├── dbparser.py
│ │ ├── orm.py
│ │ └── settings.py
│ ├── helpers.py
│ ├── info.py
│ ├── main.py
│ ├── matplotlibrc
│ ├── metrics.py
│ ├── mpl-data/
│ │ ├── fonts/
│ │ │ ├── afm/
│ │ │ │ ├── cmex10.afm
│ │ │ │ ├── cmmi10.afm
│ │ │ │ ├── cmr10.afm
│ │ │ │ ├── cmsy10.afm
│ │ │ │ ├── cmtt10.afm
│ │ │ │ ├── pagd8a.afm
│ │ │ │ ├── pagdo8a.afm
│ │ │ │ ├── pagk8a.afm
│ │ │ │ ├── pagko8a.afm
│ │ │ │ ├── pbkd8a.afm
│ │ │ │ ├── pbkdi8a.afm
│ │ │ │ ├── pbkl8a.afm
│ │ │ │ ├── pbkli8a.afm
│ │ │ │ ├── pcrb8a.afm
│ │ │ │ ├── pcrbo8a.afm
│ │ │ │ ├── pcrr8a.afm
│ │ │ │ ├── pcrro8a.afm
│ │ │ │ ├── phvb8a.afm
│ │ │ │ ├── phvb8an.afm
│ │ │ │ ├── phvbo8a.afm
│ │ │ │ ├── phvbo8an.afm
│ │ │ │ ├── phvl8a.afm
│ │ │ │ ├── phvlo8a.afm
│ │ │ │ ├── phvr8a.afm
│ │ │ │ ├── phvr8an.afm
│ │ │ │ ├── phvro8a.afm
│ │ │ │ ├── phvro8an.afm
│ │ │ │ ├── pncb8a.afm
│ │ │ │ ├── pncbi8a.afm
│ │ │ │ ├── pncr8a.afm
│ │ │ │ ├── pncri8a.afm
│ │ │ │ ├── pplb8a.afm
│ │ │ │ ├── pplbi8a.afm
│ │ │ │ ├── pplr8a.afm
│ │ │ │ ├── pplri8a.afm
│ │ │ │ ├── psyr.afm
│ │ │ │ ├── ptmb8a.afm
│ │ │ │ ├── ptmbi8a.afm
│ │ │ │ ├── ptmr8a.afm
│ │ │ │ ├── ptmri8a.afm
│ │ │ │ ├── putb8a.afm
│ │ │ │ ├── putbi8a.afm
│ │ │ │ ├── putr8a.afm
│ │ │ │ ├── putri8a.afm
│ │ │ │ ├── pzcmi8a.afm
│ │ │ │ └── pzdr.afm
│ │ │ ├── pdfcorefonts/
│ │ │ │ ├── Courier-Bold.afm
│ │ │ │ ├── Courier-BoldOblique.afm
│ │ │ │ ├── Courier-Oblique.afm
│ │ │ │ ├── Courier.afm
│ │ │ │ ├── Helvetica-Bold.afm
│ │ │ │ ├── Helvetica-BoldOblique.afm
│ │ │ │ ├── Helvetica-Oblique.afm
│ │ │ │ ├── Helvetica.afm
│ │ │ │ ├── Symbol.afm
│ │ │ │ ├── Times-Bold.afm
│ │ │ │ ├── Times-BoldItalic.afm
│ │ │ │ ├── Times-Italic.afm
│ │ │ │ ├── Times-Roman.afm
│ │ │ │ └── ZapfDingbats.afm
│ │ │ └── ttf/
│ │ │ └── LICENSE_STIX
│ │ ├── images/
│ │ │ ├── back.ppm
│ │ │ ├── back.xpm
│ │ │ ├── filesave.ppm
│ │ │ ├── filesave.xpm
│ │ │ ├── forward.ppm
│ │ │ ├── forward.xpm
│ │ │ ├── hand.ppm
│ │ │ ├── hand.xpm
│ │ │ ├── home.ppm
│ │ │ ├── home.xpm
│ │ │ ├── move.ppm
│ │ │ ├── move.xpm
│ │ │ ├── stock_close.ppm
│ │ │ ├── stock_close.xpm
│ │ │ ├── stock_down.ppm
│ │ │ ├── stock_down.xpm
│ │ │ ├── stock_left.ppm
│ │ │ ├── stock_left.xpm
│ │ │ ├── stock_refresh.ppm
│ │ │ ├── stock_refresh.xpm
│ │ │ ├── stock_right.ppm
│ │ │ ├── stock_right.xpm
│ │ │ ├── stock_save_as.ppm
│ │ │ ├── stock_save_as.xpm
│ │ │ ├── stock_up.ppm
│ │ │ ├── stock_up.xpm
│ │ │ ├── stock_zoom-in.ppm
│ │ │ ├── stock_zoom-in.xpm
│ │ │ ├── stock_zoom-out.ppm
│ │ │ ├── stock_zoom-out.xpm
│ │ │ ├── subplots.ppm
│ │ │ ├── subplots.xpm
│ │ │ ├── zoom_to_rect.ppm
│ │ │ └── zoom_to_rect.xpm
│ │ └── lineprops.glade
│ ├── options/
│ │ ├── __init__.py
│ │ ├── common.py
│ │ └── structures.py
│ ├── optolithium.py
│ ├── pcpi.py
│ ├── physc.py
│ ├── plugins.py
│ ├── qt.py
│ ├── resources.py
│ ├── setup.py
│ ├── share/
│ │ ├── data/
│ │ │ ├── Air-Vacuum.MAT
│ │ │ ├── Si Dioxide.MAT
│ │ │ ├── Si Nitride.MAT
│ │ │ ├── Silicon.MAT
│ │ │ ├── a-Polysilicon.MAT
│ │ │ ├── fivebar.MSK
│ │ │ └── i-line.res
│ │ └── misc/
│ │ ├── magic
│ │ └── magic.mgc
│ ├── views/
│ │ ├── __init__.py
│ │ ├── appconfig.py
│ │ ├── common.py
│ │ ├── controls.py
│ │ ├── dbview.py
│ │ ├── development.py
│ │ ├── diffraction.py
│ │ ├── exposure.py
│ │ ├── imaging.py
│ │ ├── mask.py
│ │ ├── metrology.py
│ │ ├── numerics.py
│ │ ├── peb.py
│ │ ├── resist.py
│ │ ├── sets.py
│ │ ├── simulations.py
│ │ ├── summary.py
│ │ └── wafer.py
│ └── xhtml/
│ └── report.xhtml
├── README.md
└── installer/
├── GPL-V2.rtf
└── Optolithium.aip
================================================
FILE CONTENTS
================================================
================================================
FILE: .hgignore
================================================
syntax: glob
OptolithiumGui/icons/.DS_Store
OptolithiumGui/database/.DS_Store
.DS_Store
OptolithiumC/.idea/*
OptolithiumC/.settings/*
OptolithiumC/.cproject
OptolithiumC/.project
OptolithiumGui/.idea/*
OptolithiumGui/.project
OptolithiumC/build/*
OptolithiumC/CMakeFiles/*
OptolithiumC/plugins/CMakeFiles/*
OptolithiumC/plugins/build/*
OptolithiumGui/_clipper.so
OptolithiumGui/_optolithiumc.so
OptolithiumC/plugins/cmake_install.cmake
OptolithiumC/plugins/Makefile
OptolithiumC/liboptolithiumc.a
OptolithiumC/cmake_install.cmake
OptolithiumGui/clipper.py
OptolithiumC/CMakeCache.txt
OptolithiumC/Makefile
OptolithiumGui/optolithiumc.py
OptolithiumGui/*.pyc
OptolithiumGui/database/*.pyc
OptolithiumGui/options/*.pyc
OptolithiumGui/views/*.pyc
OptolithiumC/libs/clipper/CMakeFiles/*
OptolithiumC/libs/eikonal/CMakeFiles/*
OptolithiumC/libs/kissfft/CMakeFiles/*
OptolithiumC/install_manifest.txt
OptolithiumC/libs/clipper/Makefile
OptolithiumC/libs/clipper/cmake_install.cmake
OptolithiumC/libs/clipper/libpolyclipping.a
OptolithiumC/libs/eikonal/Makefile
OptolithiumC/libs/eikonal/cmake_install.cmake
OptolithiumC/libs/eikonal/libeikonal.a
OptolithiumC/libs/kissfft/Makefile
OptolithiumC/libs/kissfft/cmake_install.cmake
OptolithiumC/libs/kissfft/libkissfft.a
OptolithiumGui/logs/myeasylog.log
OptolithiumGui/test/*
OptolithiumC/libs/fourier/CMakeFiles/*
OptolithiumC/libs/fourier/libfourier.a
OptolithiumC/libs/fourier/cmake_install.cmake
OptolithiumC/libs/fourier/Makefile
OptolithiumC/libs/fourier/check
OptolithiumGui/logs/*
OptolithiumGui/plugins/dev_models/*.dylib
OptolithiumGui/plugins/masks/*.dylib
OptolithiumGui/plugins/source_shapes/*.dylib
OptolithiumGui/plugins/pupil_filters/*.dylib
OptolithiumGui/*.db
OptolithiumC/plugins/*.dll
OptolithiumC/plugins/*.dll.a
OptolithiumGui/build/*
OptolithiumGui/plugins/*
OptolithiumGui/_optolithiumc.pyd
OptolithiumGui/_clipper.pyd
OptolithiumC/_optolithiumc.pyd
OptolithiumC/_clipper.pyd
installer/Optolithium-cache/*
installer/Optolithium-SetupFiles/*
================================================
FILE: COPYRIGHT
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
================================================
FILE: LICENSE.TXT
================================================
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License.
================================================
FILE: OptolithiumC/CMakeLists.txt
================================================
PROJECT("optolithiumc")
CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
CMAKE_POLICY(SET CMP0015 NEW)
SET(CMAKE_USE_RELATIVE_PATHS ON)
SET(CMAKE_SKIP_RPATH TRUE)
SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
SET(OPTOLITHIUMGUI_DIR "${CMAKE_HOME_DIRECTORY}/../OptolithiumGui")
SET(CMAKE_MODULE_PATH "${CMAKE_HOME_DIRECTORY}")
# SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${OPTOLITHIUMGUI_DIR}")
# SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${OPTOLITHIUMGUI_DIR}")
SET(OPTOLITHIUMC_DIR "src")
SET(LIBRARIES_DIR "libs")
SET(OPTOLITHIUMC_USE_FFTW_LIBRARY "ON")
# SET(OPTOLITHIUMC_USE_KISSFFT_LIBRARY "ON")
# SET(OPTOLITHIUMC_USE_FOURIER_LIBRARY "ON")
SET(EIKONAL_DIR "${LIBRARIES_DIR}/eikonal")
SET(CLIPPER_DIR "${LIBRARIES_DIR}/clipper")
SET(KISSFFT_DIR "${LIBRARIES_DIR}/kissfft")
SET(FOURIER_DIR "${LIBRARIES_DIR}/fourier")
ADD_DEFINITIONS(-DARMA_NO_DEBUG)
ADD_DEFINITIONS(-D_ELPP_DISABLE_PERFORMANCE_TRACKING)
ADD_DEFINITIONS(-D__NO_MINGW_LFS)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -include cmath -std=gnu++11 -Wall")
SET(ARMADILLO_INCLUDE_DIR "${LIBRARIES_DIR}/armadillo/include/")
SET(ARMANPY_INCLUDE_DIR "${LIBRARIES_DIR}/armanpy/include")
SET(EASYLOGGING_INCLUDE_DIR "${LIBRARIES_DIR}/easylogging")
SET(EIKONAL_INCLUDE_DIR "${EIKONAL_DIR}/include")
SET(CLIPPER_INCLUDE_DIR "${CLIPPER_DIR}/include")
SET(CMAKE_BUILD_TYPE "Release")
FIND_PACKAGE(Threads REQUIRED)
FIND_PACKAGE(SWIG REQUIRED)
FIND_PACKAGE(PythonLibs 2.7 REQUIRED)
FIND_PACKAGE(NumPy REQUIRED)
IF (DEFINED OPTOLITHIUMC_USE_FFTW_LIBRARY)
IF (WIN32)
SET(FFTW_DIR "${LIBRARIES_DIR}/fftw3-win32")
INCLUDE_DIRECTORIES(${FFTW_DIR})
ELSE()
FIND_PACKAGE(FFTW REQUIRED)
INCLUDE_DIRECTORIES("${FFTW_INCLUDES}")
ENDIF()
ELSEIF (DEFINED OPTOLITHIUMC_USE_KISSFFT_LIBRARY)
ADD_SUBDIRECTORY(${KISSFFT_DIR})
INCLUDE_DIRECTORIES("${KISSFFT_DIR}/include")
ELSEIF (DEFINED OPTOLITHIUMC_USE_FOURIER_LIBRARY)
ADD_SUBDIRECTORY(${FOURIER_DIR})
INCLUDE_DIRECTORIES("${FOURIER_DIR}/include")
ENDIF()
INCLUDE("${SWIG_USE_FILE}")
INCLUDE_DIRECTORIES("include")
INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}")
INCLUDE_DIRECTORIES("${PYTHON_INCLUDE_DIR}")
INCLUDE_DIRECTORIES("${ARMADILLO_INCLUDE_DIR}")
INCLUDE_DIRECTORIES("${ARMANPY_INCLUDE_DIR}")
INCLUDE_DIRECTORIES("${NUMPY_INCLUDE_DIRS}")
INCLUDE_DIRECTORIES("${EASYLOGGING_INCLUDE_DIR}")
INCLUDE_DIRECTORIES("${EIKONAL_INCLUDE_DIR}")
INCLUDE_DIRECTORIES("${CLIPPER_INCLUDE_DIR}")
ADD_SUBDIRECTORY("${EIKONAL_DIR}")
ADD_SUBDIRECTORY("${CLIPPER_DIR}")
ADD_SUBDIRECTORY("plugins")
# build the optolithiumc library
ADD_LIBRARY(optolithiumc STATIC
"${OPTOLITHIUMC_DIR}/opl_log.cpp"
"${OPTOLITHIUMC_DIR}/opl_geometry.cpp"
"${OPTOLITHIUMC_DIR}/opl_contours.cpp"
"${OPTOLITHIUMC_DIR}/opl_interp.cpp"
"${OPTOLITHIUMC_DIR}/opl_capi.cpp"
"${OPTOLITHIUMC_DIR}/opl_sim.cpp"
)
LINK_DIRECTORIES("${CLIPPER_DIR}")
TARGET_LINK_LIBRARIES(optolithiumc "eikonal")
IF (DEFINED OPTOLITHIUMC_USE_FFTW_LIBRARY)
IF (WIN32)
LINK_DIRECTORIES("${FFTW_DIR}")
TARGET_LINK_LIBRARIES(optolithiumc "fftw3")
ELSE()
TARGET_LINK_LIBRARIES(optolithiumc ${FFTW_LIBRARIES})
ENDIF()
ADD_DEFINITIONS(-DOPTOLITHIUMC_USE_FFTW_LIBRARY)
ELSEIF (DEFINED OPTOLITHIUMC_USE_KISSFFT_LIBRARY)
TARGET_LINK_LIBRARIES(optolithiumc "kissfft")
ADD_DEFINITIONS(-DOPTOLITHIUMC_USE_KISSFFT_LIBRARY)
ELSEIF (DEFINED OPTOLITHIUMC_USE_FOURIER_LIBRARY)
TARGET_LINK_LIBRARIES(optolithiumc "fourier")
ADD_DEFINITIONS(-DOPTOLITHIUMC_USE_FOURIER_LIBRARY)
ENDIF()
# Swig shall but all stuff to the same directory where the *.so or *.pyd are placed
SET(CMAKE_SWIG_OUTDIR "${CMAKE_HOME_DIRECTORY}/build/")
# Set up the swig wrapper for optolithiumc
SET_SOURCE_FILES_PROPERTIES(optolithiumc.i PROPERTIES CPLUSPLUS ON)
SET_SOURCE_FILES_PROPERTIES(optolithiumc.i PROPERTIES SWIG_FLAGS "-ignoremissing;-w509")
SWIG_ADD_MODULE(optolithiumc python optolithiumc.i)
SWIG_LINK_LIBRARIES(optolithiumc optolithiumc ${PYTHON_LIBRARIES})
# Set up the swig wrapper for clipper
SET_SOURCE_FILES_PROPERTIES(clipper.i PROPERTIES CPLUSPLUS ON)
SET_SOURCE_FILES_PROPERTIES(clipper.i PROPERTIES SWIG_FLAGS "-ignoremissing;-w509")
SWIG_ADD_MODULE(clipper python clipper.i)
SWIG_LINK_LIBRARIES(clipper polyclipping ${PYTHON_LIBRARIES})
# Install stage
INSTALL(FILES "${CMAKE_SWIG_OUTDIR}/optolithiumc.py" DESTINATION "${OPTOLITHIUMGUI_DIR}")
INSTALL(FILES "${CMAKE_SWIG_OUTDIR}/clipper.py" DESTINATION "${OPTOLITHIUMGUI_DIR}")
INSTALL(TARGETS _optolithiumc _clipper LIBRARY DESTINATION "${OPTOLITHIUMGUI_DIR}")
INSTALL(TARGETS _optolithiumc _clipper LIBRARY DESTINATION "${CMAKE_HOME_DIRECTORY}/build")
# ADD_CUSTOM_COMMAND(TARGET _optolithiumc PRE_BUILD
# COMMAND ${CMAKE_COMMAND} -E remove ${CMAKE_HOME_DIRECTORY}/build/optolithiumcPYTHON_wrap.cxx
# COMMAND ${CMAKE_COMMAND} -E remove "${OPTOLITHIUMGUI_DIR}/optolithiumc.py"
# )
# ADD_CUSTOM_COMMAND(TARGET _clipper PRE_BUILD
# COMMAND ${CMAKE_COMMAND} -E remove ${CMAKE_HOME_DIRECTORY}/build/clipperPYTHON_wrap.cxx
# COMMAND ${CMAKE_COMMAND} -E remove "${OPTOLITHIUMGUI_DIR}/clipper.py"
# )
================================================
FILE: OptolithiumC/FindFFTW.cmake
================================================
# - Find FFTW
# Find the native FFTW includes and library
#
# FFTW_INCLUDES - where to find fftw3.h
# FFTW_LIBRARIES - List of libraries when using FFTW.
# FFTW_FOUND - True if FFTW found.
if (FFTW_INCLUDES)
# Already in cache, be silent
set (FFTW_FIND_QUIETLY TRUE )
endif (FFTW_INCLUDES)
find_path (FFTW_INCLUDES fftw3.h)
find_library (FFTW_LIBRARIES NAMES fftw3)
# handle the QUIETLY and REQUIRED arguments and set FFTW_FOUND to TRUE if
# all listed variables are TRUE
include (FindPackageHandleStandardArgs)
find_package_handle_standard_args (FFTW DEFAULT_MSG FFTW_LIBRARIES FFTW_INCLUDES)
mark_as_advanced (FFTW_LIBRARIES FFTW_INCLUDES)
================================================
FILE: OptolithiumC/FindNumPy.cmake
================================================
# - Find the NumPy libraries
# This module finds if NumPy is installed, and sets the following variables
# indicating where it is.
#
# TODO: Update to provide the libraries and paths for linking npymath lib.
#
# NUMPY_FOUND - was NumPy found
# NUMPY_VERSION - the version of NumPy found as a string
# NUMPY_VERSION_MAJOR - the major version number of NumPy
# NUMPY_VERSION_MINOR - the minor version number of NumPy
# NUMPY_VERSION_PATCH - the patch version number of NumPy
# NUMPY_VERSION_DECIMAL - e.g. version 1.6.1 is 10601
# NUMPY_INCLUDE_DIRS - path to the NumPy include files
#============================================================================
# Copyright 2012 Continuum Analytics, Inc.
#
# MIT License
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to permit
# persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
#
#============================================================================
# Finding NumPy involves calling the Python interpreter
if(NumPy_FIND_REQUIRED)
find_package(PythonInterp REQUIRED)
else()
find_package(PythonInterp)
endif()
if(NOT PYTHONINTERP_FOUND)
set(NUMPY_FOUND FALSE)
return()
endif()
execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
"import numpy as n; print(n.__version__); print(n.get_include());"
RESULT_VARIABLE _NUMPY_SEARCH_SUCCESS
OUTPUT_VARIABLE _NUMPY_VALUES_OUTPUT
ERROR_VARIABLE _NUMPY_ERROR_VALUE
OUTPUT_STRIP_TRAILING_WHITESPACE)
if(NOT _NUMPY_SEARCH_SUCCESS MATCHES 0)
if(NumPy_FIND_REQUIRED)
message(FATAL_ERROR
"NumPy import failure:\n${_NUMPY_ERROR_VALUE}")
endif()
set(NUMPY_FOUND FALSE)
return()
endif()
# Convert the process output into a list
string(REGEX REPLACE ";" "\\\\;" _NUMPY_VALUES ${_NUMPY_VALUES_OUTPUT})
string(REGEX REPLACE "\n" ";" _NUMPY_VALUES ${_NUMPY_VALUES})
# Just in case there is unexpected output from the Python command.
list(GET _NUMPY_VALUES -2 NUMPY_VERSION)
list(GET _NUMPY_VALUES -1 NUMPY_INCLUDE_DIRS)
string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" _VER_CHECK "${NUMPY_VERSION}")
if("${_VER_CHECK}" STREQUAL "")
# The output from Python was unexpected. Raise an error always
# here, because we found NumPy, but it appears to be corrupted somehow.
message(FATAL_ERROR
"Requested version and include path from NumPy, got instead:\n${_NUMPY_VALUES_OUTPUT}\n")
return()
endif()
# Make sure all directory separators are '/'
string(REGEX REPLACE "\\\\" "/" NUMPY_INCLUDE_DIRS ${NUMPY_INCLUDE_DIRS})
# Get the major and minor version numbers
string(REGEX REPLACE "\\." ";" _NUMPY_VERSION_LIST ${NUMPY_VERSION})
list(GET _NUMPY_VERSION_LIST 0 NUMPY_VERSION_MAJOR)
list(GET _NUMPY_VERSION_LIST 1 NUMPY_VERSION_MINOR)
list(GET _NUMPY_VERSION_LIST 2 NUMPY_VERSION_PATCH)
string(REGEX MATCH "[0-9]*" NUMPY_VERSION_PATCH ${NUMPY_VERSION_PATCH})
math(EXPR NUMPY_VERSION_DECIMAL
"(${NUMPY_VERSION_MAJOR} * 10000) + (${NUMPY_VERSION_MINOR} * 100) + ${NUMPY_VERSION_PATCH}")
find_package_message(NUMPY
"Found NumPy: version \"${NUMPY_VERSION}\" ${NUMPY_INCLUDE_DIRS}"
"${NUMPY_INCLUDE_DIRS}${NUMPY_VERSION}")
set(NUMPY_FOUND TRUE)
================================================
FILE: OptolithiumC/clipper.i
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
%module clipper
%{
#include "clipper.hpp"
%}
%include <std_vector.i>
%include "clipper.hpp"
%template(Path) std::vector<ClipperLib::IntPoint>;
%template(Paths) std::vector<ClipperLib::Path>;
namespace ClipperLib {
%pythoncode %{
def merge(polygons, fillType=pftNonZero):
result = Paths()
c = Clipper();
# c.ForceSimple = True
for polygon in polygons:
path = Path([IntPoint(*p) for p in polygon])
c.AddPath(path, ptSubject, True);
c.Execute(ctUnion, result, fillType, fillType)
return [[(point.X, point.Y) for point in polygon] for polygon in polygons]
%}
}
================================================
FILE: OptolithiumC/examples/aerial_image_various_source_shapes.py
================================================
__author__ = 'OlaPsema'
import optolithiumc as oplc
import numpy as np
import matplotlib.pyplot as plt
def get_quasar_source_shape_model(x, y, sigma_in, sigma_out, blade_angle):
xv, yv = np.meshgrid(x, y)
if blade_angle <= 90.:
blade_angle = (90. + blade_angle) / 2.
cond3 = np.abs(yv) <= np.abs(np.tan(np.deg2rad(blade_angle)) * x)
cond4 = np.abs(xv) <= np.abs(np.tan(np.deg2rad(blade_angle)) * np.transpose(np.array([y])))
else:
cond3 = cond4 = 1
cond1 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) <= sigma_out ** 2
cond2 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) >= sigma_in ** 2
val = np.array(cond1 & cond2 & cond3 & cond4, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_conventional_coherent_source_shape_model(step, x, y):
xv, yv = np.meshgrid(x, y)
val = np.array(((xv - 0.) ** 2 + (yv - 0.) ** 2) <= (step / 10.) ** 2, dtype=float)
plt.imshow(val)
plt.show()
return np.asfortranarray(val)
def get_conventional_partially_coherent_source_shape_model(x, y, sigma):
xv, yv = np.meshgrid(x, y)
cond = ((xv - 0.) ** 2 + (yv - 0.) ** 2) <= sigma ** 2
val = np.array(cond, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_annular_source_shape_model(x, y, sigma_in, sigma_out):
xv, yv = np.meshgrid(x, y)
cond1 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) <= sigma_out ** 2
cond2 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) >= sigma_in ** 2
val = np.array(cond1 & cond2, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_dipole_source_shape_model(x, y, center_sigma, radius_sigma):
xv, yv = np.meshgrid(x, y)
cond1 = ((xv - center_sigma) ** 2 + (yv - 0.) ** 2) <= radius_sigma ** 2
cond2 = ((xv + center_sigma) ** 2 + (yv - 0.) ** 2) <= radius_sigma ** 2
val = np.array(cond1 | cond2, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_monopole_source_shape_model(x, y, center_x, center_y, radius_sigma):
xv, yv = np.meshgrid(x, y)
cond1 = ((xv - center_x) ** 2 + (yv + center_y) ** 2) <= radius_sigma ** 2
val = np.array(cond1, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_quadrupole_source_shape_model(x, y, center_sigma, radius_sigma, geometry_type):
xv, yv = np.meshgrid(x, y)
if geometry_type == 1:
center_sigma = center_sigma * np.sqrt(1. / 2.)
cond1 = ((xv - center_sigma) ** 2 + (yv - center_sigma) ** 2) <= radius_sigma ** 2
cond2 = ((xv - center_sigma) ** 2 + (yv + center_sigma) ** 2) <= radius_sigma ** 2
cond3 = ((xv + center_sigma) ** 2 + (yv - center_sigma) ** 2) <= radius_sigma ** 2
cond4 = ((xv + center_sigma) ** 2 + (yv + center_sigma) ** 2) <= radius_sigma ** 2
else:
cond1 = ((xv - center_sigma) ** 2 + (yv - 0.) ** 2) <= radius_sigma ** 2
cond2 = ((xv + center_sigma) ** 2 + (yv + 0.) ** 2) <= radius_sigma ** 2
cond3 = ((xv - 0.) ** 2 + (yv - center_sigma) ** 2) <= radius_sigma ** 2
cond4 = ((xv - 0.) ** 2 + (yv + center_sigma) ** 2) <= radius_sigma ** 2
val = np.array(cond1 | cond2 | cond3 | cond4, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_shrinc_source_shape_model(x, y, sigma_out, stripe_width):
xv, yv = np.meshgrid(x, y)
cond1 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) <= sigma_out ** 2
cond2 = np.abs(yv) >= stripe_width/2.
cond3 = np.abs(xv) >= stripe_width/2.
val = np.array(cond1 & cond2 & cond3, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_square_source_shape_model(x, y, half_width_sigma):
xv, yv = np.meshgrid(x, y)
cond1 = np.abs(yv) <= half_width_sigma
cond2 = np.abs(xv) <= half_width_sigma
val = np.array(cond1 & cond2, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
class AerialImage(object):
def __init__(self):
# setting pattern properties:
# example: pattern with 1 feature _I_
self.featureWidth = 240. # nm
self.pitch = 600. # nm
self.featureTransmittance = 0. # from 0. to 1.
self.maskTransmittance = 1. # from 0. to 1.
self.featurePhase = 0.
self.maskPhase = 0.
self.wavelength = 365.0 # nanometers
self.numericalAperture = 0.9
self.reductionRatio = 1.0
self.flare = 0.
self.immersion = 0.
self.focus = 0.
self.nominalDose = 145 # mJ/cm^2
self.correctable = 0.5
self.sourceStep = 0.01
self.maskStep = 5.
self.sourceShapeType = 6
# 1 - conventional coherent
# 3 - conventional partially coherent
# 4 - dipole
# 5 - monopole
# 6 - quadrupole
# 7 - quasar
# 8 - shrinc
# 9 - square
# 10 - annular
self.aerial_image_formation()
def source_shape_model_choice(self, x, y):
if self.sourceShapeType == 1:
return get_conventional_coherent_source_shape_model(self.sourceStep, x, y)
elif self.sourceShapeType == 3:
return get_conventional_partially_coherent_source_shape_model(x, y, sigma=0.5)
elif self.sourceShapeType == 4:
return get_dipole_source_shape_model(x, y, center_sigma=0.5, radius_sigma=0.3)
elif self.sourceShapeType == 5:
return get_monopole_source_shape_model(x, y, center_x=0.5, center_y=0.3, radius_sigma=0.2)
elif self.sourceShapeType == 6:
# types:
# 1 - Normal (90deg)
# 2 - Cross (45deg)
return get_quadrupole_source_shape_model(x, y, center_sigma=0.5, radius_sigma=0.2, geometry_type=1)
elif self.sourceShapeType == 7:
return get_quasar_source_shape_model(x, y, sigma_in=0.4, sigma_out=0.8, blade_angle=60.)
elif self.sourceShapeType == 8:
return get_shrinc_source_shape_model(x, y, sigma_out=0.8, stripe_width=0.2)
elif self.sourceShapeType == 9:
return get_square_source_shape_model(x, y, half_width_sigma=0.5)
elif self.sourceShapeType == 10:
return get_annular_source_shape_model(x, y, sigma_in=0.4, sigma_out=0.8)
else:
raise ValueError("Wrong source shape id")
def aerial_image_formation(self):
core_logging = oplc.OptolithiumCoreLog()
core_logging.set_verbose_level(0)
# feature formation
point1 = oplc.Point2d(-self.featureWidth / 2., 0.)
point2 = oplc.Point2d(self.featureWidth / 2., 0.)
points_array = oplc.Points2dArray((point1, point2))
region = oplc.Region(points_array, self.featureTransmittance, self.featurePhase)
region_array = (region, )
# repeatable part formation
point1 = oplc.Point2d(-self.pitch / 2., 0.)
point2 = oplc.Point2d(self.pitch / 2., 0.)
box = oplc.Box(point1, point2, self.maskTransmittance, self.maskPhase)
# mask formation
mask = oplc.Mask(region_array, box)
# source calculation
points_count = int(2 / self.sourceStep) + 1
nx, ny = (points_count, points_count)
x = np.linspace(-1, 1, nx)
y = np.linspace(-1, 1, ny)
x = np.round(x/self.sourceStep)*self.sourceStep
y = np.round(y/self.sourceStep)*self.sourceStep
values = self.source_shape_model_choice(x, y)
source_shape_model_sheet = oplc.SourceShapeModelSheet(x, y, values)
source_shape = oplc.SourceShape(source_shape_model_sheet, self.sourceStep, self.sourceStep)
pupil_filter_model = oplc.PupilFilterModelEmpty()
imaging_tool = oplc.ImagingTool(source_shape, pupil_filter_model, self.wavelength, self.numericalAperture,
self.reductionRatio, self.flare, self.immersion)
diffraction = oplc.diffraction(imaging_tool, mask)
exposure = oplc.Exposure(self.focus, self.nominalDose, self.correctable)
optical_transfer_function = oplc.OpticalTransferFunction(imaging_tool, exposure, None)
aerial_image = oplc.aerial_image(diffraction, optical_transfer_function, self.maskStep)
plt.plot(aerial_image.x, aerial_image.values[0])
plt.show()
with open("results.txt", 'w') as f:
for i in range(len(aerial_image.x)):
f.write('%f' % aerial_image.x[i])
f.write("\t")
f.write('%f' % aerial_image.values[0][i])
f.write("\n")
def main():
AerialImage()
if __name__ == "__main__":
main()
================================================
FILE: OptolithiumC/examples/resist_images_and_contours.py
================================================
__author__ = 'OlaPsema'
import optolithiumc as oplc
import numpy as np
import matplotlib.pyplot as plt
def get_quasar_source_shape_model(x, y, sigma_in, sigma_out, blade_angle):
xv, yv = np.meshgrid(x, y)
if blade_angle <= 90.:
blade_angle = (90. + blade_angle) / 2.
cond3 = np.abs(yv) <= np.abs(np.tan(np.deg2rad(blade_angle)) * x)
cond4 = np.abs(xv) <= np.abs(np.tan(np.deg2rad(blade_angle)) * np.transpose(np.array([y])))
else:
cond3 = cond4 = 1
cond1 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) <= sigma_out ** 2
cond2 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) >= sigma_in ** 2
val = np.array(cond1 & cond2 & cond3 & cond4, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_conventional_coherent_source_shape_model(step, x, y):
xv, yv = np.meshgrid(x, y)
val = np.array(((xv - 0.) ** 2 + (yv - 0.) ** 2) <= (step / 10.) ** 2, dtype=float)
plt.imshow(val)
plt.show()
return np.asfortranarray(val)
def get_conventional_partially_coherent_source_shape_model(x, y, sigma):
xv, yv = np.meshgrid(x, y)
cond = ((xv - 0.) ** 2 + (yv - 0.) ** 2) <= sigma ** 2
val = np.array(cond, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_annular_source_shape_model(x, y, sigma_in, sigma_out):
xv, yv = np.meshgrid(x, y)
cond1 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) <= sigma_out ** 2
cond2 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) >= sigma_in ** 2
val = np.array(cond1 & cond2, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_dipole_source_shape_model(x, y, center_sigma, radius_sigma):
xv, yv = np.meshgrid(x, y)
cond1 = ((xv - center_sigma) ** 2 + (yv - 0.) ** 2) <= radius_sigma ** 2
cond2 = ((xv + center_sigma) ** 2 + (yv - 0.) ** 2) <= radius_sigma ** 2
val = np.array(cond1 | cond2, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_monopole_source_shape_model(x, y, center_x, center_y, radius_sigma):
xv, yv = np.meshgrid(x, y)
cond1 = ((xv - center_x) ** 2 + (yv + center_y) ** 2) <= radius_sigma ** 2
val = np.array(cond1, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_quadrupole_source_shape_model(x, y, center_sigma, radius_sigma, geometry_type):
xv, yv = np.meshgrid(x, y)
if geometry_type == 1:
center_sigma = center_sigma * np.sqrt(1. / 2.)
cond1 = ((xv - center_sigma) ** 2 + (yv - center_sigma) ** 2) <= radius_sigma ** 2
cond2 = ((xv - center_sigma) ** 2 + (yv + center_sigma) ** 2) <= radius_sigma ** 2
cond3 = ((xv + center_sigma) ** 2 + (yv - center_sigma) ** 2) <= radius_sigma ** 2
cond4 = ((xv + center_sigma) ** 2 + (yv + center_sigma) ** 2) <= radius_sigma ** 2
else:
cond1 = ((xv - center_sigma) ** 2 + (yv - 0.) ** 2) <= radius_sigma ** 2
cond2 = ((xv + center_sigma) ** 2 + (yv + 0.) ** 2) <= radius_sigma ** 2
cond3 = ((xv - 0.) ** 2 + (yv - center_sigma) ** 2) <= radius_sigma ** 2
cond4 = ((xv - 0.) ** 2 + (yv + center_sigma) ** 2) <= radius_sigma ** 2
val = np.array(cond1 | cond2 | cond3 | cond4, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_shrinc_source_shape_model(x, y, sigma_out, stripe_width):
xv, yv = np.meshgrid(x, y)
cond1 = ((xv - 0.) ** 2 + (yv - 0.) ** 2) <= sigma_out ** 2
cond2 = np.abs(yv) >= stripe_width / 2.
cond3 = np.abs(xv) >= stripe_width / 2.
val = np.array(cond1 & cond2 & cond3, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
def get_square_source_shape_model(x, y, half_width_sigma):
xv, yv = np.meshgrid(x, y)
cond1 = np.abs(yv) <= half_width_sigma
cond2 = np.abs(xv) <= half_width_sigma
val = np.array(cond1 & cond2, dtype=float)
plt.imshow(val)
plt.show()
val = np.asfortranarray(val / np.sum(val))
return val
class ResistImagesAndContours(object):
def __init__(self):
self.featureWidth = 240. # nm
self.pitch = 600. # nm
self.featureTransmittance = 0. # from 0. to 1.
self.maskTransmittance = 1. # from 0. to 1.
self.featurePhase = 0.
self.maskPhase = 0.
self.wavelength = 365.0 # nanometers
self.numericalAperture = 0.9
self.reductionRatio = 1.0
self.flare = 0.
self.immersion = 0.
self.focus = 0.
self.nominalDose = 145 # mJ/cm^2
self.correctable = 0.5
self.resistThickness = 600.
self.stepZ = 5.
self.sourceStep = 0.05
self.maskStep = 5.
self.a = 0. # exposure-dependent absorption of resist
self.b = 0.81 # exposure-independent absorption of resist
self.c = 0.008 # rate of absorption change or bleaching rate
self.n = 1.835 # refractive index (exposed and unexposed)
self.ea = 33.5 # PEB acid diffusivity activation energy
self.ln_ar = 45. # PEB acid diffusivity Ln(Ar)
self.substrateRefractiveIndexReal = 6.49
self.substrateRefractiveIndexImage = 2.6
self.barcThickness = 172.
self.barcRefractiveIndexReal = 1.81
self.barcRefractiveIndexImage = 0.34
self.environmentRefractiveIndexReal = 1.
self.environmentRefractiveIndexImage = 0.
self.pac = np.linspace(0., 1., np.int(self.pitch / self.maskStep))
# relative inhibitor concentration = (inhibitor concentration)/(initial inhibitor concentration)
self.pn = 2
max_development_rate = 100 # nm/s
min_development_rate = 0.1 # nm/s
self.rate = max_development_rate * np.power((1 - self.pac), self.pn) + min_development_rate
# development rate
self.sourceShapeType = 3
# 1 - conventional coherent
# 3 - conventional partially coherent
# 4 - dipole
# 5 - monopole
# 6 - quadrupole
# 7 - quasar
# 8 - shrinc
# 9 - square
# 10 - annular
self.image_formation()
def source_shape_model_choice(self, x, y):
if self.sourceShapeType == 1:
return get_conventional_coherent_source_shape_model(self.sourceStep, x, y)
elif self.sourceShapeType == 3:
return get_conventional_partially_coherent_source_shape_model(x, y, sigma=0.9)
elif self.sourceShapeType == 4:
return get_dipole_source_shape_model(x, y, center_sigma=0.5, radius_sigma=0.3)
elif self.sourceShapeType == 5:
return get_monopole_source_shape_model(x, y, center_x=0.5, center_y=0.3, radius_sigma=0.2)
elif self.sourceShapeType == 6:
# types:
# 1 - Normal (90deg)
# 2 - Cross (45deg)
return get_quadrupole_source_shape_model(x, y, center_sigma=0.5, radius_sigma=0.2, geometry_type=1)
elif self.sourceShapeType == 7:
return get_quasar_source_shape_model(x, y, sigma_in=0.4, sigma_out=0.8, blade_angle=60.)
elif self.sourceShapeType == 8:
return get_shrinc_source_shape_model(x, y, sigma_out=0.8, stripe_width=0.2)
elif self.sourceShapeType == 9:
return get_square_source_shape_model(x, y, half_width_sigma=0.5)
elif self.sourceShapeType == 10:
return get_annular_source_shape_model(x, y, sigma_in=0.4, sigma_out=0.8)
else:
raise ValueError("Wrong source shape id")
def image_formation(self):
core_logging = oplc.OptolithiumCoreLog()
core_logging.set_verbose_level(0)
# feature formation
point1 = oplc.Point2d(-self.featureWidth / 2., 0.)
point2 = oplc.Point2d(self.featureWidth / 2., 0.)
points_array = oplc.Points2dArray((point1, point2))
region = oplc.Region(points_array, self.featureTransmittance, self.featurePhase)
region_array = (region, )
# repeatable part formation
point1 = oplc.Point2d(-self.pitch / 2., 0.)
point2 = oplc.Point2d(self.pitch / 2., 0.)
box = oplc.Box(point1, point2, self.maskTransmittance, self.maskPhase)
# mask formation
mask = oplc.Mask(region_array, box)
# source calculation
points_count = int(2 / self.sourceStep) + 1
nx, ny = (points_count, points_count)
x = np.linspace(-1, 1, nx)
y = np.linspace(-1, 1, ny)
x = np.round(x / self.sourceStep) * self.sourceStep
y = np.round(y / self.sourceStep) * self.sourceStep
values = self.source_shape_model_choice(x, y)
source_shape_model_sheet = oplc.SourceShapeModelSheet(x, y, values)
source_shape = oplc.SourceShape(source_shape_model_sheet, self.sourceStep, self.sourceStep)
pupil_filter_model = oplc.PupilFilterModelEmpty()
imaging_tool = oplc.ImagingTool(source_shape, pupil_filter_model, self.wavelength, self.numericalAperture,
self.reductionRatio, self.flare, self.immersion)
diffraction = oplc.diffraction(imaging_tool, mask)
exposure = oplc.Exposure(self.focus, self.nominalDose, self.correctable)
exposure_resist_model = oplc.ExposureResistModel(self.wavelength, self.a, self.b, self.c, self.n)
peb_resist_model = oplc.PebResistModel(self.ea, self.ln_ar)
rate_model = oplc.ResistRateModelSheet(self.pac, self.rate)
plt.plot(self.pac, self.rate)
plt.show()
# wafer stack formation
substrate_layer = oplc.ConstantWaferLayer(oplc.SUBSTRATE_LAYER, self.substrateRefractiveIndexReal,
self.substrateRefractiveIndexImage)
resist_layer = oplc.ResistWaferLayer(self.resistThickness, exposure_resist_model, peb_resist_model, rate_model)
barc_layer = oplc.ConstantWaferLayer(oplc.MATERIAL_LAYER, self.barcThickness, self.barcRefractiveIndexReal,
self.barcRefractiveIndexImage)
environment_layer = oplc.ConstantWaferLayer(oplc.ENVIRONMENT_LAYER, self.environmentRefractiveIndexReal,
self.environmentRefractiveIndexImage)
wafer_stack = oplc.WaferStack()
wafer_stack.push(substrate_layer)
wafer_stack.push(barc_layer)
wafer_stack.push(resist_layer)
wafer_stack.push(environment_layer)
optical_transfer_function = oplc.OpticalTransferFunction(imaging_tool, exposure, wafer_stack)
image_in_resist = oplc.image_in_resist(diffraction, optical_transfer_function, self.maskStep, self.stepZ)
fig, ax = plt.subplots(figsize=(6, 6))
tmp = np.rot90(image_in_resist.values[0])
with open("resultsImageInResist.txt", 'w') as f:
for i in range(len(tmp)):
for j in range(len(tmp[i])):
f.write('%f\t' % tmp[i][j])
f.write("\n")
ax.imshow(tmp, interpolation='none', extent=[-self.pitch / 2, self.pitch / 2., 0, self.resistThickness])
ax.set_aspect("equal")
plt.show()
latent_image = oplc.latent_image(image_in_resist, resist_layer, exposure)
fig, ax = plt.subplots(figsize=(6, 6))
tmp = np.rot90((latent_image.values[0]))
with open("resultsLatentImage.txt", 'w') as f:
for i in range(len(tmp)):
for j in range(len(tmp[i])):
f.write('%f\t' % tmp[i][j])
f.write("\n")
ax.imshow(tmp, interpolation='none', extent=[-self.pitch / 2, self.pitch / 2., 0, self.resistThickness])
ax.set_aspect("equal")
plt.show()
time_contours = oplc.develop_time_contours(latent_image, resist_layer)
tmp = np.rot90((time_contours.values[0]))
with open("resultsTimeContours.txt", 'w') as f:
for i in range(len(tmp)):
for j in range(len(tmp[i])):
f.write('%f\t' % tmp[i][j])
f.write("\n")
fig, ax = plt.subplots(figsize=(6, 6))
ax.imshow(tmp, interpolation='none', extent=[-self.pitch / 2., self.pitch / 2., 0, self.resistThickness])
ax.set_aspect("equal")
plt.show()
def main():
ResistImagesAndContours()
if __name__ == "__main__":
main()
================================================
FILE: OptolithiumC/include/opl_capi.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPTOLITHIUMC_HPP_
#define OPTOLITHIUMC_HPP_
#include <complex>
#include <algorithm>
#if !defined( SWIG )
// SWIG should not see #include <armadillo> as it can not handle it
#include <armadillo>
#endif
#include "opl_geometry.h"
#include "opl_interp.h"
#include "opl_contours.h"
#include "opl_physc.h"
#include "opl_misc.h"
#include "optolithium.h"
#define OPTOLITHIUM_CORE_VERSION "0.7a"
namespace oplc {
using namespace geometry;
//using namespace std::literals::complex_literals;
const arma::cx_double j = arma::cx_double(0.0, 1.0);
inline arma::cx_double _etransmit(double transmit, double phase) {
return std::sqrt(transmit) * std::exp(j*phase*M_PI/180.0);
}
typedef enum { // z y x
X_1D = 1, // 0 0 1
Y_1D = 2, // 0 1 0
XY_2D = 3, // 0 1 1
XZ_2D = 5, // 1 0 1
YZ_2D = 6, // 1 1 0
XYZ_3D = 7, // 1 1 1
} resist_volume_type_t;
typedef enum {
RESIST_VOLUME = 0,
RESIST_PROFILE = 1,
} resist_simulations_t;
class AbstractResistSimulations {
protected:
// Each coordinate values data
std::shared_ptr<arma::vec> _x;
std::shared_ptr<arma::vec> _y;
std::shared_ptr<arma::vec> _z;
double _stepx;
double _stepy;
double _stepz;
public:
virtual resist_simulations_t type(void) const = 0;
virtual ~AbstractResistSimulations(void) { }
std::shared_ptr<arma::vec> x(void) const;
std::shared_ptr<arma::vec> y(void) const;
std::shared_ptr<arma::vec> z(void) const;
double x(uint32_t k) const;
double y(uint32_t k) const;
double z(uint32_t k) const;
bool has_x(void) const;
bool has_y(void) const;
bool has_z(void) const;
double stepx(void) const;
double stepy(void) const;
double stepz(void) const;
resist_volume_type_t axes(void) const;
};
typedef std::shared_ptr<AbstractResistSimulations> SharedAbstractResistSimulations;
class ResistVolume : public AbstractResistSimulations {
private:
// Values being calculated
std::shared_ptr<arma::cube> _values;
inline static double _calc_lateral_step(double mask_pitch, double desired_step) {
if (mask_pitch == 0.0 || desired_step == 0.0) {
return 0.0;
} else {
int32_t n = static_cast<int32_t>(ceil(mask_pitch/desired_step));
if (mask_pitch/static_cast<double>(n-1) > desired_step) {
n += (n % 2) ? 2 : 1;
}
return mask_pitch/static_cast<double>(n-1);
}
}
inline static double _calc_normal_step(double thickness, double desired_step) {
if (thickness == 0.0 || desired_step == 0.0) {
return 0.0;
} else {
double tmp = thickness / desired_step;
if (tmp - round(tmp) != 0.0) {
return thickness/ceil(tmp + 1);
} else {
return desired_step;
}
}
}
// Offset required to make lateral counts odd
inline static uint32_t _get_count(double size, double step, uint32_t offset=0) {
if (size == 0.0 || step == 0.0) {
return 1;
} else {
return static_cast<uint32_t>(ceil(size/step)+offset);
}
}
inline static void _init_vector(arma::vec& vec, double start, double step) {
for (uint32_t k = 0; k < vec.n_elem; k++) {
vec(k) = k * step + start;
}
}
public:
// Cached input data
const RectangleGeometry boundary;
const double thickness;
const double desired_stepxy;
const double desired_stepz;
// Initialization for 2D/3D cases (e.g. Image in Resist, Latent Image, PAC, Development Rates)
ResistVolume(const RectangleGeometry& boundary, double thickness, double desired_stepxy, double desired_stepz);
// Initialization for 1D/2D cases (e.g. for AerialImage)
ResistVolume(const RectangleGeometry& boundary, double desired_step);
ResistVolume(const ResistVolume& other, bool copydata=false);
std::shared_ptr<arma::cube> values(void) const;
double& value(uint32_t u, uint32_t v=0, uint32_t k=0) const;
resist_simulations_t type(void) const;
};
typedef std::shared_ptr<ResistVolume> SharedResistVolume;
class ResistProfile : public AbstractResistSimulations {
private:
ArrayOfSharedPolygons _polygons;
public:
ResistProfile(SharedResistVolume volume, double level);
ArrayOfSharedPolygons polygons(void) const;
resist_simulations_t type(void) const;
};
typedef std::shared_ptr<ResistProfile> SharedResistProfile;
class AbstractMaskGeometry : public virtual AbstractGeometry {
protected:
double _transmittance;
double _phase;
public:
AbstractMaskGeometry(double transmittance, double phase) : _transmittance(transmittance), _phase(phase) { }
double transmittance(void) const;
double phase(void) const;
bool is_mask(void) const;
// Effective transmittance of the region
arma::cx_double etransmit(void);
bool operator==(const AbstractGeometry& other) const;
};
class Region : public AbstractMaskGeometry, public PolygonGeometry {
public:
Region(const ArrayOfSharedPoints2d &points, double transmittance, double phase) :
AbstractMaskGeometry(transmittance, phase), PolygonGeometry(points) { }
Region(const Region& other) : AbstractMaskGeometry(other._transmittance, other._phase), PolygonGeometry(other) { }
bool operator==(const AbstractGeometry& other) const {
return AbstractMaskGeometry::operator ==(other) && PolygonGeometry::operator ==(other);
}
};
class Box : public AbstractMaskGeometry, public RectangleGeometry {
public:
Box(const Point2d& lb, const Point2d& rt, double transmittance, double phase) :
AbstractMaskGeometry(transmittance, phase), RectangleGeometry(lb, rt) { }
Box(ArrayOfSharedPoints2d points, double transmittance, double phase) :
Box(*points[0], *points[1], transmittance, phase) { }
Box(const Box& other) : Box(other.left_bottom(), other.right_top(), other._transmittance, other._phase) { }
bool operator==(const AbstractGeometry& other) const {
return AbstractMaskGeometry::operator ==(other) && RectangleGeometry::operator ==(other);
}
};
typedef std::shared_ptr<AbstractMaskGeometry> SharedAbstractMaskGeometry;
typedef std::vector<SharedAbstractMaskGeometry> ArrayOfSharedAbstractMaskGeometry;
typedef std::shared_ptr<Region> SharedRegion;
typedef std::shared_ptr<const Region> ConstSharedRegion;
typedef std::vector<SharedRegion> ArrayOfSharedRegions;
typedef std::shared_ptr<Box> SharedBox;
typedef std::shared_ptr<const Box> ConstSharedBox;
class Mask: public Iterable::Interface<SharedRegion> {
protected:
SharedBox _boundary;
ArrayOfSharedRegions _regions;
Sizes _sizes;
// Correct mask region according to diffraction calculation requirements
static SharedRegion _make_region(ConstSharedRegion region, const Point2d& center_offset);
public:
SharedRegion at(uint32_t index) const;
uint32_t length(void) const;
Mask(const ArrayOfSharedRegions& regions, SharedBox boundary);
Mask(const Mask& other);
SharedBox boundary(void) const;
Sizes pitch(void) const;
bool is_opaque(void) const;
bool is_clear(void) const;
bool is_bad(void) const;
bool is_1d(void) const;
bool operator==(const Mask& other) const;
};
typedef std::shared_ptr<Mask> SharedMask;
typedef enum {
PLUGIN_MODEL_TYPE = 0,
SHEET_MODEL_TYPE = 1,
EMPTY_MODEL_TYPE = 2
} common_model_type_t;
class AbstractSourceShapeModel {
public:
const common_model_type_t type;
AbstractSourceShapeModel(common_model_type_t type) : type(type) { }
virtual ~AbstractSourceShapeModel(void) { };
virtual double calculate(double sx, double sy) const = 0;
virtual bool operator==(const AbstractSourceShapeModel& other) const = 0;
};
class SourceShapeModelPlugin : public AbstractSourceShapeModel {
private:
const source_shape_expr_t _expression;
const std::vector<double> _args;
const void *_pargs;
public:
SourceShapeModelPlugin(source_shape_expr_t expression, std::vector<double> args);
double calculate(double sx, double sy) const;
bool operator==(const AbstractSourceShapeModel& other) const;
};
class SourceShapeModelSheet : public AbstractSourceShapeModel {
private:
const interp::LinearInterpolation2d _interp;
public:
// armanpy not support pass arrays by shared_ptr
SourceShapeModelSheet(const arma::vec& sx, const arma::vec& sy, const arma::mat& intensity);
double calculate(double sx, double sy) const;
bool operator==(const AbstractSourceShapeModel& other) const;
};
class AbstractResistRateModel {
public:
const common_model_type_t type;
AbstractResistRateModel(common_model_type_t type) : type(type) { }
virtual ~AbstractResistRateModel(void) { };
virtual double calculate(double pac, double depth=0.0) const = 0;
virtual bool operator==(const AbstractResistRateModel& other) const = 0;
};
class ResistRateModelExpression : public AbstractResistRateModel {
private:
const rate_model_expr_t _expression;
const std::vector<double> _args;
const void *_pargs;
public:
ResistRateModelExpression(rate_model_expr_t expression, std::vector<double> args);
double calculate(double pac, double depth=0.0) const;
bool operator==(const AbstractResistRateModel& other) const;
};
class ResistRateModelDepthSheet : public AbstractResistRateModel {
private:
const interp::LinearInterpolation2d _interp;
public:
// armanpy not support pass arrays by shared_ptr
ResistRateModelDepthSheet(const arma::vec& pac, const arma::vec& depth, const arma::mat& rate);
double calculate(double pac, double depth=0.0) const;
bool operator==(const AbstractResistRateModel& other) const;
};
class ResistRateModelSheet : public AbstractResistRateModel {
private:
const interp::LinearInterpolation1d _interp;
public:
// armanpy not support pass arrays by shared_ptr
ResistRateModelSheet(const arma::vec& pac, const arma::vec& rate);
double calculate(double pac, double depth=0.0) const;
bool operator==(const AbstractResistRateModel& other) const;
};
class AbstractPupilFilterModel {
public:
const common_model_type_t type;
AbstractPupilFilterModel(common_model_type_t type) : type(type) { }
virtual ~AbstractPupilFilterModel(void) { };
virtual arma::cx_double calculate(double sx, double sy) const = 0;
virtual bool operator==(const AbstractPupilFilterModel& other) const = 0;
};
class PupilFilterModelPlugin : public AbstractPupilFilterModel {
private:
const pupil_filter_expr_t _expression;
const std::vector<double> _args;
const void *_pargs;
public:
PupilFilterModelPlugin(pupil_filter_expr_t expression, std::vector<double> args);
arma::cx_double calculate(double sx, double sy) const;
bool operator==(const AbstractPupilFilterModel& other) const;
};
class PupilFilterModelSheet : public AbstractPupilFilterModel {
private:
interp::LinearInterpolation2d _interp_real;
interp::LinearInterpolation2d _interp_imag;
public:
// armanpy not support pass arrays by shared_ptr
PupilFilterModelSheet(const arma::vec& sx, const arma::vec& sy, const arma::cx_mat& coef);
arma::cx_double calculate(double sx, double sy) const;
bool operator==(const AbstractPupilFilterModel& other) const;
};
class PupilFilterModelEmpty : public AbstractPupilFilterModel {
public:
PupilFilterModelEmpty(void);
arma::cx_double calculate(double sx, double sy) const;
bool operator==(const AbstractPupilFilterModel& other) const;
};
typedef std::shared_ptr<AbstractResistRateModel> SharedAbstractResistRateModel;
typedef std::shared_ptr<const AbstractResistRateModel> ConstSharedAbstractResistRateModel;
typedef std::shared_ptr<ResistRateModelExpression> SharedResistRateModelExpression;
typedef std::shared_ptr<ResistRateModelSheet> SharedResistRateModelSheet;
typedef std::shared_ptr<AbstractSourceShapeModel> SharedAbstractSourceShapeModel;
typedef std::shared_ptr<const AbstractSourceShapeModel> ConstSharedAbstractSourceShapeModel;
typedef std::shared_ptr<SourceShapeModelPlugin> SharedSourceShapePlugin;
typedef std::shared_ptr<SourceShapeModelSheet> SharedSourceShapeSheet;
typedef std::shared_ptr<AbstractPupilFilterModel> SharedAbstractPupilFilterModel;
typedef std::shared_ptr<const AbstractPupilFilterModel> ConstSharedAbstractPupilFilterModel;
typedef std::shared_ptr<PupilFilterModelPlugin> SharedPupilFilterPlugin;
typedef std::shared_ptr<PupilFilterModelSheet> SharedPupilFilterSheet;
class SourceShape {
private:
// Direction cosine limit in any direction for the source shape
static constexpr double _clim = 1.0;
// Simulation's model of the source shape either function or data grid
SharedAbstractSourceShapeModel _model;
// Simulation's step by x and y axis
double _stepx;
double _stepy;
std::shared_ptr<arma::mat> _values;
std::shared_ptr<arma::s32_vec> _kx;
std::shared_ptr<arma::s32_vec> _ky;
std::shared_ptr<arma::vec> _cx;
std::shared_ptr<arma::vec> _cy;
// Non-zeros item's indexes
std::shared_ptr<arma::umat> _non_zeros;
// Non-zeros limits of the source shape
double _sx_min;
double _sx_max;
double _sy_min;
double _sy_max;
static void _init_vectors(std::shared_ptr<arma::s32_vec> &k, std::shared_ptr<arma::vec> &dcos, double step);
static std::shared_ptr<arma::mat> _init_values(
const arma::vec &cx, const arma::vec &cy, SharedAbstractSourceShapeModel model);
static std::shared_ptr<arma::umat> _get_non_zeros_indexes(const arma::mat &values);
static void _get_limits(double &sx_min, double &sx_max, double &sy_min, double &sy_max,
std::shared_ptr<arma::umat> non_zeros, std::shared_ptr<arma::vec> cx, std::shared_ptr<arma::vec> cy);
public:
SourceShape(SharedAbstractSourceShapeModel model, double stepx, double stepy);
std::shared_ptr<arma::mat> values(void) const;
double value(uint32_t r, uint32_t c) const;
double cx(uint32_t i) const;
double cy(uint32_t i) const;
std::shared_ptr<arma::vec> cx(void) const;
std::shared_ptr<arma::vec> cy(void) const;
std::shared_ptr<arma::umat> non_zeros(void) const;
double sx_min(void) const;
double sx_max(void) const;
double sy_min(void) const;
double sy_max(void) const;
bool operator==(const SourceShape& other) const;
};
typedef std::shared_ptr<SourceShape> SharedSourceShape;
typedef std::shared_ptr<const SourceShape> ConstSharedSourceShape;
class ImagingTool {
private:
SharedSourceShape _source_shape;
SharedAbstractPupilFilterModel _pupil_filter_model;
double _reduction_ratio;
double _squared_reduction_ratio;
double _flare;
double _immersion;
public:
const double wavelength;
const double numeric_aperture;
ImagingTool(SharedSourceShape source_shape, SharedAbstractPupilFilterModel pupil_filter_model,
double wavelength, double numeric_aperture, double reduction_ratio, double flare, double immersion);
SharedSourceShape source_shape(void) const;
arma::cx_double filter(double cx, double cy) const;
double reduction(double cx, double cy, arma::cx_double environment_refraction=physc::air_nk) const;
void flare(SharedResistVolume intensity) const;
bool operator==(const ImagingTool& other) const;
};
typedef std::shared_ptr<ImagingTool> SharedImagingTool;
typedef std::shared_ptr<const ImagingTool> ConstSharedImagingTool;
class Exposure {
public:
const double focus;
const double nominal_dose;
const double correctable;
Exposure(double focus, double nominal_dose, double correctable);
arma::cx_double defocus(double cx, double cy, double wvl) const;
double dose(void) const;
bool operator==(const Exposure& other) const;
};
typedef std::shared_ptr<Exposure> SharedExposure;
typedef std::shared_ptr<const Exposure> ConstSharedExposure;
inline bool within_circle(double dx, double dy, double r) {
double adx = std::abs(dx);
double ady = std::abs(dy);
if (adx + ady <= r) {
return true;
} else if (adx > r || ady > r) {
return false;
} else if (adx*adx + ady*ady <= r*r) {
return true;
} else {
return false;
}
}
inline bool within_circle(double x, double y, double cx, double cy, double r) {
return within_circle(x - cx, y - cy, r);
}
class Diffraction {
private:
// Diffraction orders values
std::shared_ptr<arma::cx_mat> _values;
// Diffraction orders spatial frequencies arrays
std::shared_ptr<arma::vec> _frqx;
std::shared_ptr<arma::vec> _frqy;
// Diffraction orders indexes
std::shared_ptr<arma::s32_vec> _kx;
std::shared_ptr<arma::s32_vec> _ky;
// Direction cosines matrix and vectors
std::shared_ptr<arma::mat> _cxy;
std::shared_ptr<arma::vec> _cx;
std::shared_ptr<arma::vec> _cy;
inline static void _init_vectors(arma::s32_vec& k, arma::vec& frq, arma::vec& dcos,
double pitch, double wavelength, std::pair<int32_t, int32_t> limits) {
if (pitch == 0.0) {
k(0) = 0;
frq(0) = 0.0;
dcos(0) = 0.0;
} else {
int32_t k_min = limits.first;
// int32_t k_max = limits.second;
// int32_t median = static_cast<int32_t>(round(static_cast<double>(k_max - k_min)/2.0));
// VLOG(4) << "k_min = " << k_min << " k_max = " << k_max << " median = " << median;
for (uint32_t i = 0; i < k.n_elem; i++) {
k(i) = k_min + i;
frq(i) = k(i) / pitch;
dcos(i) = frq(i) * wavelength;
}
}
}
inline static void _init_cosines(arma::mat& cxy, arma::vec& cx, arma::vec& cy) {
for (uint32_t c = 0; c < cx.n_elem; c++) {
for (uint32_t r = 0; r < cy.n_elem; r++) {
cxy(r, c) = sqrt(cx(c)*cx(c) + cy(r)*cy(r));
}
}
}
// Calculate total size of the diffraction array taking account source shape tilt
// median - center point of the diffraction pattern belong axis
// na - numeric aperture
// wvl - wavelength
// pitch - mask pitch for specified direction
// cs_min/cx_max - minimum/maximum value of direction cosine in source shape
// coordinate system where intensity is not zero
inline static std::pair<int32_t, int32_t> _calc_size(
double na, double wvl, double pitch, double cs_min, double cs_max) {
if (cs_min > cs_max) {
std::ostringstream error_msg;
error_msg << "Maximum direction cosine of source shape must be greater than minimum value: "
<< "Max = " << cs_max << " Min = " << cs_min;
throw std::invalid_argument(error_msg.str());
}
int32_t k_min = static_cast<int32_t>(-floor(na*(1.0-cs_min)/wvl*pitch));
int32_t k_max = static_cast<int32_t>(floor(na*(1.0+cs_max)/wvl*pitch));
return std::pair<int32_t, int32_t>(k_min, k_max);
}
template <typename T>
inline static std::shared_ptr<T> _select_axis(uint32_t axis, std::shared_ptr<T> x, std::shared_ptr<T> y) {
if (axis == DIM_1D_X) {
return x;
} else if (axis == DIM_1D_Y) {
return y;
} else {
throw std::runtime_error("Can't get using axis from non-1D storage");
}
}
void _add_1d_region(SharedAbstractMaskGeometry region, arma::cx_double factor);
static arma::cx_double _calc_2d_region(SharedAbstractMaskGeometry region,
int32_t kx, int32_t ky, double frqx, double frqy);
void _add_2d_region(SharedAbstractMaskGeometry region, arma::cx_double factor);
public:
// Corresponding source shape data
ConstSharedSourceShape source_shape;
// Corresponding mask pitch (it's hard linked with spatial frequencies step = 1/pitch)
const Sizes pitch;
const Box boundary;
// Required to pass diffraction points over the objective lens at the corners
const double numeric_aperture;
const double wavelength;
Diffraction(SharedMask mask, SharedImagingTool imaging_tool);
// Return direction cosines for given axis
std::shared_ptr<arma::vec> c(uint32_t axis) const;
// Return diffraction terms order number for given axis
std::shared_ptr<arma::s32_vec> k(uint32_t axis) const;
// Return spatial frequencies for given axis
std::shared_ptr<arma::vec> frq(uint32_t axis) const;
// Return plane waves of diffraction pattern values
std::shared_ptr<arma::cx_mat> values(void) const;
arma::cx_double value(uint32_t r, uint32_t c) const;
// Return absolute value of direction cosines
std::shared_ptr<arma::mat> cxy(void) const;
// Return direction cosine belong to x-axis
std::shared_ptr<arma::vec> cx(void) const;
double cx(uint32_t i) const;
// Return direction cosine belong to y-axis
std::shared_ptr<arma::vec> cy(void) const;
double cy(uint32_t i) const;
// Return spatial frequencies belong to x-axis
std::shared_ptr<arma::vec> frqx(void) const;
// Return spatial frequencies belong to y-axis
std::shared_ptr<arma::vec> frqy(void) const;
// Return diffraction terms order numbers belong x-axis
std::shared_ptr<arma::s32_vec> kx(void) const;
int32_t kx(uint32_t i) const;
// Return diffraction terms order numbers belong y-axis
std::shared_ptr<arma::s32_vec> ky(void) const;
int32_t ky(uint32_t i) const;
void add_region(SharedAbstractMaskGeometry region, arma::cx_double factor);
};
typedef std::shared_ptr<Diffraction> SharedDiffraction;
typedef std::shared_ptr<const Diffraction> ConstSharedDiffraction;
typedef enum {
ENVIRONMENT_LAYER = 0,
RESIST_LAYER = 1,
MATERIAL_LAYER = 2,
SUBSTRATE_LAYER = 3
} layer_type_t;
class AbstractWaferLayer {
public:
const layer_type_t type;
const double thickness;
AbstractWaferLayer(layer_type_t layer_type, double thickness) : type(layer_type), thickness(thickness) { }
virtual ~AbstractWaferLayer(void) { };
// 0 < m < 1 - for resist layer current PAC value, for others layer should be ignored
virtual arma::cx_double refraction(double wavelength, double m=1.0) const = 0;
bool is_environment(void) const;
bool is_resist(void) const;
bool is_material(void) const;
bool is_substrate(void) const;
arma::cx_double effective_refraction(arma::cx_double incident_angle, double wavelength) const;
// WARNING: valid only for zero order
arma::cx_double internal_transmit(double wavelength, double power=1.0) const;
// Can be used for others d.ords
arma::cx_double internal_transmit(arma::cx_double incident_angle, double dz, double wavelength) const;
std::string str(void) const;
virtual bool operator==(const AbstractWaferLayer& other) const = 0;
};
class StandardWaferLayer : public AbstractWaferLayer {
private:
interp::LinearInterpolation1d _refraction_real;
interp::LinearInterpolation1d _refraction_imag;
public:
StandardWaferLayer(layer_type_t layer_type, double thickness, const arma::vec& wavelength,
const arma::vec& refraction_real, const arma::vec& refraction_imag);
StandardWaferLayer(layer_type_t layer_type, const arma::vec& wavelength,
const arma::vec& refraction_real, const arma::vec& refraction_imag) :
StandardWaferLayer(layer_type, NAN, wavelength, refraction_real, refraction_imag) { };
arma::cx_double refraction(double wavelength, double m=1.0) const;
bool operator==(const AbstractWaferLayer& other) const;
};
class ConstantWaferLayer : public AbstractWaferLayer {
private:
arma::cx_double _refraction;
public:
ConstantWaferLayer(layer_type_t layer_type, double thickness, double real, double imag);
ConstantWaferLayer(layer_type_t layer_type, double real, double imag) :
ConstantWaferLayer(layer_type, NAN, real, imag) { }
arma::cx_double refraction(double wavelength=0.0, double m=1.0) const;
bool operator==(const AbstractWaferLayer& other) const;
};
class ExposureResistModel {
public:
const double wavelength;
// Dill model constants
const double a;
const double b;
const double c;
// Real refractive index
const double n;
ExposureResistModel(double wavelength, double a, double b, double c, double n) :
wavelength(wavelength), a(a), b(b), c(c), n(n) { }
arma::cx_double refraction(double m=1.0) const;
bool operator==(const ExposureResistModel& other) const;
};
typedef std::shared_ptr<ExposureResistModel> SharedExposureResistModel;
typedef std::shared_ptr<const ExposureResistModel> ConstSharedExposureResistModel;
class PostExposureBake {
public:
const double time;
const double temp;
PostExposureBake(double time, double temp) : time(time), temp(temp) { }
};
typedef std::shared_ptr<PostExposureBake> SharedPostExposureBake;
typedef std::shared_ptr<const PostExposureBake> ConstSharedPostExposureBake;
class PebResistModel {
public:
const double ea;
const double ln_ar;
PebResistModel(double ea, double ln_ar) : ea(ea), ln_ar(ln_ar) { }
double diffusivity(double temp) const;
double diffusion_length(double temp, double time) const;
arma::vec kernel(SharedPostExposureBake peb, double step) const;
bool operator==(const PebResistModel& other) const;
};
typedef std::shared_ptr<PebResistModel> SharedPebResistModel;
typedef std::shared_ptr<const PebResistModel> ConstSharedPebResistModel;
class ResistWaferLayer : public AbstractWaferLayer {
public:
const ConstSharedExposureResistModel exposure;
const ConstSharedPebResistModel peb;
const ConstSharedAbstractResistRateModel rate;
ResistWaferLayer(double thickness, SharedExposureResistModel exposure_model,
SharedPebResistModel peb_model, SharedAbstractResistRateModel rate_model) :
AbstractWaferLayer(RESIST_LAYER, thickness),
exposure(exposure_model), peb(peb_model), rate(rate_model) { }
arma::cx_double refraction(double wavelength, double m=1.0) const;
bool operator==(const AbstractWaferLayer& other) const;
};
typedef std::shared_ptr<AbstractWaferLayer> SharedAbstractWaferLayer;
typedef std::shared_ptr<StandardWaferLayer> SharedStandardWaferLayer;
typedef std::shared_ptr<ResistWaferLayer> SharedResistWaferLayer;
typedef std::shared_ptr<ConstantWaferLayer> SharedConstantWaferLayer;
typedef std::vector<SharedAbstractWaferLayer> ArrayOfSharedAbstractWaferLayers;
class WaferStack {
private:
ArrayOfSharedAbstractWaferLayers _layers;
SharedAbstractWaferLayer _resist;
SharedAbstractWaferLayer _substrate;
SharedAbstractWaferLayer _environment;
std::map<std::pair<double, double>, std::shared_ptr<arma::cx_vec>> _cached_top_reflections;
std::map<std::pair<double, double>, std::shared_ptr<arma::cx_vec>> _cached_bottom_reflections;
double _cached_wavelength;
static inline arma::cx_double _angle(arma::cx_double incident_angle,
arma::cx_double top_refraction, arma::cx_double bottom_refraction) {
return std::asin(top_refraction / bottom_refraction * std::sin(incident_angle));
}
static inline arma::cx_double _reflection(arma::cx_double top_refraction, arma::cx_double bottom_refraction) {
return (top_refraction - bottom_refraction) / (top_refraction + bottom_refraction);
}
static inline arma::cx_double _transmittance(arma::cx_double top_refraction, arma::cx_double bottom_refraction) {
return 2.0 * top_refraction / (top_refraction + bottom_refraction);
}
// Calculate refractive indexes between layers (for all layers in the stack)
arma::cx_vec _calc_refractive_indexes(double cxy, double wavelength);
// Calculate effective reflection for all stack from top to bottom
// (reflection with taking account of all top layers)
std::shared_ptr<arma::cx_vec> _calc_effective_top_reflections(double cxy, double wavelength);
// Return cached value or calculate
std::shared_ptr<arma::cx_vec> effective_top_reflection(double cx, double cy, double wavelength);
// Calculate effective reflection for all stack from bottom to top
// (reflection with taking account of all bottom layers)
std::shared_ptr<arma::cx_vec> _calc_effective_bottom_reflections(double cxy, double wavelength);
// Return cached value or calculate
std::shared_ptr<arma::cx_vec> effective_bottom_reflection(double cx, double cy, double wavelength);
public:
WaferStack(void);
WaferStack(ArrayOfSharedAbstractWaferLayers layers);
void push(SharedAbstractWaferLayer layer);
bool is_ok(void);
SharedAbstractWaferLayer operator[](int32_t i) const;
SharedAbstractWaferLayer environment(void) const;
SharedAbstractWaferLayer resist(void) const;
SharedAbstractWaferLayer substrate(void) const;
uint32_t index_of(SharedAbstractWaferLayer layer) const;
std::complex<double> reflectivity(uint32_t indx, double wavelength);
// This routine only suitable for the stack where resist is the SECOND layer!
std::complex<double> standing_waves(double cx, double cy, double dz, double wavelength);
bool operator==(const WaferStack& other) const;
};
typedef std::shared_ptr<WaferStack> SharedWaferStack;
typedef std::shared_ptr<const WaferStack> ConstSharedWaferStack;
class Development {
public:
const double time;
Development(double time) : time(time) { }
};
typedef std::shared_ptr<Development> SharedDevelopment;
typedef std::shared_ptr<const Development> ConstSharedDevelopment;
class OpticalTransferFunction {
private:
ConstSharedImagingTool _imaging_tool;
ConstSharedExposure _exposure;
// This object is not constant because when calculating it change it internal precalculated values
SharedWaferStack _wafer_stack;
const double _wavelength;
const double _numeric_aperture;
// std::map<std::pair<double, double>, arma::cx_double> _cached_data;
public:
OpticalTransferFunction(SharedImagingTool imaging_tool,
SharedExposure exposure=nullptr, SharedWaferStack wafer_stack=nullptr) :
_imaging_tool(imaging_tool), _exposure(exposure), _wafer_stack(wafer_stack),
_wavelength(imaging_tool->wavelength), _numeric_aperture(imaging_tool->numeric_aperture) { }
// Calculate optical transfer function value for given direction cosines values cx, cy
// and given offset from the resist top dz.
arma::cx_double calc(double cx, double cy, double dz=0.0);
ConstSharedImagingTool imaging_tool(void) const;
ConstSharedExposure exposure(void) const;
ConstSharedWaferStack wafer_stack(void) const;
};
typedef std::shared_ptr<OpticalTransferFunction> SharedOpticalTransferFunction;
// WARNING: !!! REQUIRED OTHERWISE SWIG NOT INCLUDE ARMANPY.I !!!
class Example
{
private:
arma::imat m;
public:
Example(int rows, int cols) {
m = arma::randi(rows, cols, arma::distr_param(0, 100));
};
arma::imat get(void) {
return m;
};
// THIS METHOD MUST EXISTS
void set(const arma::imat& m) {
this->m = m;
};
void set(int v, int r, int c) {
this->m(r, c) = v;
}
void rnd(unsigned s) {
this->m.randn(s,s);
};
std::shared_ptr<arma::imat> get_sptr(void) {
std::shared_ptr<arma::imat> p(new arma::imat(m));
return p;
};
void modify(arma::imat& A, unsigned rows, unsigned cols) {
A.resize( rows, cols );
A.randn( rows, cols );
for( unsigned r = 0; r < rows; r++) {
for( unsigned c = 0; c < cols; c++) {
A(r, c) = 10.0*r+c;
}
}
};
arma::imat reshape(int rows, int cols) const {
return arma::reshape(this->m, rows, cols);
}
arma::imat rot90(void) const {
return misc::rot90(this->m);
}
};
} // namespace oplc
#endif /* OPTOLITHIUMC_HPP_ */
================================================
FILE: OptolithiumC/include/opl_contours.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for non-commercial usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPL_CONTOURS_H_
#define OPL_CONTOURS_H_
#if !defined( SWIG )
// SWIG should not see #include <armadillo> as it can not handle it
#include <armadillo>
#endif
#include "opl_log.h"
#include "opl_geometry.h"
#include "opl_interp.h"
namespace contours {
using namespace geometry;
typedef std::shared_ptr<ArrayOfSharedPoints2d> SharedArrayOfSharedPoints;
class _ContourEngine {
private:
typedef arma::Mat<char> CharMat;
std::shared_ptr<const arma::vec> _x;
std::shared_ptr<const arma::vec> _y;
std::shared_ptr<const arma::mat> _values;
CharMat _marks;
std::list<SharedArrayOfSharedPoints> _contours_list;
ArrayOfSharedPolygons _polygons;
void _mark_facets(double lvl, int32_t sign);
void _drawcn(double lvl, int32_t r, int32_t c, Point2d ct, uint8_t start_edge, bool first);
void _calculate_level_lines(double level);
void _erase_contour(SharedArrayOfSharedPoints contour);
void _extract_polygons(void);
public:
_ContourEngine(const arma::vec& x, const arma::vec& y,
const arma::mat& values, double level, bool negative=false);
ArrayOfSharedPolygons polygons(void) const;
};
class _SurfaceCell;
class _SurfaceEngine {
private:
friend class _SurfaceCell;
const arma::vec& _x;
const arma::vec& _y;
const arma::vec& _z;
const arma::cube& _values;
const double _level;
const int32_t _negative;
ArrayOfSharedTriangles3d _triangles;
ArrayOfSharedPoints3d _verteces;
// Lookup tables used in the construction of the isosurface.
static const uint32_t edgeTable[256];
static const int32_t triTable[256][16];
static const uint32_t indexes_p[12];
static const uint32_t indexes_q[12];
// Calculate table lookup index from those vertices which are below the isolevel.
static uint32_t _calculate_table_index(const _SurfaceCell& cell, double level, int32_t negative);
static ArrayOfSharedPoints3d _calculate_vertices(const _SurfaceCell& cell, uint32_t edge_code, double level);
void _process_verteces(ArrayOfSharedPoints3d verteces, const int32_t tri_codes[]);
static inline Point3d _linear_interp3d(double lvl,
const Point3d& p, const Point3d& q, double v1, double v2) {
double k = (lvl - v1) / (v2 - v1);
return p + k * (q - p);
}
public:
_SurfaceEngine(const arma::vec& x, const arma::vec& y, const arma::vec& z,
const arma::cube& values, const double level, const int32_t negative);
SharedSurface3d surface(void) const;
};
class _SurfaceCell {
public:
std::vector<Point3d> points;
std::vector<double> values;
inline void _get_level(const _SurfaceEngine* se, Point3d& p, double& v, uint32_t r, uint32_t c, uint32_t s) {
if (r >= se->_y.n_elem || c >= se->_x.n_elem || s >= se->_z.n_elem) {
p = Point3d();
v = -1.0;
} else {
p = Point3d(se->_x(c), se->_y(r), se->_z(s));
v = se->_values(r, c, s);
}
}
_SurfaceCell(const _SurfaceEngine* se, uint32_t r, uint32_t c, uint32_t s) {
this->points.resize(8);
this->values.resize(8);
_get_level(se, this->points[0], this->values[0], r , c , s);
_get_level(se, this->points[1], this->values[1], r+1, c , s);
_get_level(se, this->points[2], this->values[2], r+1, c+1, s);
_get_level(se, this->points[3], this->values[3], r , c+1, s);
_get_level(se, this->points[4], this->values[4], r , c , s+1);
_get_level(se, this->points[5], this->values[5], r+1, c , s+1);
_get_level(se, this->points[6], this->values[6], r+1, c+1, s+1);
_get_level(se, this->points[7], this->values[7], r , c+1, s+1);
}
std::string str(void) const {
std::ostringstream result;
result << "{\n";
for (uint32_t k = 0; k < 8; k++) {
result << "\t" << this->points[k].str() << " -> " << this->values[k] << "\n";
}
result << "}";
return result.str();
}
};
ArrayOfSharedPolygons contours(const arma::vec& x, const arma::vec& y,
const arma::mat& values, double level, bool negative=false);
SharedSurface3d isosurface(const arma::vec& x, const arma::vec& y, const arma::vec& z,
const arma::cube& values, double level, bool negative);
}
#endif /* OPL_CONTOURS_H_ */
================================================
FILE: OptolithiumC/include/opl_conv.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for non-commercial usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPL_CONV_H_
#define OPL_CONV_H_
#if !defined( SWIG )
// SWIG should not see #include <armadillo> as it can not handle it
#include <armadillo>
#endif
namespace conv {
typedef enum {
SYMMETRIC = 0,
CIRCULAR = 1
} conv1d_type_t;
template <typename _ArrayType>
inline void _symmetric_conv1d(_ArrayType& result, const _ArrayType& array, const arma::vec& kernel) {
// Symmetric convolution help
// | |
// 0 1 2 1 0 1 2 1 0
// 0 1 2 3 4 3 2 1 0
// -4 -3 -2 -1 0 1 2 3 4
if (array.n_elem > 1) {
const double n_elem = static_cast<double>(kernel.n_elem);
const int32_t kmin = -static_cast<int32_t>(std::floor(n_elem/2.0));
// LOG(INFO) << "Array size = " << array.n_elem << " Centered kernel min index = " << kmin;
// Make symmetric convolution. Indexes reflected from boundary
for (int32_t i = 0; i < static_cast<int32_t>(array.n_elem); i++) {
double sum = 0;
for (int32_t s = kmin, k = 0; k < static_cast<int32_t>(kernel.n_elem); s++, k++) {
uint32_t v;
const int32_t w = abs(i + s), c = array.n_elem;
if (w >= c) {
const uint8_t is_fall = (w/(c-1))%2;
if (is_fall) {
v = (c-1) - w % (c-1);
} else {
v = w % (c-1);
}
} else {
v = w;
}
// LOG(INFO) << "i = " << i << " s = " << s <<
// " array(" << v << ") = " << array(v) <<
// " kernel(" << k << ") = " << kernel(k);
sum += array(v) * kernel(k);
}
result(i) = sum;
}
} else if (array.n_elem == 1) {
result(0) = array(0);
// LOG(INFO) << "Array size = 1 -> input: " << array(0) << " result: " << result(0);
}
}
template <typename _ArrayType>
inline void _circular_conv1d(_ArrayType& result, const _ArrayType& array, const arma::vec& kernel) {
// Circular convolution help for vertical stage
// | |
// 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2
// 0 1 2 3 4 3 2 1 0
// -4 -3 -2 -1 0 1 2 3 4
if (array.n_elem > 1) {
const double n_elem = static_cast<double>(kernel.n_elem);
const int32_t kmin = -static_cast<int32_t>(std::floor(n_elem/2.0));
// LOG(INFO) << "Array size = " << array.n_elem << " Centered kernel min index = " << kmin;
// Make circular convolution
for (int32_t i = 0; i < static_cast<int32_t>(array.n_elem); i++) {
double sum = 0;
for (int32_t s = kmin, k = 0; k < static_cast<int32_t>(kernel.n_elem); s++, k++) {
const uint32_t v = (array.n_elem + i + s) % array.n_elem;
// LOG(INFO) << "i = " << i << " s = " << s <<
// " array(" << v << ") = " << array(v) <<
// " kernel(" << k << ") = " << kernel(k);
sum += array(v) * kernel(k);
}
result(i) = sum;
}
} else if (array.n_elem == 1) {
result(0) = array(0);
// LOG(INFO) << "Array size = 1 -> input: " << array(0) << " result: " << result(0);
}
}
inline arma::rowvec conv1d(const arma::rowvec& array, const arma::vec& kernel, conv1d_type_t type) {
arma::rowvec result = arma::rowvec(array.n_elem);
if (type == CIRCULAR) {
_circular_conv1d(result, array, kernel);
} else if (type == SYMMETRIC) {
_symmetric_conv1d(result, array, kernel);
} else {
throw std::invalid_argument("Convolution type can be only SYMMETRIC or CIRCULAR");
}
return result;
}
inline arma::colvec conv1d(const arma::colvec& array, const arma::vec& kernel, conv1d_type_t type) {
arma::colvec result = arma::colvec(array.n_elem);
if (type == CIRCULAR) {
_circular_conv1d(result, array, kernel);
} else if (type == SYMMETRIC) {
_symmetric_conv1d(result, array, kernel);
} else {
throw std::invalid_argument("Convolution type can be only SYMMETRIC or CIRCULAR");
}
return result;
}
inline arma::cube conv1d(const arma::cube& array, const arma::vec& kernel, conv1d_type_t type) {
if ((array.n_rows == 1 && array.n_cols == 1) ||
(array.n_rows == 1 && array.n_slices == 1) ||
(array.n_cols == 1 && array.n_slices == 1))
{
arma::cube result = arma::cube(array.n_rows, array.n_cols, array.n_slices);
if (type == CIRCULAR) {
_circular_conv1d(result, array, kernel);
} else if (type == SYMMETRIC) {
_symmetric_conv1d(result, array, kernel);
} else {
throw std::invalid_argument("Convolution type can be only SYMMETRIC or CIRCULAR");
}
return result;
} else {
throw std::invalid_argument("One dimension circular convolution can be performed only on vectors");
}
}
}
#endif /* OPL_CONV_H_ */
================================================
FILE: OptolithiumC/include/opl_eikonal.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPL_EIKONAL_H_
#define OPL_EIKONAL_H_
#if !defined( SWIG )
// SWIG should not see #include <armadillo> as it can not handle it
#include <armadillo>
#include <FMM_API.h>
#endif
namespace eikonal {
void _chk_eikonal_status(int status) {
if (status != LSM_FMM_ERR_SUCCESS) {
std::string error_string;
if (status == LSM_FMM_ERR_FMM_DATA_CREATION_ERROR) {
error_string = "Data creation error";
} else if (status == LSM_FMM_ERR_INVALID_SPATIAL_DISCRETIZATION_ORDER) {
error_string = "Invalid spatial discretization order";
} else {
error_string = "General error";
}
throw std::runtime_error("Solving eikonal failed: " + error_string);
}
}
// result must contain initial state
void solve2d(arma::mat& result, const arma::mat& rates, double row_step, double col_step) {
const int sizes[2] = { static_cast<int>(rates.n_rows), static_cast<int>(rates.n_cols) };
const double grid[2] = { col_step, row_step };
const int derivative_order = 2;
double *mask = nullptr;
double *phi = reinterpret_cast<LSMLIB_REAL*>(&result(0, 0));
const double *speed = reinterpret_cast<const LSMLIB_REAL*>(&rates(0, 0));
int status = solveEikonalEquation2d(phi, speed, mask, derivative_order, sizes, grid);
_chk_eikonal_status(status);
}
// result must contain initial state
void solve3d(arma::cube& result, const arma::cube& rates, double row_step, double col_step, double slice_step) {
int sizes[3] = { static_cast<int>(rates.n_rows),
static_cast<int>(rates.n_cols), static_cast<int>(rates.n_slices) };
double grid[3] = { row_step, col_step, slice_step };
int derivative_order = 2;
double *mask = nullptr;
double *phi = reinterpret_cast<LSMLIB_REAL*>(&result(0, 0, 0));
const double *speed = reinterpret_cast<const LSMLIB_REAL*>(&rates(0, 0, 0));
int status = solveEikonalEquation3d(phi, speed, mask, derivative_order, sizes, grid);
_chk_eikonal_status(status);
}
}
#endif /* OPL_EIKONAL_H_ */
================================================
FILE: OptolithiumC/include/opl_fft.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#include "opl_log.h"
#include <stdint.h>
#if !defined(SWIG)
// SWIG should not see #include <armadillo> as it can not handle it
#include <armadillo>
#endif
#if defined(OPTOLITHIUMC_USE_FFTW_LIBRARY)
#include <fftw3.h>
#elif defined(OPTOLITHIUMC_USE_KISSFFT_LIBRARY)
#include <kiss_fftnd.h>
#include <kiss_fft.h>
#elif defined(OPTOLITHIUMC_USE_FOURIER_LIBRARY)
#include <fourier.h>
#else
#error "OPTOLITHIUMC_USE_KISSFFT_LIBRARY or OPTOLITHIUMC_USE_FFTW_LIBRARY must be set!"
#endif
namespace fft {
enum direction_t {FFT_BACKWARD, FFT_FORWARD};
class TransformInterface2d {
public:
// TransformInterface2d(arma::cx_mat &array, direction_t dir, int32_t n_times=-1) { }
virtual void execute(void) = 0;
virtual ~TransformInterface2d() { };
};
#if defined(OPTOLITHIUMC_USE_FFTW_LIBRARY)
#define FFTW_METHOD_THRESHOLD 100
typedef fftw_plan fft_plan_t;
class FFTW2d {
private:
fft_plan_t _plan;
fftw_complex *_raw_ptr;
public:
FFTW2d(arma::cx_mat &array, direction_t dir, int32_t n_times = -1) {
int fftw_dir = (dir == FFT_FORWARD) ? FFTW_FORWARD : FFTW_BACKWARD;
this->_raw_ptr = reinterpret_cast<fftw_complex *>(&array(0, 0));
{TIMED_SCOPE(aerial_image_fftw_plan, "Create fftw transform plan");
const uint32_t method = (uint32_t) (n_times > FFTW_METHOD_THRESHOLD ? FFTW_MEASURE : FFTW_ESTIMATE);
this->_plan = fftw_plan_dft_2d(array.n_cols, array.n_rows, this->_raw_ptr, this->_raw_ptr, fftw_dir, method);
}
}
~FFTW2d() {
fftw_destroy_plan(this->_plan);
}
void execute(void) {
{TIMED_SCOPE(aerial_image_timer_fftw, "FFTW calculation done");
fftw_execute(this->_plan);
}
}
};
typedef FFTW2d FFT2d;
#elif defined(OPTOLITHIUMC_USE_KISSFFT_LIBRARY)
class KissFFT2d : public TransformInterface2d {
private:
kiss_fftnd_cfg _cfg;
kiss_fft_cpx *_out_buf;
kiss_fft_cpx *_raw_ptr;
uint32_t _buf_size;
uint32_t _n_elem;
public:
KissFFT2d(arma::cx_mat &array, direction_t dir, int32_t n_times = -1) {
printf("n_cols = %d, n_rows = %d\n", array.n_cols, array.n_rows);
const int ndims = 2;
const int dims[2] = {static_cast<int>(array.n_cols), static_cast<int>(array.n_rows)};
// const int dims[2] = {static_cast<int>(array.n_rows), static_cast<int>(array.n_cols)};
int is_inverse = (dir == FFT_BACKWARD) ? 1 : 0;
this->_raw_ptr = reinterpret_cast<kiss_fft_cpx*>(&array(0, 0));
// this->_n_elem = array.n_cols * array.n_rows;
// this->_buf_size = static_cast<uint32_t>(this->_n_elem*sizeof(kiss_fft_cpx));
// this->_out_buf = static_cast<kiss_fft_cpx*>(malloc(this->_buf_size));
this->_cfg = kiss_fftnd_alloc(dims, ndims, is_inverse, NULL, NULL);
}
~KissFFT2d() {
kiss_fft_free(this->_cfg);
free(this->_out_buf);
}
void execute(void) {
{TIMED_SCOPE(aerial_image_timer_fftw, "KissFFT calculation done");
// printf("================================================================\n");
// kiss_fft_cpx zero;
// zero.r = 0.0;
// zero.i = 0.0;
// kiss_fft_cpx tmp = this->_raw_ptr[0];
// this->_raw_ptr[0] = this->_raw_ptr[159];
// this->_raw_ptr[1] = tmp;
// this->_raw_ptr[159] = tmp;
// this->_raw_ptr[158] = zero;
// memcpy(this->_out_buf, this->_raw_ptr, this->_buf_size);
// for (uint32_t k = 0; k < this->_n_elem; k++) {
// printf("v[%d] = %.5f %.5fi\n", k, this->_out_buf[k].r, this->_out_buf[k].i);
// }
// memset(this->_out_buf, 0, this->_buf_size);
kiss_fftnd(this->_cfg, this->_raw_ptr, this->_raw_ptr);
// for (uint32_t k = 0; k < this->_n_elem; k++) {
// this->_out_buf[k].r /= this->_n_elem;
// this->_out_buf[k].i /= this->_n_elem;
// }
// printf("--------------------------------------------------------------\n");
//
// for (uint32_t k = 0; k < this->_n_elem; k++) {
// printf("v[%d] = %.5f %.5fi\n", k, this->_out_buf[k].r, this->_out_buf[k].i);
// }
// memcpy(this->_raw_ptr, this->_out_buf, this->_buf_size);
}
}
};
typedef KissFFT2d FFT2d;
#elif defined(OPTOLITHIUMC_USE_FOURIER_LIBRARY)
class Fourier2d {
private:
fft_plan_t* _plan;
fft_complex_t * _raw_ptr;
public:
Fourier2d(arma::cx_mat &array, direction_t dir, int32_t n_times = -1) {
int fft_dir = (dir == FFT_FORWARD) ? FFT_LITHO_FORWARD : FFT_LITHO_BACKWARD;
this->_raw_ptr = reinterpret_cast<fft_complex_t *>(&array(0, 0));
this->_plan = fft_plan_create_2d(
array.n_rows, array.n_cols, this->_raw_ptr, this->_raw_ptr,
fft_dir, FFT_USE_CACHE | FFT_USE_RADIX2_TABLE);
}
~Fourier2d() {
fft_plan_destroy(this->_plan);
}
void execute(void) {
{TIMED_SCOPE(aerial_image_timer_fftw, "FFT calculation done");
fft_execute_2d(this->_plan);
}
}
};
typedef Fourier2d FFT2d;
#endif
}
================================================
FILE: OptolithiumC/include/opl_geometry.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPL_GEOMETRY_H_
#define OPL_GEOMETRY_H_
#include <stdlib.h>
#include <cmath>
#include <vector>
#include <list>
#include <memory>
#include "opl_log.h"
#include "opl_iter.h"
#if !defined( SWIG )
// SWIG should not see #include <armadillo> as it can not handle it
#include <armadillo>
#endif
#if !defined(M_PI) && !defined(SWIG)
// Shit C++11 standard where not defined in math but this constant defined
#define M_E 2.7182818284590452354
#define M_LOG2E 1.4426950408889634074
#define M_LOG10E 0.43429448190325182765
#define M_LN2 0.69314718055994530942
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.78539816339744830962
#define M_1_PI 0.31830988618379067154
#define M_2_PI 0.63661977236758134308
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT1_2 0.70710678118654752440
#endif
namespace geometry {
typedef enum {
LEFT = 0,
RIGHT = 1,
BEYOND = 2,
BEHIND = 3,
BETWEEN = 4,
ORIGIN = 5,
DESTINATION = 6,
} classify_type_t;
typedef enum {
COLLINEAR = 0,
PARALLEL = 1,
SKEW = 2,
SKEW_NO_CROSS = 3,
SKEW_CROSS =4,
} cross_type_t;
typedef enum {
CW = 1,
CCW = -1,
} rotation_type_t;
typedef enum {
DIM_1D_X = 0,
DIM_1D_Y = 1,
DIM_2D = 2
} dimension_t;
typedef enum {
GEOMETRY_POLYGON = 0,
GEOMETRY_BOX = 1
} geometry_t;
#define DEFAULT_CLASSIFY_PRECISION 1e-2
class Edge2d;
class Point2d {
public:
double x;
double y;
Point2d(double x=0.0, double y=0.0) : x(x), y(y) { }
Point2d(const Point2d& other) : x(other.x), y(other.y) { }
Point2d operator+(const Point2d& p) const;
Point2d operator+(double s) const;
Point2d operator-(const Point2d& p) const;
Point2d operator-(double s) const;
double& operator[](uint32_t i);
double operator[](uint32_t i) const;
bool operator==(const Point2d& p) const;
bool operator!=(const Point2d& p) const;
bool operator<(const Point2d& p) const;
bool operator>(const Point2d& p) const;
Point2d& operator+=(const Point2d& rhs);
Point2d& operator-=(const Point2d& rhs);
Point2d& abs(void);
classify_type_t classify(const Point2d& p0, const Point2d& p1,
double precision=DEFAULT_CLASSIFY_PRECISION) const;
classify_type_t classify(const Edge2d&, double precision=DEFAULT_CLASSIFY_PRECISION) const;
double polar_angle(void) const;
double length(void) const;
Point2d normal_intersect(const Edge2d&) const;
double distance(const Edge2d&) const;
void transform(int32_t sign, double mag, double angle);
std::string str(void) const;
};
Point2d operator* (double s, const Point2d& p);
Point2d operator/ (const Point2d& p, double s);
double dot(const Point2d& p, const Point2d& q);
typedef Point2d Sizes;
class Edge2d {
public:
Point2d org;
Point2d dst;
Edge2d(double org_x, double org_y, double dst_x, double dst_y) :
org(Point2d(org_x, org_y)), dst(Point2d(dst_x, dst_y)) { }
Edge2d(const Point2d& org, const Point2d& dst) : org(org), dst(dst) { }
Edge2d& rot(rotation_type_t dir=CCW);
Edge2d& flip(void);
cross_type_t intersect(const Edge2d& e, double &t) const;
// Return intersection point between 'this' edge and edge represented as 't' value (line direction)
Point2d point(double t) const;
// Return intersection point between 'this' edge and given edge 'e'
Point2d point(const Edge2d& e) const;
cross_type_t cross_type(const Edge2d& e) const;
bool is_vertical(void) const;
bool is_horizontal(void) const;
double dx(void) const;
double dy(void) const;
Sizes sizes(void) const;
double length(void) const;
double slope(void) const;
double y(double x) const;
// Calculate the area of trapezoid between this edge, y-axis and two horizontal lines.
double area(void) const;
std::string str(void) const;
bool operator==(const Edge2d& other) const;
};
typedef std::shared_ptr<Point2d> SharedPoint2d;
typedef std::vector<SharedPoint2d> ArrayOfSharedPoints2d;
typedef std::shared_ptr<Edge2d> SharedEdge2d;
typedef std::shared_ptr<const Edge2d> ConstSharedEdge2d;
typedef std::vector<SharedEdge2d> ArrayOfSharedEdges2d;
class AbstractGeometry : public Iterable::Interface<SharedEdge2d> {
protected:
ArrayOfSharedEdges2d _edges;
dimension_t _axis;
public:
virtual geometry_t type(void) const = 0;
virtual bool operator==(const AbstractGeometry &other) const = 0;
virtual std::string str(void) const = 0;
virtual bool is_mask(void) const {
return false;
}
SharedEdge2d at(uint32_t index) const;
uint32_t length(void) const;
double signed_area(void) const;
virtual bool set_bypass(rotation_type_t direction);
dimension_t axis(void) const;
};
typedef std::shared_ptr<AbstractGeometry> SharedAbstractGeomtery;
typedef std::vector<SharedAbstractGeomtery> ArrayOfSharedAbstractGeomtery;
class PolygonGeometry : public virtual AbstractGeometry {
public:
// Check whether input points represent one dimensional polygon
static bool is_1d_possible(const ArrayOfSharedPoints2d &points);
static bool is_2d_possible(const ArrayOfSharedPoints2d &points);
PolygonGeometry(const ArrayOfSharedPoints2d &points);
PolygonGeometry(const PolygonGeometry& other);
bool clean(void);
geometry_t type(void) const;
bool operator==(const AbstractGeometry &other) const;
std::string str(void) const;
};
typedef std::shared_ptr<PolygonGeometry> SharedPolygon;
typedef std::vector<SharedPolygon> ArrayOfSharedPolygons;
class RectangleGeometry : public virtual AbstractGeometry {
private:
Edge2d _diag;
Sizes _sizes;
public:
RectangleGeometry(const Point2d& lb, const Point2d& rt);
RectangleGeometry(ArrayOfSharedPoints2d points);
RectangleGeometry(const RectangleGeometry& other);
Point2d left_bottom(void) const;
Point2d right_top(void) const;
Edge2d diag(void) const;
Sizes sizes(void) const;
bool set_bypass(rotation_type_t direction);
geometry_t type(void) const;
bool operator==(const AbstractGeometry& other) const;
std::string str(void) const;
};
class Point3d {
public:
double x;
double y;
double z;
Point3d(double x=0.0, double y=0.0, double z=0.0) : x(x), y(y), z(z) { }
Point3d(const Point3d& other) : x(other.x), y(other.y), z(other.z) { }
Point3d operator+(const Point3d& p) const;
Point3d operator+(double s) const;
Point3d operator-(const Point3d& p) const;
Point3d operator-(double s) const;
double& operator[](uint32_t i);
double operator[](uint32_t i) const;
bool operator==(const Point3d& p) const;
bool operator!=(const Point3d& p) const;
bool operator<(const Point3d& p) const;
bool operator>(const Point3d& p) const;
Point3d& operator+=(const Point3d& rhs);
Point3d& operator-=(const Point3d& rhs);
Point3d& abs(void);
double length(void) const;
std::string str(void) const;
};
Point3d operator* (double s, const Point3d& p);
Point3d operator/ (const Point3d& p, double s);
double dot(const Point3d& p, const Point3d& q);
typedef std::shared_ptr<Point3d> SharedPoint3d;
typedef std::shared_ptr<const Point3d> ConstSharedPoint3d;
typedef std::vector<SharedPoint3d> ArrayOfSharedPoints3d;
class Edge3d {
public:
Point3d org;
Point3d dst;
Edge3d(double org_x, double org_y, double org_z, double dst_x, double dst_y, double dst_z) :
org(Point3d(org_x, org_y, org_z)), dst(Point3d(dst_x, dst_y, dst_z)) { }
Edge3d(const Point3d& org, const Point3d& dst) : org(org), dst(dst) { }
double length(void) const;
std::string str(void) const;
bool operator==(const Edge3d& other) const;
};
double dot(const Edge3d& p, const Edge3d& q);
Point3d cross(const Edge3d& p, const Edge3d& q);
typedef std::shared_ptr<Edge3d> SharedEdge3d;
typedef std::vector<SharedEdge3d> ArrayOfSharedEdges3d;
class Triangle3d : public Iterable::Interface<SharedPoint3d> {
private:
SharedPoint3d _a, _b, _c;
public:
Triangle3d(SharedPoint3d a, SharedPoint3d b, SharedPoint3d c) : _a(a), _b(b), _c(c) { }
Triangle3d(const Point3d& a, const Point3d& b, const Point3d& c);
uint32_t length(void) const {
return 3;
}
bool operator==(const Triangle3d &other) const;
std::string str(void) const;
SharedPoint3d at(uint32_t index) const;
Point3d& operator[](uint32_t i);
Point3d operator[](uint32_t i) const;
SharedPoint3d normal(void) const;
SharedPoint3d a(void) const {
return this->_a;
}
SharedPoint3d b(void) const {
return this->_b;
}
SharedPoint3d c(void) const {
return this->_c;
}
};
typedef std::shared_ptr<Triangle3d> SharedTriangle3d;
typedef std::vector<SharedTriangle3d> ArrayOfSharedTriangles3d;
class Surface3d {
private:
bool _is_finalized;
ArrayOfSharedPoints3d _points;
ArrayOfSharedTriangles3d _triangles;
std::shared_ptr<arma::vec> _x;
std::shared_ptr<arma::vec> _y;
std::shared_ptr<arma::vec> _z;
public:
Surface3d() {
this->_is_finalized = false;
};
Surface3d(ArrayOfSharedPoints3d points, ArrayOfSharedTriangles3d triangles);
bool add_point(SharedPoint3d point) {
if (!this->_is_finalized) {
this->_points.push_back(point);
return true;
} else {
return false;
}
}
bool add_triangle(SharedTriangle3d triangle) {
if (!this->_is_finalized) {
this->_triangles.push_back(triangle);
return true;
} else {
return false;
}
}
void generate_xyz(void);
ArrayOfSharedPoints3d points(void) const;
ArrayOfSharedTriangles3d triangles(void) const;
std::shared_ptr<arma::vec> x(void) const;
std::shared_ptr<arma::vec> y(void) const;
std::shared_ptr<arma::vec> z(void) const;
};
typedef std::shared_ptr<Surface3d> SharedSurface3d;
}
#endif /* OPL_GEOMETRY_H_ */
================================================
FILE: OptolithiumC/include/opl_interp.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPL_INTERP_H_
#define OPL_INTERP_H_
#include <memory>
#if !defined( SWIG )
// SWIG should not see #include <armadillo> as it can not handle it
#include <armadillo>
#endif
namespace interp {
typedef std::shared_ptr<const arma::vec> ConstVector;
typedef std::shared_ptr<const arma::mat> ConstMatrix;
typedef std::shared_ptr<arma::vec> Vector;
class LinearInterpolation1d {
private:
ConstVector _px; // Input array x
ConstVector _py; // Input array y - values
Vector _b; // Additive coefficient of line
Vector _s; // Slope of line
double _fill;
public:
LinearInterpolation1d(void) : _fill(0.0) { };
LinearInterpolation1d(ConstVector px, ConstVector py, double fill=0.0);
double interpolate(double xi) const;
std::shared_ptr<arma::vec> interpolate(const arma::vec& xi) const;
std::shared_ptr<const arma::vec> x(void) const {
return this->_px;
}
std::shared_ptr<const arma::vec> y(void) const {
return this->_py;
}
bool operator==(const LinearInterpolation1d& other) const;
};
typedef std::shared_ptr<LinearInterpolation1d> SharedLinearInterpolation1d;
class LinearInterpolation2d {
private:
ConstVector _px;
ConstVector _py;
ConstMatrix _values;
double _fill;
SharedLinearInterpolation1d _xlastinterp1;
std::vector<SharedLinearInterpolation1d> _yinterp1;
public:
LinearInterpolation2d(void) : _fill(0.0) { };
LinearInterpolation2d(ConstVector px, ConstVector py, ConstMatrix values, double fill=0.0);
double interpolate(double xi, double yi) const;
std::shared_ptr<arma::mat> interpolate(const arma::vec& xi, const arma::vec& yi) const;
std::shared_ptr<const arma::vec> x(void) const {
return this->_px;
}
std::shared_ptr<const arma::vec> y(void) const {
return this->_py;
}
std::shared_ptr<const arma::mat> values(void) const {
return this->_values;
}
bool operator==(const LinearInterpolation2d& other) const;
};
typedef std::shared_ptr<LinearInterpolation2d> SharedLinearInterpolation2d;
}
#endif /* OPL_INTERP_H_ */
================================================
FILE: OptolithiumC/include/opl_iter.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef ITERABLE_H_
#define ITERABLE_H_
#include <stdint.h>
#include <opl_log.h>
namespace Iterable
{
inline uint32_t indx(int32_t k, int32_t len) {
return static_cast<uint32_t>((k < 0) ? (len + k) % len : k % len);
}
template <class object_t>
class Interface;
template <class object_t>
class Iterator
{
private:
uint32_t _pos;
const Interface<object_t> *_container;
public:
Iterator(const Interface<object_t>* p_vec, uint32_t pos): _pos(pos), _container(p_vec){ }
uint32_t pos(void) const {
return this->_pos;
}
// these three methods form the basis of an iterator for use with a range-based for loop
bool operator!= (const Iterator& other) const {
return this->_pos != other._pos;
}
object_t operator*(void) const {
return this->_container->at(indx(this->_pos, this->_container->length()));
}
const Iterator& operator++ () {
++_pos;
// although not strictly necessary for a range-based for loop
// following the normal convention of returning a value from
// operator++ is a good idea.
return *this;
}
Iterator begin(void) const {
return this->_container->begin();
}
Iterator end(void) const {
return this->_container->end();
}
Iterator next(void) const {
return Iterator(this->_container, indx(this->_pos+1, this->_container->length()));
}
Iterator prev(void) const {
return Iterator(this->_container, indx(this->_pos-1, this->_container->length()));
}
};
template <class object_t>
class Interface
{
public:
virtual ~Interface() {};
virtual Iterator<object_t> begin(void) const {
return Iterator<object_t>(this, 0);
}
virtual Iterator<object_t> end(void) const {
return Iterator<object_t>(this, this->length());
}
virtual object_t front(void) const {
return this->at(0);
}
virtual object_t back(void) const {
return this->at(this->length()-1);
}
virtual object_t at(uint32_t index) const = 0;
virtual uint32_t length(void) const = 0;
};
}
#endif /* ITERABLE_H_ */
================================================
FILE: OptolithiumC/include/opl_log.h
================================================
/*
* opl_log.h
*
* Created on: Jul 22, 2014
* Author: batman
*/
#ifndef OPL_LOG_H_
#define OPL_LOG_H_
#include <easylogging++.h>
class OptolithiumCoreLog {
public:
OptolithiumCoreLog(void);
virtual ~OptolithiumCoreLog(void);
void set_verbose_level(int level);
void log(const std::string &message);
void vlog(const std::string &message, int level=4);
};
#endif /* OPL_LOG_H_ */
================================================
FILE: OptolithiumC/include/opl_misc.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPL_MISC_H_
#define OPL_MISC_H_
#if !defined(SWIG)
namespace misc {
inline void swap(double& a, double& b) {
double tmp = b;
b = a;
a = tmp;
}
inline double round_to(double value, double precision) {
return round(value / precision) * precision;
}
template <class cls>
inline bool safe_vector_equal(
const std::vector<std::shared_ptr<cls>>& v1,
const std::vector<std::shared_ptr<cls>>& v2) {
return v1.size() == v2.size() && std::equal(v1.begin(), v1.end(), v2.begin(),
[] (const std::shared_ptr<cls>& a, const std::shared_ptr<cls>& b) -> bool {return *a == *b;});
}
// Rotate arma::mat counter-clockwise
template <class cls>
inline cls rot90(cls array) {
cls result = cls(array.n_cols, array.n_rows);
for (uint32_t r = 0; r < array.n_rows; r++) {
for (uint32_t c = 0; c < array.n_cols; c++) {
result(array.n_cols - c - 1, r) = array(r, c);
}
}
return result;
}
}
#endif
#endif /* OPL_MISC_H_ */
================================================
FILE: OptolithiumC/include/opl_physc.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPL_PHYSC_H_
#define OPL_PHYSC_H_
#include <complex>
namespace physc {
// Ideal gas constant (kcal/K/mol)
constexpr double R = 1.987204118e-3;
// Absolute zero temperature (C)
constexpr double T0 = -273.15;
// Refractive index in air
constexpr std::complex<double> air_nk = std::complex<double>(1.0002926, 0.0);
// Speed of Light (m/s)
constexpr double c = 299792458;
}
#endif /* OPL_PHYSC_H_ */
================================================
FILE: OptolithiumC/include/opl_sim.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPL_SIM_H_
#define OPL_SIM_H_
#include "opl_capi.h"
using namespace oplc;
SharedDiffraction diffraction(SharedImagingTool imaging_tools, SharedMask mask);
SharedResistVolume aerial_image(SharedDiffraction diffraction, SharedOpticalTransferFunction otf, double stepxy);
SharedResistVolume image_in_resist(SharedDiffraction diffraction,
SharedOpticalTransferFunction otf, double stepxy, double stepz);
SharedResistVolume latent_image(SharedResistVolume image_in_resist,
SharedResistWaferLayer resist, SharedExposure exposure);
SharedResistVolume peb_latent_image(SharedResistVolume latent_image,
SharedResistWaferLayer resist, SharedPostExposureBake peb);
SharedResistVolume develop_time_contours(SharedResistVolume peb_latent_image, SharedResistWaferLayer resist);
SharedResistProfile resist_profile(SharedResistVolume develop_times, SharedDevelopment development);
#endif /* OPL_SIM_H_ */
================================================
FILE: OptolithiumC/include/optolithium.h
================================================
/*
*
* This file is part of Optolithium lithography modelling software.
*
* Copyright (C) 2015 Alexei Gladkikh
*
* This software is dual-licensed: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version only for NON-COMMERCIAL usage.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* If you are interested in other licensing models, including a commercial-
* license, please contact the author at gladkikhalexei@gmail.com
*
*/
#ifndef OPTOLITHIUM_SDK_H_
#define OPTOLITHIUM_SDK_H_
#include <stdlib.h>
#include <math.h>
#include <float.h>
#include <complex.h>
#if defined _WIN32 || defined __CYGWIN__
#ifdef __GNUC__
#define DLL_PUBLIC __attribute__ ((dllexport))
#else
#define DLL_PUBLIC __declspec(dllexport) // Note: actually gcc seems to also supports this syntax.
#endif
#define DLL_LOCAL
#else
#if __GNUC__ >= 4
#define DLL_PUBLIC __attribute__ ((visibility ("default")))
#define DLL_LOCAL __attribute__ ((visibility ("hidden")))
#else
#define DLL_PUBLIC
#define DLL_LOCAL
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
// Plugin type description
typedef enum {
PLUGIN_MASK = 0,
PLUGIN_DEVELOPMENT_MODEL = 1,
PLUGIN_SOURCE_SHAPE = 2,
PLUGIN_ILLUMINATION = 3,
PLUGIN_MATERIAL = 4,
PLUGIN_PUPIL_FILTER = 5,
} plugin_type_t;
// Plugin entry point type: this structure must export each shared library to being plugin
typedef struct {
plugin_type_t plugin_type;
const void* plugin_entry;
} plugin_descriptor_t;
#define INT(value) (int[]){value}
#define DBL(value) (double[]){value}
typedef struct {
const char *name;
double defv;
double *min;
double *max;
} standard_plugin_arg_t;
// ====================================================================================================================
// Development model plugin descriptions types
// ====================================================================================================================
typedef double (*rate_model_expr_t)(double pac, double depth, const void *args);
typedef standard_plugin_arg_t dev_model_arg_t;
typedef struct {
const int *prolith_id;
const char *name;
const char *desc;
rate_model_expr_t expression;
const int args_count;
const dev_model_arg_t (*args)[];
} dev_model_t;
// ====================================================================================================================
// Mask plugin descriptions types
// ====================================================================================================================
typedef enum {
MASK_TYPE_1D = 1,
MASK_TYPE_2D = 2
} mask_type_t;
typedef struct {
double x;
double y;
} mask_point_t;
typedef struct {
double transmittance;
double phase;
int length;
mask_point_t *points;
} mask_region_t;
typedef struct {
mask_region_t boundary;
int regions_count;
mask_region_t *regions;
} mask_t;
typedef int (*mask_create_t)(mask_t *mask, void *parameters);
typedef standard_plugin_arg_t mask_parameter_t;
typedef struct {
const char *name;
const char *desc;
const mask_type_t type;
mask_create_t create;
const int parameters_count;
const mask_parameter_t (*parameters)[];
} mask_plugin_t;
// ====================================================================================================================
// Source shape plugin interface
// ====================================================================================================================
typedef double (*source_shape_expr_t)(double sx, double sy, const void *args);
typedef standard_plugin_arg_t source_shape_arg_t;
typedef struct {
const char *name;
const char *desc;
source_shape_expr_t expression;
const int args_count;
const source_shape_arg_t (*args)[];
} source_shape_plugin_t;
// ====================================================================================================================
// Pupil filter plugin interface
// ====================================================================================================================
typedef double _Complex (*pupil_filter_expr_t)(double cx, double cy, const void *args);
typedef standard_plugin_arg_t pupil_filter_arg_t;
typedef struct {
const char *name;
const char *desc;
pupil_filter_expr_t expression;
const int args_count;
const pupil_filter_arg_t (*args)[];
} pupil_filter_plugin_t;
#ifdef __cplusplus
}
#endif
#endif /*OPTOLITHIUM_SDK_H_*/
================================================
FILE: OptolithiumC/libs/armadillo/include/armadillo
================================================
// Copyright (C) 2008-2015 Conrad Sanderson
// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef ARMA_INCLUDES
#define ARMA_INCLUDES
#include <cstdlib>
#include <cstring>
#include <climits>
#include <cmath>
#include <ctime>
#include <cstdio>
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <new>
#include <limits>
#include <algorithm>
#include <complex>
#include <vector>
#if ( defined(__unix__) || defined(__unix) || defined(_POSIX_C_SOURCE) || (defined(__APPLE__) && defined(__MACH__)) ) && !defined(_WIN32)
#include <unistd.h>
#endif
#if (defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L))
#include <sys/time.h>
#endif
#if (__cplusplus >= 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X__)
#undef ARMA_USE_CXX11
#define ARMA_USE_CXX11
#endif
#include "armadillo_bits/config.hpp"
#include "armadillo_bits/compiler_setup.hpp"
#if defined(ARMA_USE_CXX11)
#include <initializer_list>
#include <cstdint>
#include <random>
#if !defined(ARMA_DONT_USE_CXX11_CHRONO)
#include <chrono>
#endif
#endif
#if defined(ARMA_USE_TBB_ALLOC)
#include <tbb/scalable_allocator.h>
#endif
#if defined(ARMA_USE_MKL_ALLOC)
#include <mkl_service.h>
#endif
#if !defined(ARMA_USE_CXX11)
#if defined(ARMA_HAVE_TR1)
#include <tr1/cmath>
#include <tr1/complex>
#endif
#endif
#include "armadillo_bits/include_atlas.hpp"
#include "armadillo_bits/include_hdf5.hpp"
#include "armadillo_bits/include_superlu.hpp"
#if defined(_OPENMP)
#include <omp.h>
#endif
//! \namespace arma namespace for Armadillo classes and functions
namespace arma
{
// preliminaries
#include "armadillo_bits/forward_bones.hpp"
#include "armadillo_bits/arma_static_check.hpp"
#include "armadillo_bits/typedef_elem.hpp"
#include "armadillo_bits/typedef_elem_check.hpp"
#include "armadillo_bits/typedef_mat.hpp"
#include "armadillo_bits/arma_boost.hpp"
#include "armadillo_bits/arma_version.hpp"
#include "armadillo_bits/arma_config.hpp"
#include "armadillo_bits/traits.hpp"
#include "armadillo_bits/promote_type.hpp"
#include "armadillo_bits/upgrade_val.hpp"
#include "armadillo_bits/restrictors.hpp"
#include "armadillo_bits/access.hpp"
#include "armadillo_bits/span.hpp"
#include "armadillo_bits/distr_param.hpp"
#include "armadillo_bits/constants.hpp"
#include "armadillo_bits/constants_compat.hpp"
#ifdef ARMA_RNG_ALT
#include ARMA_INCFILE_WRAP(ARMA_RNG_ALT)
#else
#include "armadillo_bits/arma_rng_cxx98.hpp"
#endif
#include "armadillo_bits/arma_rng_cxx11.hpp"
#include "armadillo_bits/arma_rng.hpp"
//
// class prototypes
#include "armadillo_bits/Base_bones.hpp"
#include "armadillo_bits/BaseCube_bones.hpp"
#include "armadillo_bits/SpBase_bones.hpp"
#include "armadillo_bits/blas_bones.hpp"
#include "armadillo_bits/lapack_bones.hpp"
#include "armadillo_bits/atlas_bones.hpp"
#include "armadillo_bits/arpack_bones.hpp"
#include "armadillo_bits/superlu_bones.hpp"
#include "armadillo_bits/hdf5_bones.hpp"
#include "armadillo_bits/blas_wrapper.hpp"
#include "armadillo_bits/lapack_wrapper.hpp"
#include "armadillo_bits/atlas_wrapper.hpp"
#include "armadillo_bits/arpack_wrapper.hpp"
#include "armadillo_bits/superlu_wrapper.hpp"
#include "armadillo_bits/cond_rel_bones.hpp"
#include "armadillo_bits/arrayops_bones.hpp"
#include "armadillo_bits/podarray_bones.hpp"
#include "armadillo_bits/auxlib_bones.hpp"
#include "armadillo_bits/sp_auxlib_bones.hpp"
#include "armadillo_bits/injector_bones.hpp"
#include "armadillo_bits/Mat_bones.hpp"
#include "armadillo_bits/Col_bones.hpp"
#include "armadillo_bits/Row_bones.hpp"
#include "armadillo_bits/Cube_bones.hpp"
#include "armadillo_bits/xvec_htrans_bones.hpp"
#include "armadillo_bits/xtrans_mat_bones.hpp"
#include "armadillo_bits/SizeMat_bones.hpp"
#include "armadillo_bits/SizeCube_bones.hpp"
#include "armadillo_bits/SpValProxy_bones.hpp"
#include "armadillo_bits/SpMat_bones.hpp"
#include "armadillo_bits/SpCol_bones.hpp"
#include "armadillo_bits/SpRow_bones.hpp"
#include "armadillo_bits/SpSubview_bones.hpp"
#include "armadillo_bits/spdiagview_bones.hpp"
#include "armadillo_bits/typedef_mat_fixed.hpp"
#include "armadillo_bits/field_bones.hpp"
#include "armadillo_bits/subview_bones.hpp"
#include "armadillo_bits/subview_elem1_bones.hpp"
#include "armadillo_bits/subview_elem2_bones.hpp"
#include "armadillo_bits/subview_field_bones.hpp"
#include "armadillo_bits/subview_cube_bones.hpp"
#include "armadillo_bits/diagview_bones.hpp"
#include "armadillo_bits/subview_each_bones.hpp"
#include "armadillo_bits/diskio_bones.hpp"
#include "armadillo_bits/wall_clock_bones.hpp"
#include "armadillo_bits/running_stat_bones.hpp"
#include "armadillo_bits/running_stat_vec_bones.hpp"
#include "armadillo_bits/Op_bones.hpp"
#include "armadillo_bits/OpCube_bones.hpp"
#include "armadillo_bits/SpOp_bones.hpp"
#include "armadillo_bits/eOp_bones.hpp"
#include "armadillo_bits/eOpCube_bones.hpp"
#include "armadillo_bits/mtOp_bones.hpp"
#include "armadillo_bits/mtOpCube_bones.hpp"
#include "armadillo_bits/mtSpOp_bones.hpp"
#include "armadillo_bits/Glue_bones.hpp"
#include "armadillo_bits/eGlue_bones.hpp"
#include "armadillo_bits/mtGlue_bones.hpp"
#include "armadillo_bits/SpGlue_bones.hpp"
#include "armadillo_bits/GlueCube_bones.hpp"
#include "armadillo_bits/eGlueCube_bones.hpp"
#include "armadillo_bits/mtGlueCube_bones.hpp"
#include "armadillo_bits/eop_core_bones.hpp"
#include "armadillo_bits/eglue_core_bones.hpp"
#include "armadillo_bits/Gen_bones.hpp"
#include "armadillo_bits/GenCube_bones.hpp"
#include "armadillo_bits/op_diagmat_bones.hpp"
#include "armadillo_bits/op_diagvec_bones.hpp"
#include "armadillo_bits/op_dot_bones.hpp"
#include "armadillo_bits/op_inv_bones.hpp"
#include "armadillo_bits/op_htrans_bones.hpp"
#include "armadillo_bits/op_max_bones.hpp"
#include "armadillo_bits/op_min_bones.hpp"
#include "armadillo_bits/op_mean_bones.hpp"
#include "armadillo_bits/op_median_bones.hpp"
#include "armadillo_bits/op_sort_bones.hpp"
#include "armadillo_bits/op_sort_index_bones.hpp"
#include "armadillo_bits/op_sum_bones.hpp"
#include "armadillo_bits/op_stddev_bones.hpp"
#include "armadillo_bits/op_strans_bones.hpp"
#include "armadillo_bits/op_var_bones.hpp"
#include "armadillo_bits/op_repmat_bones.hpp"
#include "armadillo_bits/op_reshape_bones.hpp"
#include "armadillo_bits/op_vectorise_bones.hpp"
#include "armadillo_bits/op_resize_bones.hpp"
#include "armadillo_bits/op_cov_bones.hpp"
#include "armadillo_bits/op_cor_bones.hpp"
#include "armadillo_bits/op_shuffle_bones.hpp"
#include "armadillo_bits/op_prod_bones.hpp"
#include "armadillo_bits/op_pinv_bones.hpp"
#include "armadillo_bits/op_dotext_bones.hpp"
#include "armadillo_bits/op_flip_bones.hpp"
#include "armadillo_bits/op_princomp_bones.hpp"
#include "armadillo_bits/op_misc_bones.hpp"
#include "armadillo_bits/op_relational_bones.hpp"
#include "armadillo_bits/op_find_bones.hpp"
#include "armadillo_bits/op_chol_bones.hpp"
#include "armadillo_bits/op_cx_scalar_bones.hpp"
#include "armadillo_bits/op_trimat_bones.hpp"
#include "armadillo_bits/op_cumsum_bones.hpp"
#include "armadillo_bits/op_symmat_bones.hpp"
#include "armadillo_bits/op_hist_bones.hpp"
#include "armadillo_bits/op_unique_bones.hpp"
#include "armadillo_bits/op_toeplitz_bones.hpp"
#include "armadillo_bits/op_fft_bones.hpp"
#include "armadillo_bits/op_any_bones.hpp"
#include "armadillo_bits/op_all_bones.hpp"
#include "armadillo_bits/op_normalise_bones.hpp"
#include "armadillo_bits/op_clamp_bones.hpp"
#include "armadillo_bits/op_expmat_bones.hpp"
#include "armadillo_bits/op_nonzeros_bones.hpp"
#include "armadillo_bits/glue_times_bones.hpp"
#include "armadillo_bits/glue_mixed_bones.hpp"
#include "armadillo_bits/glue_cov_bones.hpp"
#include "armadillo_bits/glue_cor_bones.hpp"
#include "armadillo_bits/glue_kron_bones.hpp"
#include "armadillo_bits/glue_cross_bones.hpp"
#include "armadillo_bits/glue_join_bones.hpp"
#include "armadillo_bits/glue_relational_bones.hpp"
#include "armadillo_bits/glue_solve_bones.hpp"
#include "armadillo_bits/glue_conv_bones.hpp"
#include "armadillo_bits/glue_toeplitz_bones.hpp"
#include "armadillo_bits/glue_hist_bones.hpp"
#include "armadillo_bits/glue_histc_bones.hpp"
#include "armadillo_bits/glue_max_bones.hpp"
#include "armadillo_bits/glue_min_bones.hpp"
#include "armadillo_bits/spop_max_bones.hpp"
#include "armadillo_bits/spop_min_bones.hpp"
#include "armadillo_bits/spop_sum_bones.hpp"
#include "armadillo_bits/spop_strans_bones.hpp"
#include "armadillo_bits/spop_htrans_bones.hpp"
#include "armadillo_bits/spop_misc_bones.hpp"
#include "armadillo_bits/spop_mean_bones.hpp"
#include "armadillo_bits/spop_var_bones.hpp"
#include "armadillo_bits/spglue_plus_bones.hpp"
#include "armadillo_bits/spglue_minus_bones.hpp"
#include "armadillo_bits/spglue_times_bones.hpp"
#include "armadillo_bits/spglue_join_bones.hpp"
//
// low-level debugging and memory handling functions
#include "armadillo_bits/debug.hpp"
#include "armadillo_bits/memory.hpp"
//
// wrappers for various cmath functions
#include "armadillo_bits/arma_cmath.hpp"
//
// classes that underlay metaprogramming
#include "armadillo_bits/unwrap.hpp"
#include "armadillo_bits/unwrap_cube.hpp"
#include "armadillo_bits/unwrap_spmat.hpp"
#include "armadillo_bits/Proxy.hpp"
#include "armadillo_bits/ProxyCube.hpp"
#include "armadillo_bits/SpProxy.hpp"
#include "armadillo_bits/diagmat_proxy.hpp"
#include "armadillo_bits/strip.hpp"
#include "armadillo_bits/Op_meat.hpp"
#include "armadillo_bits/OpCube_meat.hpp"
#include "armadillo_bits/SpOp_meat.hpp"
#include "armadillo_bits/mtOp_meat.hpp"
#include "armadillo_bits/mtOpCube_meat.hpp"
#include "armadillo_bits/mtSpOp_meat.hpp"
#include "armadillo_bits/Glue_meat.hpp"
#include "armadillo_bits/GlueCube_meat.hpp"
#include "armadillo_bits/SpGlue_meat.hpp"
#include "armadillo_bits/eop_aux.hpp"
#include "armadillo_bits/eOp_meat.hpp"
#include "armadillo_bits/eOpCube_meat.hpp"
#include "armadillo_bits/eGlue_meat.hpp"
#include "armadillo_bits/eGlueCube_meat.hpp"
#include "armadillo_bits/mtGlue_meat.hpp"
#include "armadillo_bits/mtGlueCube_meat.hpp"
#include "armadillo_bits/Base_meat.hpp"
#include "armadillo_bits/BaseCube_meat.hpp"
#include "armadillo_bits/SpBase_meat.hpp"
#include "armadillo_bits/Gen_meat.hpp"
#include "armadillo_bits/GenCube_meat.hpp"
//
// ostream
#include "armadillo_bits/arma_ostream_bones.hpp"
#include "armadillo_bits/arma_ostream_meat.hpp"
//
// n_unique, which is used by some sparse operators
#include "armadillo_bits/fn_n_unique.hpp"
//
// operators
#include "armadillo_bits/operator_plus.hpp"
#include "armadillo_bits/operator_minus.hpp"
#include "armadillo_bits/operator_times.hpp"
#include "armadillo_bits/operator_schur.hpp"
#include "armadillo_bits/operator_div.hpp"
#include "armadillo_bits/operator_relational.hpp"
#include "armadillo_bits/operator_cube_plus.hpp"
#include "armadillo_bits/operator_cube_minus.hpp"
#include "armadillo_bits/operator_cube_times.hpp"
#include "armadillo_bits/operator_cube_schur.hpp"
#include "armadillo_bits/operator_cube_div.hpp"
#include "armadillo_bits/operator_cube_relational.hpp"
#include "armadillo_bits/operator_ostream.hpp"
//
// user accessible functions
// the order of the fn_*.hpp include files matters,
// as some files require functionality given in preceding files
#include "armadillo_bits/fn_conv_to.hpp"
#include "armadillo_bits/fn_min.hpp"
#include "armadillo_bits/fn_max.hpp"
#include "armadillo_bits/fn_accu.hpp"
#include "armadillo_bits/fn_sum.hpp"
#include "armadillo_bits/fn_diagmat.hpp"
#include "armadillo_bits/fn_diagvec.hpp"
#include "armadillo_bits/fn_inv.hpp"
#include "armadillo_bits/fn_trace.hpp"
#include "armadillo_bits/fn_trans.hpp"
#include "armadillo_bits/fn_det.hpp"
#include "armadillo_bits/fn_log_det.hpp"
#include "armadillo_bits/fn_eig_sym.hpp"
#include "armadillo_bits/fn_eig_gen.hpp"
#include "armadillo_bits/fn_eig_pair.hpp"
#include "armadillo_bits/fn_lu.hpp"
#include "armadillo_bits/fn_zeros.hpp"
#include "armadillo_bits/fn_ones.hpp"
#include "armadillo_bits/fn_eye.hpp"
#include "armadillo_bits/fn_misc.hpp"
#include "armadillo_bits/fn_find.hpp"
#include "armadillo_bits/fn_elem.hpp"
#include "armadillo_bits/fn_norm.hpp"
#include "armadillo_bits/fn_dot.hpp"
#include "armadillo_bits/fn_randu.hpp"
#include "armadillo_bits/fn_randn.hpp"
#include "armadillo_bits/fn_trig.hpp"
#include "armadillo_bits/fn_mean.hpp"
#include "armadillo_bits/fn_median.hpp"
#include "armadillo_bits/fn_stddev.hpp"
#include "armadillo_bits/fn_var.hpp"
#include "armadillo_bits/fn_sort.hpp"
#include "armadillo_bits/fn_sort_index.hpp"
#include "armadillo_bits/fn_strans.hpp"
#include "armadillo_bits/fn_chol.hpp"
#include "armadillo_bits/fn_qr.hpp"
#include "armadillo_bits/fn_svd.hpp"
#include "armadillo_bits/fn_solve.hpp"
#include "armadillo_bits/fn_repmat.hpp"
#include "armadillo_bits/fn_reshape.hpp"
#include "armadillo_bits/fn_vectorise.hpp"
#include "armadillo_bits/fn_resize.hpp"
#include "armadillo_bits/fn_cov.hpp"
#include "armadillo_bits/fn_cor.hpp"
#include "armadillo_bits/fn_shuffle.hpp"
#include "armadillo_bits/fn_prod.hpp"
#include "armadillo_bits/fn_eps.hpp"
#include "armadillo_bits/fn_pinv.hpp"
#include "armadillo_bits/fn_rank.hpp"
#include "armadillo_bits/fn_kron.hpp"
#include "armadillo_bits/fn_flip.hpp"
#include "armadillo_bits/fn_as_scalar.hpp"
#include "armadillo_bits/fn_princomp.hpp"
#include "armadillo_bits/fn_cross.hpp"
#include "armadillo_bits/fn_join.hpp"
#include "armadillo_bits/fn_conv.hpp"
#include "armadillo_bits/fn_trunc_exp.hpp"
#include "armadillo_bits/fn_trunc_log.hpp"
#include "armadillo_bits/fn_toeplitz.hpp"
#include "armadillo_bits/fn_trimat.hpp"
#include "armadillo_bits/fn_cumsum.hpp"
#include "armadillo_bits/fn_symmat.hpp"
#include "armadillo_bits/fn_syl_lyap.hpp"
#include "armadillo_bits/fn_hist.hpp"
#include "armadillo_bits/fn_histc.hpp"
#include "armadillo_bits/fn_unique.hpp"
#include "armadillo_bits/fn_fft.hpp"
#include "armadillo_bits/fn_fft2.hpp"
#include "armadillo_bits/fn_any.hpp"
#include "armadillo_bits/fn_all.hpp"
#include "armadillo_bits/fn_size.hpp"
#include "armadillo_bits/fn_numel.hpp"
#include "armadillo_bits/fn_inplace_strans.hpp"
#include "armadillo_bits/fn_inplace_trans.hpp"
#include "armadillo_bits/fn_randi.hpp"
#include "armadillo_bits/fn_randg.hpp"
#include "armadillo_bits/fn_cond.hpp"
#include "armadillo_bits/fn_normalise.hpp"
#include "armadillo_bits/fn_clamp.hpp"
#include "armadillo_bits/fn_expmat.hpp"
#include "armadillo_bits/fn_nonzeros.hpp"
#include "armadillo_bits/fn_interp1.hpp"
#include "armadillo_bits/fn_qz.hpp"
#include "armadillo_bits/fn_speye.hpp"
#include "armadillo_bits/fn_spones.hpp"
#include "armadillo_bits/fn_sprandn.hpp"
#include "armadillo_bits/fn_sprandu.hpp"
#include "armadillo_bits/fn_eigs_sym.hpp"
#include "armadillo_bits/fn_eigs_gen.hpp"
#include "armadillo_bits/fn_norm_sparse.hpp"
#include "armadillo_bits/fn_spsolve.hpp"
#include "armadillo_bits/fn_svds.hpp"
//
// misc stuff
#include "armadillo_bits/hdf5_misc.hpp"
#include "armadillo_bits/fft_engine.hpp"
#if !defined(ARMA_BAD_COMPILER)
#include "armadillo_bits/gmm_misc_bones.hpp"
#include "armadillo_bits/gmm_misc_meat.hpp"
#include "armadillo_bits/gmm_diag_bones.hpp"
#include "armadillo_bits/gmm_diag_meat.hpp"
#endif
//
// classes implementing various forms of dense matrix multiplication
#include "armadillo_bits/mul_gemv.hpp"
#include "armadillo_bits/mul_gemm.hpp"
#include "armadillo_bits/mul_gemm_mixed.hpp"
#include "armadillo_bits/mul_syrk.hpp"
#include "armadillo_bits/mul_herk.hpp"
//
// class meat
#include "armadillo_bits/eop_core_meat.hpp"
#include "armadillo_bits/eglue_core_meat.hpp"
#include "armadillo_bits/cond_rel_meat.hpp"
#include "armadillo_bits/arrayops_meat.hpp"
#include "armadillo_bits/podarray_meat.hpp"
#include "armadillo_bits/auxlib_meat.hpp"
#include "armadillo_bits/sp_auxlib_meat.hpp"
#include "armadillo_bits/injector_meat.hpp"
#include "armadillo_bits/Mat_meat.hpp"
#include "armadillo_bits/Col_meat.hpp"
#include "armadillo_bits/Row_meat.hpp"
#include "armadillo_bits/Cube_meat.hpp"
#include "armadillo_bits/xvec_htrans_meat.hpp"
#include "armadillo_bits/xtrans_mat_meat.hpp"
#include "armadillo_bits/SizeMat_meat.hpp"
#include "armadillo_bits/SizeCube_meat.hpp"
#include "armadillo_bits/field_meat.hpp"
#include "armadillo_bits/subview_meat.hpp"
#include "armadillo_bits/subview_elem1_meat.hpp"
#include "armadillo_bits/subview_elem2_meat.hpp"
#include "armadillo_bits/subview_field_meat.hpp"
#include "armadillo_bits/subview_cube_meat.hpp"
#include "armadillo_bits/diagview_meat.hpp"
#include "armadillo_bits/subview_each_meat.hpp"
#include "armadillo_bits/SpValProxy_meat.hpp"
#include "armadillo_bits/SpMat_meat.hpp"
#include "armadillo_bits/SpMat_iterators_meat.hpp"
#include "armadillo_bits/SpCol_meat.hpp"
#include "armadillo_bits/SpRow_meat.hpp"
#include "armadillo_bits/SpSubview_meat.hpp"
#include "armadillo_bits/SpSubview_iterators_meat.hpp"
#include "armadillo_bits/spdiagview_meat.hpp"
#include "armadillo_bits/diskio_meat.hpp"
#include "armadillo_bits/wall_clock_meat.hpp"
#include "armadillo_bits/running_stat_meat.hpp"
#include "armadillo_bits/running_stat_vec_meat.hpp"
#include "armadillo_bits/op_diagmat_meat.hpp"
#include "armadillo_bits/op_diagvec_meat.hpp"
#include "armadillo_bits/op_dot_meat.hpp"
#include "armadillo_bits/op_inv_meat.hpp"
#include "armadillo_bits/op_htrans_meat.hpp"
#include "armadillo_bits/op_max_meat.hpp"
#include "armadillo_bits/op_min_meat.hpp"
#include "armadillo_bits/op_mean_meat.hpp"
#include "armadillo_bits/op_median_meat.hpp"
#include "armadillo_bits/op_sort_meat.hpp"
#include "armadillo_bits/op_sort_index_meat.hpp"
#include "armadillo_bits/op_sum_meat.hpp"
#include "armadillo_bits/op_stddev_meat.hpp"
#include "armadillo_bits/op_strans_meat.hpp"
#include "armadillo_bits/op_var_meat.hpp"
#include "armadillo_bits/op_repmat_meat.hpp"
#include "armadillo_bits/op_reshape_meat.hpp"
#include "armadillo_bits/op_vectorise_meat.hpp"
#include "armadillo_bits/op_resize_meat.hpp"
#include "armadillo_bits/op_cov_meat.hpp"
#include "armadillo_bits/op_cor_meat.hpp"
#include "armadillo_bits/op_shuffle_meat.hpp"
#include "armadillo_bits/op_prod_meat.hpp"
#include "armadillo_bits/op_pinv_meat.hpp"
#include "armadillo_bits/op_dotext_meat.hpp"
#include "armadillo_bits/op_flip_meat.hpp"
#include "armadillo_bits/op_princomp_meat.hpp"
#include "armadillo_bits/op_misc_meat.hpp"
#include "armadillo_bits/op_relational_meat.hpp"
#include "armadillo_bits/op_find_meat.hpp"
#include "armadillo_bits/op_chol_meat.hpp"
#include "armadillo_bits/op_cx_scalar_meat.hpp"
#include "armadillo_bits/op_trimat_meat.hpp"
#include "armadillo_bits/op_cumsum_meat.hpp"
#include "armadillo_bits/op_symmat_meat.hpp"
#include "armadillo_bits/op_hist_meat.hpp"
#include "armadillo_bits/op_unique_meat.hpp"
#include "armadillo_bits/op_toeplitz_meat.hpp"
#include "armadillo_bits/op_fft_meat.hpp"
#include "armadillo_bits/op_any_meat.hpp"
#include "armadillo_bits/op_all_meat.hpp"
#include "armadillo_bits/op_normalise_meat.hpp"
#include "armadillo_bits/op_clamp_meat.hpp"
#include "armadillo_bits/op_expmat_meat.hpp"
#include "armadillo_bits/op_nonzeros_meat.hpp"
#include "armadillo_bits/glue_times_meat.hpp"
#include "armadillo_bits/glue_mixed_meat.hpp"
#include "armadillo_bits/glue_cov_meat.hpp"
#include "armadillo_bits/glue_cor_meat.hpp"
#include "armadillo_bits/glue_kron_meat.hpp"
#include "armadillo_bits/glue_cross_meat.hpp"
#include "armadillo_bits/glue_join_meat.hpp"
#include "armadillo_bits/glue_relational_meat.hpp"
#include "armadillo_bits/glue_solve_meat.hpp"
#include "armadillo_bits/glue_conv_meat.hpp"
#include "armadillo_bits/glue_toeplitz_meat.hpp"
#include "armadillo_bits/glue_hist_meat.hpp"
#include "armadillo_bits/glue_histc_meat.hpp"
#include "armadillo_bits/glue_max_meat.hpp"
#include "armadillo_bits/glue_min_meat.hpp"
#include "armadillo_bits/spop_max_meat.hpp"
#include "armadillo_bits/spop_min_meat.hpp"
#include "armadillo_bits/spop_sum_meat.hpp"
#include "armadillo_bits/spop_strans_meat.hpp"
#include "armadillo_bits/spop_htrans_meat.hpp"
#include "armadillo_bits/spop_misc_meat.hpp"
#include "armadillo_bits/spop_mean_meat.hpp"
#include "armadillo_bits/spop_var_meat.hpp"
#include "armadillo_bits/spglue_plus_meat.hpp"
#include "armadillo_bits/spglue_minus_meat.hpp"
#include "armadillo_bits/spglue_times_meat.hpp"
#include "armadillo_bits/spglue_join_meat.hpp"
}
#include "armadillo_bits/compiler_setup_post.hpp"
#endif
================================================
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/BaseCube_bones.hpp
================================================
// Copyright (C) 2008-2014 Conrad Sanderson
// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//! \addtogroup BaseCube
//! @{
template<typename elem_type, typename derived>
struct BaseCube_eval_Cube
{
arma_inline const derived& eval() const;
};
template<typename elem_type, typename derived>
struct BaseCube_eval_expr
{
arma_inline Cube<elem_type> eval() const; //!< force the immediate evaluation of a delayed expression
};
template<typename elem_type, typename derived, bool condition>
struct BaseCube_eval {};
template<typename elem_type, typename derived>
struct BaseCube_eval<elem_type, derived, true> { typedef BaseCube_eval_Cube<elem_type, derived> result; };
template<typename elem_type, typename derived>
struct BaseCube_eval<elem_type, derived, false> { typedef BaseCube_eval_expr<elem_type, derived> result; };
//! Analog of the Base class, intended for cubes
template<typename elem_type, typename derived>
struct BaseCube
: public BaseCube_eval<elem_type, derived, is_Cube<derived>::value>::result
{
arma_inline const derived& get_ref() const;
inline void print(const std::string extra_text = "") const;
inline void print(std::ostream& user_stream, const std::string extra_text = "") const;
inline void raw_print(const std::string extra_text = "") const;
inline void raw_print(std::ostream& user_stream, const std::string extra_text = "") const;
};
//! @}
================================================
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/BaseCube_meat.hpp
================================================
// Copyright (C) 2008-2014 Conrad Sanderson
// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//! \addtogroup BaseCube
//! @{
template<typename elem_type, typename derived>
arma_inline
const derived&
BaseCube<elem_type,derived>::get_ref() const
{
return static_cast<const derived&>(*this);
}
template<typename elem_type, typename derived>
inline
void
BaseCube<elem_type,derived>::print(const std::string extra_text) const
{
const unwrap_cube<derived> tmp( (*this).get_ref() );
tmp.M.impl_print(extra_text);
}
template<typename elem_type, typename derived>
inline
void
BaseCube<elem_type,derived>::print(std::ostream& user_stream, const std::string extra_text) const
{
const unwrap_cube<derived> tmp( (*this).get_ref() );
tmp.M.impl_print(user_stream, extra_text);
}
template<typename elem_type, typename derived>
inline
void
BaseCube<elem_type,derived>::raw_print(const std::string extra_text) const
{
const unwrap_cube<derived> tmp( (*this).get_ref() );
tmp.M.impl_raw_print(extra_text);
}
template<typename elem_type, typename derived>
inline
void
BaseCube<elem_type,derived>::raw_print(std::ostream& user_stream, const std::string extra_text) const
{
const unwrap_cube<derived> tmp( (*this).get_ref() );
tmp.M.impl_raw_print(user_stream, extra_text);
}
//
// extra functions defined in BaseCube_eval_Cube
template<typename elem_type, typename derived>
arma_inline
const derived&
BaseCube_eval_Cube<elem_type, derived>::eval() const
{
arma_extra_debug_sigprint();
return static_cast<const derived&>(*this);
}
//
// extra functions defined in BaseCube_eval_expr
template<typename elem_type, typename derived>
arma_inline
Cube<elem_type>
BaseCube_eval_expr<elem_type, derived>::eval() const
{
arma_extra_debug_sigprint();
return Cube<elem_type>( static_cast<const derived&>(*this) );
}
//! @}
================================================
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Base_bones.hpp
================================================
// Copyright (C) 2008-2014 Conrad Sanderson
// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//! \addtogroup Base
//! @{
template<typename derived>
struct Base_inv_yes
{
arma_inline const Op<derived,op_inv> i(const bool slow = false) const; //!< matrix inverse
arma_inline const Op<derived,op_inv> i(const char* method ) const; //!< matrix inverse
};
template<typename derived>
struct Base_inv_no
{
};
template<typename derived, bool condition>
struct Base_inv {};
template<typename derived>
struct Base_inv<derived, true> { typedef Base_inv_yes<derived> result; };
template<typename derived>
struct Base_inv<derived, false> { typedef Base_inv_no<derived> result; };
template<typename elem_type, typename derived>
struct Base_eval_Mat
{
arma_inline const derived& eval() const;
};
template<typename elem_type, typename derived>
struct Base_eval_expr
{
arma_inline Mat<elem_type> eval() const; //!< force the immediate evaluation of a delayed expression
};
template<typename elem_type, typename derived, bool condition>
struct Base_eval {};
template<typename elem_type, typename derived>
struct Base_eval<elem_type, derived, true> { typedef Base_eval_Mat<elem_type, derived> result; };
template<typename elem_type, typename derived>
struct Base_eval<elem_type, derived, false> { typedef Base_eval_expr<elem_type, derived> result; };
template<typename derived>
struct Base_trans_cx
{
arma_inline const Op<derived,op_htrans> t() const;
arma_inline const Op<derived,op_htrans> ht() const;
arma_inline const Op<derived,op_strans> st() const; // simple transpose: no complex conjugates
};
template<typename derived>
struct Base_trans_default
{
arma_inline const Op<derived,op_htrans> t() const;
arma_inline const Op<derived,op_htrans> ht() const;
arma_inline const Op<derived,op_htrans> st() const; // return op_htrans instead of op_strans, as it's handled better by matrix multiplication code
};
template<typename derived, bool condition>
struct Base_trans {};
template<typename derived>
struct Base_trans<derived, true> { typedef Base_trans_cx<derived> result; };
template<typename derived>
struct Base_trans<derived, false> { typedef Base_trans_default<derived> result; };
//! Class for static polymorphism, modelled after the "Curiously Recurring Template Pattern" (CRTP).
//! Used for type-safe downcasting in functions that restrict their input(s) to be classes that are
//! derived from Base (e.g. Mat, Op, Glue, diagview, subview).
//! A Base object can be converted to a Mat object by the unwrap class.
template<typename elem_type, typename derived>
struct Base
: public Base_inv<derived, is_supported_blas_type<elem_type>::value>::result
, public Base_eval<elem_type, derived, is_Mat<derived>::value>::result
, public Base_trans<derived, is_cx<elem_type>::value>::result
{
arma_inline const derived& get_ref() const;
inline void print(const std::string extra_text = "") const;
inline void print(std::ostream& user_stream, const std::string extra_text = "") const;
inline void raw_print(const std::string extra_text = "") const;
inline void raw_print(std::ostream& user_stream, const std::string extra_text = "") const;
inline arma_warn_unused elem_type min() const;
inline arma_warn_unused elem_type max() const;
inline elem_type min(uword& index_of_min_val) const;
inline elem_type max(uword& index_of_max_val) const;
inline elem_type min(uword& row_of_min_val, uword& col_of_min_val) const;
inline elem_type max(uword& row_of_max_val, uword& col_of_max_val) const;
};
//! @}
================================================
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Base_meat.hpp
================================================
// Copyright (C) 2008-2014 Conrad Sanderson
// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//! \addtogroup Base
//! @{
template<typename elem_type, typename derived>
arma_inline
const derived&
Base<elem_type,derived>::get_ref() const
{
return static_cast<const derived&>(*this);
}
template<typename elem_type, typename derived>
inline
void
Base<elem_type,derived>::print(const std::string extra_text) const
{
const Proxy<derived> P( (*this).get_ref() );
const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
tmp.M.impl_print(extra_text);
}
template<typename elem_type, typename derived>
inline
void
Base<elem_type,derived>::print(std::ostream& user_stream, const std::string extra_text) const
{
const Proxy<derived> P( (*this).get_ref() );
const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
tmp.M.impl_print(user_stream, extra_text);
}
template<typename elem_type, typename derived>
inline
void
Base<elem_type,derived>::raw_print(const std::string extra_text) const
{
const Proxy<derived> P( (*this).get_ref() );
const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
tmp.M.impl_raw_print(extra_text);
}
template<typename elem_type, typename derived>
inline
void
Base<elem_type,derived>::raw_print(std::ostream& user_stream, const std::string extra_text) const
{
const Proxy<derived> P( (*this).get_ref() );
const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
tmp.M.impl_raw_print(user_stream, extra_text);
}
template<typename elem_type, typename derived>
inline
arma_warn_unused
elem_type
Base<elem_type,derived>::min() const
{
return op_min::min( (*this).get_ref() );
}
template<typename elem_type, typename derived>
inline
arma_warn_unused
elem_type
Base<elem_type,derived>::max() const
{
return op_max::max( (*this).get_ref() );
}
template<typename elem_type, typename derived>
inline
elem_type
Base<elem_type,derived>::min(uword& index_of_min_val) const
{
const Proxy<derived> P( (*this).get_ref() );
return op_min::min_with_index(P, index_of_min_val);
}
template<typename elem_type, typename derived>
inline
elem_type
Base<elem_type,derived>::max(uword& index_of_max_val) const
{
const Proxy<derived> P( (*this).get_ref() );
return op_max::max_with_index(P, index_of_max_val);
}
template<typename elem_type, typename derived>
inline
elem_type
Base<elem_type,derived>::min(uword& row_of_min_val, uword& col_of_min_val) const
{
const Proxy<derived> P( (*this).get_ref() );
uword index;
const elem_type val = op_min::min_with_index(P, index);
const uword local_n_rows = P.get_n_rows();
row_of_min_val = index % local_n_rows;
col_of_min_val = index / local_n_rows;
return val;
}
template<typename elem_type, typename derived>
inline
elem_type
Base<elem_type,derived>::max(uword& row_of_max_val, uword& col_of_max_val) const
{
const Proxy<derived> P( (*this).get_ref() );
uword index;
const elem_type val = op_max::max_with_index(P, index);
const uword local_n_rows = P.get_n_rows();
row_of_max_val = index % local_n_rows;
col_of_max_val = index / local_n_rows;
return val;
}
//
// extra functions defined in Base_inv_yes
template<typename derived>
arma_inline
const Op<derived,op_inv>
Base_inv_yes<derived>::i(const bool slow) const
{
return Op<derived,op_inv>( static_cast<const derived&>(*this), ((slow == false) ? 0 : 1), 0 );
}
template<typename derived>
arma_inline
const Op<derived,op_inv>
Base_inv_yes<derived>::i(const char* method) const
{
const char sig = (method != NULL) ? method[0] : char(0);
arma_debug_check( ((sig != 's') && (sig != 'f')), "Base::i(): unknown method specified" );
return Op<derived,op_inv>( static_cast<const derived&>(*this), ((sig == 'f') ? 0 : 1), 0 );
}
//
// extra functions defined in Base_eval_Mat
template<typename elem_type, typename derived>
arma_inline
const derived&
Base_eval_Mat<elem_type, derived>::eval() const
{
arma_extra_debug_sigprint();
return static_cast<const derived&>(*this);
}
//
// extra functions defined in Base_eval_expr
template<typename elem_type, typename derived>
arma_inline
Mat<elem_type>
Base_eval_expr<elem_type, derived>::eval() const
{
arma_extra_debug_sigprint();
return Mat<elem_type>( static_cast<const derived&>(*this) );
}
//
// extra functions defined in Base_trans_cx
template<typename derived>
arma_inline
const Op<derived,op_htrans>
Base_trans_cx<derived>::t() const
{
return Op<derived,op_htrans>( static_cast<const derived&>(*this) );
}
template<typename derived>
arma_inline
const Op<derived,op_htrans>
Base_trans_cx<derived>::ht() const
{
return Op<derived,op_htrans>( static_cast<const derived&>(*this) );
}
template<typename derived>
arma_inline
const Op<derived,op_strans>
Base_trans_cx<derived>::st() const
{
return Op<derived,op_strans>( static_cast<const derived&>(*this) );
}
//
// extra functions defined in Base_trans_default
template<typename derived>
arma_inline
const Op<derived,op_htrans>
Base_trans_default<derived>::t() const
{
return Op<derived,op_htrans>( static_cast<const derived&>(*this) );
}
template<typename derived>
arma_inline
const Op<derived,op_htrans>
Base_trans_default<derived>::ht() const
{
return Op<derived,op_htrans>( static_cast<const derived&>(*this) );
}
template<typename derived>
arma_inline
const Op<derived,op_htrans>
Base_trans_default<derived>::st() const
{
return Op<derived,op_htrans>( static_cast<const derived&>(*this) );
}
//! @}
================================================
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Col_bones.hpp
================================================
// Copyright (C) 2008-2015 Conrad Sanderson
// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//! \addtogroup Col
//! @{
//! Class for column vectors (matrices with only one column)
template<typename eT>
class Col : public Mat<eT>
{
public:
typedef eT elem_type;
typedef typename get_pod_type<eT>::result pod_type;
static const bool is_col = true;
static const bool is_row = false;
inline Col();
inline Col(const Col<eT>& X);
inline explicit Col(const uword n_elem);
inline Col(const uword in_rows, const uword in_cols);
template<typename fill_type> inline Col(const uword n_elem, const fill::fill_class<fill_type>& f);
template<typename fill_type> inline Col(const uword in_rows, const uword in_cols, const fill::fill_class<fill_type>& f);
inline Col(const char* text);
inline const Col& operator=(const char* text);
inline Col(const std::string& text);
inline const Col& operator=(const std::string& text);
inline Col(const std::vector<eT>& x);
inline const Col& operator=(const std::vector<eT>& x);
#if defined(ARMA_USE_CXX11)
inline Col(const std::initializer_list<eT>& list);
inline const Col& operator=(const std::initializer_list<eT>& list);
inline Col(Col&& m);
inline const Col& operator=(Col&& m);
#endif
inline explicit Col(const SpCol<eT>& X);
inline const Col& operator=(const eT val);
inline const Col& operator=(const Col& m);
template<typename T1> inline Col(const Base<eT,T1>& X);
template<typename T1> inline const Col& operator=(const Base<eT,T1>& X);
inline Col( eT* aux_mem, const uword aux_length, const bool copy_aux_mem = true, const bool strict = true);
inline Col(const eT* aux_mem, const uword aux_length);
template<typename T1, typename T2>
inline explicit Col(const Base<pod_type,T1>& A, const Base<pod_type,T2>& B);
template<typename T1> inline Col(const BaseCube<eT,T1>& X);
template<typename T1> inline const Col& operator=(const BaseCube<eT,T1>& X);
inline Col(const subview_cube<eT>& X);
inline const Col& operator=(const subview_cube<eT>& X);
inline mat_injector<Col> operator<<(const eT val);
arma_inline const Op<Col<eT>,op_htrans> t() const;
arma_inline const Op<Col<eT>,op_htrans> ht() const;
arma_inline const Op<Col<eT>,op_strans> st() const;
arma_inline subview_col<eT> row(const uword row_num);
arma_inline const subview_col<eT> row(const uword row_num) const;
using Mat<eT>::rows;
using Mat<eT>::operator();
arma_inline subview_col<eT> rows(const uword in_row1, const uword in_row2);
arma_inline const subview_col<eT> rows(const uword in_row1, const uword in_row2) const;
arma_inline subview_col<eT> subvec(const uword in_row1, const uword in_row2);
arma_inline const subview_col<eT> subvec(const uword in_row1, const uword in_row2) const;
arma_inline subview_col<eT> rows(const span& row_span);
arma_inline const subview_col<eT> rows(const span& row_span) const;
arma_inline subview_col<eT> subvec(const span& row_span);
arma_inline const subview_col<eT> subvec(const span& row_span) const;
arma_inline subview_col<eT> operator()(const span& row_span);
arma_inline const subview_col<eT> operator()(const span& row_span) const;
arma_inline subview_col<eT> head(const uword N);
arma_inline const subview_col<eT> head(const uword N) const;
arma_inline subview_col<eT> tail(const uword N);
arma_inline const subview_col<eT> tail(const uword N) const;
arma_inline subview_col<eT> head_rows(const uword N);
arma_inline const subview_col<eT> head_rows(const uword N) const;
arma_inline subview_col<eT> tail_rows(const uword N);
arma_inline const subview_col<eT> tail_rows(const uword N) const;
inline void shed_row (const uword row_num);
inline void shed_rows(const uword in_row1, const uword in_row2);
inline void insert_rows(const uword row_num, const uword N, const bool set_to_zero = true);
template<typename T1> inline void insert_rows(const uword row_num, const Base<eT,T1>& X);
arma_inline arma_warn_unused eT& at(const uword i);
arma_inline arma_warn_unused const eT& at(const uword i) const;
arma_inline arma_warn_unused eT& at(const uword in_row, const uword in_col);
arma_inline arma_warn_unused const eT& at(const uword in_row, const uword in_col) const;
typedef eT* row_iterator;
typedef const eT* const_row_iterator;
inline row_iterator begin_row(const uword row_num);
inline const_row_iterator begin_row(const uword row_num) const;
inline row_iterator end_row (const uword row_num);
inline const_row_iterator end_row (const uword row_num) const;
template<uword fixed_n_elem> class fixed;
protected:
inline Col(const arma_fixed_indicator&, const uword in_n_elem, const eT* in_mem);
public:
#ifdef ARMA_EXTRA_COL_PROTO
#include ARMA_INCFILE_WRAP(ARMA_EXTRA_COL_PROTO)
#endif
};
template<typename eT>
template<uword fixed_n_elem>
class Col<eT>::fixed : public Col<eT>
{
private:
static const bool use_extra = (fixed_n_elem > arma_config::mat_prealloc);
arma_align_mem eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ];
arma_inline void change_to_row();
public:
typedef fixed<fixed_n_elem> Col_fixed_type;
typedef eT elem_type;
typedef typename get_pod_type<eT>::result pod_type;
static const bool is_col = true;
static const bool is_row = false;
static const uword n_rows = fixed_n_elem;
static const uword n_cols = 1;
static const uword n_elem = fixed_n_elem;
arma_inline fixed();
arma_inline fixed(const fixed<fixed_n_elem>& X);
inline fixed(const subview_cube<eT>& X);
template<typename fill_type> inline fixed(const fill::fill_class<fill_type>& f);
template<typename T1> inline fixed(const Base<eT,T1>& A);
template<typename T1, typename T2> inline fixed(const Base<pod_type,T1>& A, const Base<pod_type,T2>& B);
inline fixed(const eT* aux_mem);
inline fixed(const char* text);
inline fixed(const std::string& text);
template<typename T1> inline const Col& operator=(const Base<eT,T1>& A);
inline const Col& operator=(const eT val);
inline const Col& operator=(const char* text);
inline const Col& operator=(const std::string& text);
inline const Col& operator=(const subview_cube<eT>& X);
using Col<eT>::operator();
#if defined(ARMA_USE_CXX11)
inline fixed(const std::initializer_list<eT>& list);
inline const Col& operator=(const std::initializer_list<eT>& list);
#endif
arma_inline const Col& operator=(const fixed<fixed_n_elem>& X);
#if defined(ARMA_GOOD_COMPILER)
template<typename T1, typename eop_type> inline const Col& operator=(const eOp<T1, eop_type>& X);
template<typename T1, typename T2, typename eglue_type> inline const Col& operator=(const eGlue<T1, T2, eglue_type>& X);
#endif
arma_inline const Op< Col_fixed_type, op_htrans > t() const;
arma_inline const Op< Col_fixed_type, op_htrans > ht() const;
arma_inline const Op< Col_fixed_type, op_strans > st() const;
arma_inline arma_warn_unused const eT& at_alt (const uword i) const;
arma_inline arma_warn_unused eT& operator[] (const uword i);
arma_inline arma_warn_unused const eT& operator[] (const uword i) const;
arma_inline arma_warn_unused eT& at (const uword i);
arma_inline arma_warn_unused const eT& at (const uword i) const;
arma_inline arma_warn_unused eT& operator() (const uword i);
arma_inline arma_warn_unused const eT& operator() (const uword i) const;
arma_inline arma_warn_unused eT& at (const uword in_row, const uword in_col);
arma_inline arma_warn_unused const eT& at (const uword in_row, const uword in_col) const;
arma_inline arma_warn_unused eT& operator() (const uword in_row, const uword in_col);
arma_inline arma_warn_unused const eT& operator() (const uword in_row, const uword in_col) const;
arma_inline arma_warn_unused eT* memptr();
arma_inline arma_warn_unused const eT* memptr() const;
arma_hot inline const Col<eT>& fill(const eT val);
arma_hot inline const Col<eT>& zeros();
arma_hot inline const Col<eT>& ones();
};
//! @}
================================================
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Col_meat.hpp
================================================
// Copyright (C) 2008-2015 Conrad Sanderson
// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//! \addtogroup Col
//! @{
//! construct an empty column vector
template<typename eT>
inline
Col<eT>::Col()
: Mat<eT>(arma_vec_indicator(), 1)
{
arma_extra_debug_sigprint();
}
template<typename eT>
inline
Col<eT>::Col(const Col<eT>& X)
: Mat<eT>(arma_vec_indicator(), X.n_elem, 1, 1)
{
arma_extra_debug_sigprint();
arrayops::copy((*this).memptr(), X.memptr(), X.n_elem);
}
//! construct a column vector with the specified number of n_elem
template<typename eT>
inline
Col<eT>::Col(const uword in_n_elem)
: Mat<eT>(arma_vec_indicator(), in_n_elem, 1, 1)
{
arma_extra_debug_sigprint();
}
template<typename eT>
inline
Col<eT>::Col(const uword in_n_rows, const uword in_n_cols)
: Mat<eT>(arma_vec_indicator(), 0, 0, 1)
{
arma_extra_debug_sigprint();
Mat<eT>::init_warm(in_n_rows, in_n_cols);
}
template<typename eT>
template<typename fill_type>
inline
Col<eT>::Col(const uword in_n_elem, const fill::fill_class<fill_type>& f)
: Mat<eT>(arma_vec_indicator(), in_n_elem, 1, 1)
{
arma_extra_debug_sigprint();
(*this).fill(f);
}
template<typename eT>
template<typename fill_type>
inline
Col<eT>::Col(const uword in_n_rows, const uword in_n_cols, const fill::fill_class<fill_type>& f)
: Mat<eT>(arma_vec_indicator(), 0, 0, 1)
{
arma_extra_debug_sigprint();
Mat<eT>::init_warm(in_n_rows, in_n_cols);
(*this).fill(f);
}
//! construct a column vector from specified text
template<typename eT>
inline
Col<eT>::Col(const char* text)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 2;
Mat<eT>::operator=(text);
std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
access::rw(Mat<eT>::vec_state) = 1;
}
//! construct a column vector from specified text
template<typename eT>
inline
const Col<eT>&
Col<eT>::operator=(const char* text)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 2;
Mat<eT>::operator=(text);
std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
access::rw(Mat<eT>::vec_state) = 1;
return *this;
}
//! construct a column vector from specified text
template<typename eT>
inline
Col<eT>::Col(const std::string& text)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 2;
Mat<eT>::operator=(text);
std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
access::rw(Mat<eT>::vec_state) = 1;
}
//! construct a column vector from specified text
template<typename eT>
inline
const Col<eT>&
Col<eT>::operator=(const std::string& text)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 2;
Mat<eT>::operator=(text);
std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
access::rw(Mat<eT>::vec_state) = 1;
return *this;
}
//! create a column vector from std::vector
template<typename eT>
inline
Col<eT>::Col(const std::vector<eT>& x)
: Mat<eT>(arma_vec_indicator(), uword(x.size()), 1, 1)
{
arma_extra_debug_sigprint_this(this);
if(x.size() > 0)
{
arrayops::copy( Mat<eT>::memptr(), &(x[0]), uword(x.size()) );
}
}
//! create a column vector from std::vector
template<typename eT>
inline
const Col<eT>&
Col<eT>::operator=(const std::vector<eT>& x)
{
arma_extra_debug_sigprint();
Mat<eT>::init_warm(uword(x.size()), 1);
if(x.size() > 0)
{
arrayops::copy( Mat<eT>::memptr(), &(x[0]), uword(x.size()) );
}
return *this;
}
#if defined(ARMA_USE_CXX11)
template<typename eT>
inline
Col<eT>::Col(const std::initializer_list<eT>& list)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 2;
Mat<eT>::operator=(list);
std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
access::rw(Mat<eT>::vec_state) = 1;
}
template<typename eT>
inline
const Col<eT>&
Col<eT>::operator=(const std::initializer_list<eT>& list)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 2;
Mat<eT>::operator=(list);
std::swap( access::rw(Mat<eT>::n_rows), access::rw(Mat<eT>::n_cols) );
access::rw(Mat<eT>::vec_state) = 1;
return *this;
}
template<typename eT>
inline
Col<eT>::Col(Col<eT>&& X)
: Mat<eT>(arma_vec_indicator(), 1)
{
arma_extra_debug_sigprint(arma_boost::format("this = %x X = %x") % this % &X);
access::rw(Mat<eT>::n_rows) = X.n_rows;
access::rw(Mat<eT>::n_cols) = 1;
access::rw(Mat<eT>::n_elem) = X.n_elem;
if( ((X.mem_state == 0) && (X.n_elem > arma_config::mat_prealloc)) || (X.mem_state == 1) || (X.mem_state == 2) )
{
access::rw(Mat<eT>::mem_state) = X.mem_state;
access::rw(Mat<eT>::mem) = X.mem;
access::rw(X.n_rows) = 0;
access::rw(X.n_cols) = 1;
access::rw(X.n_elem) = 0;
access::rw(X.mem_state) = 0;
access::rw(X.mem) = 0;
}
else
{
(*this).init_cold();
arrayops::copy( (*this).memptr(), X.mem, X.n_elem );
if( (X.mem_state == 0) && (X.n_elem <= arma_config::mat_prealloc) )
{
access::rw(X.n_rows) = 0;
access::rw(X.n_cols) = 1;
access::rw(X.n_elem) = 0;
access::rw(X.mem) = 0;
}
}
}
template<typename eT>
inline
const Col<eT>&
Col<eT>::operator=(Col<eT>&& X)
{
arma_extra_debug_sigprint(arma_boost::format("this = %x X = %x") % this % &X);
(*this).steal_mem(X);
if( (X.mem_state == 0) && (X.n_elem <= arma_config::mat_prealloc) && (this != &X) )
{
access::rw(X.n_rows) = 0;
access::rw(X.n_cols) = 1;
access::rw(X.n_elem) = 0;
access::rw(X.mem) = 0;
}
return *this;
}
#endif
template<typename eT>
inline
Col<eT>::Col(const SpCol<eT>& X)
: Mat<eT>(arma_vec_indicator(), X.n_elem, 1, 1)
{
arma_extra_debug_sigprint_this(this);
arrayops::inplace_set(Mat<eT>::memptr(), eT(0), X.n_elem);
for(typename SpCol<eT>::const_iterator it = X.begin(); it != X.end(); ++it)
{
at(it.row()) = (*it);
}
}
template<typename eT>
inline
const Col<eT>&
Col<eT>::operator=(const eT val)
{
arma_extra_debug_sigprint();
Mat<eT>::operator=(val);
return *this;
}
template<typename eT>
inline
const Col<eT>&
Col<eT>::operator=(const Col<eT>& X)
{
arma_extra_debug_sigprint();
Mat<eT>::operator=(X);
return *this;
}
template<typename eT>
template<typename T1>
inline
Col<eT>::Col(const Base<eT,T1>& X)
: Mat<eT>(arma_vec_indicator(), 1)
{
arma_extra_debug_sigprint();
Mat<eT>::operator=(X.get_ref());
}
template<typename eT>
template<typename T1>
inline
const Col<eT>&
Col<eT>::operator=(const Base<eT,T1>& X)
{
arma_extra_debug_sigprint();
Mat<eT>::operator=(X.get_ref());
return *this;
}
//! construct a column vector from a given auxiliary array of eTs
template<typename eT>
inline
Col<eT>::Col(eT* aux_mem, const uword aux_length, const bool copy_aux_mem, const bool strict)
: Mat<eT>(aux_mem, aux_length, 1, copy_aux_mem, strict)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 1;
}
//! construct a column vector from a given auxiliary array of eTs
template<typename eT>
inline
Col<eT>::Col(const eT* aux_mem, const uword aux_length)
: Mat<eT>(aux_mem, aux_length, 1)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 1;
}
template<typename eT>
template<typename T1, typename T2>
inline
Col<eT>::Col
(
const Base<typename Col<eT>::pod_type, T1>& A,
const Base<typename Col<eT>::pod_type, T2>& B
)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 1;
Mat<eT>::init(A,B);
}
template<typename eT>
template<typename T1>
inline
Col<eT>::Col(const BaseCube<eT,T1>& X)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 1;
Mat<eT>::operator=(X);
}
template<typename eT>
template<typename T1>
inline
const Col<eT>&
Col<eT>::operator=(const BaseCube<eT,T1>& X)
{
arma_extra_debug_sigprint();
Mat<eT>::operator=(X);
return *this;
}
template<typename eT>
inline
Col<eT>::Col(const subview_cube<eT>& X)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 1;
Mat<eT>::operator=(X);
}
template<typename eT>
inline
const Col<eT>&
Col<eT>::operator=(const subview_cube<eT>& X)
{
arma_extra_debug_sigprint();
Mat<eT>::operator=(X);
return *this;
}
template<typename eT>
inline
mat_injector< Col<eT> >
Col<eT>::operator<<(const eT val)
{
return mat_injector< Col<eT> >(*this, val);
}
template<typename eT>
arma_inline
const Op<Col<eT>,op_htrans>
Col<eT>::t() const
{
return Op<Col<eT>,op_htrans>(*this);
}
template<typename eT>
arma_inline
const Op<Col<eT>,op_htrans>
Col<eT>::ht() const
{
return Op<Col<eT>,op_htrans>(*this);
}
template<typename eT>
arma_inline
const Op<Col<eT>,op_strans>
Col<eT>::st() const
{
return Op<Col<eT>,op_strans>(*this);
}
template<typename eT>
arma_inline
subview_col<eT>
Col<eT>::row(const uword in_row1)
{
arma_extra_debug_sigprint();
arma_debug_check( (in_row1 >= Mat<eT>::n_rows), "Col::row(): indices out of bounds or incorrectly used");
return subview_col<eT>(*this, 0, in_row1, 1);
}
template<typename eT>
arma_inline
const subview_col<eT>
Col<eT>::row(const uword in_row1) const
{
arma_extra_debug_sigprint();
arma_debug_check( (in_row1 >= Mat<eT>::n_rows), "Col::row(): indices out of bounds or incorrectly used");
return subview_col<eT>(*this, 0, in_row1, 1);
}
template<typename eT>
arma_inline
subview_col<eT>
Col<eT>::rows(const uword in_row1, const uword in_row2)
{
arma_extra_debug_sigprint();
arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "Col::rows(): indices out of bounds or incorrectly used");
const uword subview_n_rows = in_row2 - in_row1 + 1;
return subview_col<eT>(*this, 0, in_row1, subview_n_rows);
}
template<typename eT>
arma_inline
const subview_col<eT>
Col<eT>::rows(const uword in_row1, const uword in_row2) const
{
arma_extra_debug_sigprint();
arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "Col::rows(): indices out of bounds or incorrectly used");
const uword subview_n_rows = in_row2 - in_row1 + 1;
return subview_col<eT>(*this, 0, in_row1, subview_n_rows);
}
template<typename eT>
arma_inline
subview_col<eT>
Col<eT>::subvec(const uword in_row1, const uword in_row2)
{
arma_extra_debug_sigprint();
arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "Col::subvec(): indices out of bounds or incorrectly used");
const uword subview_n_rows = in_row2 - in_row1 + 1;
return subview_col<eT>(*this, 0, in_row1, subview_n_rows);
}
template<typename eT>
arma_inline
const subview_col<eT>
Col<eT>::subvec(const uword in_row1, const uword in_row2) const
{
arma_extra_debug_sigprint();
arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "
gitextract_kvc5fbke/
├── .hgignore
├── COPYRIGHT
├── LICENSE.TXT
├── OptolithiumC/
│ ├── CMakeLists.txt
│ ├── FindFFTW.cmake
│ ├── FindNumPy.cmake
│ ├── clipper.i
│ ├── examples/
│ │ ├── aerial_image_various_source_shapes.py
│ │ └── resist_images_and_contours.py
│ ├── include/
│ │ ├── opl_capi.h
│ │ ├── opl_contours.h
│ │ ├── opl_conv.h
│ │ ├── opl_eikonal.h
│ │ ├── opl_fft.h
│ │ ├── opl_geometry.h
│ │ ├── opl_interp.h
│ │ ├── opl_iter.h
│ │ ├── opl_log.h
│ │ ├── opl_misc.h
│ │ ├── opl_physc.h
│ │ ├── opl_sim.h
│ │ └── optolithium.h
│ ├── libs/
│ │ ├── armadillo/
│ │ │ ├── include/
│ │ │ │ ├── armadillo
│ │ │ │ └── armadillo_bits/
│ │ │ │ ├── BaseCube_bones.hpp
│ │ │ │ ├── BaseCube_meat.hpp
│ │ │ │ ├── Base_bones.hpp
│ │ │ │ ├── Base_meat.hpp
│ │ │ │ ├── Col_bones.hpp
│ │ │ │ ├── Col_meat.hpp
│ │ │ │ ├── Cube_bones.hpp
│ │ │ │ ├── Cube_meat.hpp
│ │ │ │ ├── GenCube_bones.hpp
│ │ │ │ ├── GenCube_meat.hpp
│ │ │ │ ├── Gen_bones.hpp
│ │ │ │ ├── Gen_meat.hpp
│ │ │ │ ├── GlueCube_bones.hpp
│ │ │ │ ├── GlueCube_meat.hpp
│ │ │ │ ├── Glue_bones.hpp
│ │ │ │ ├── Glue_meat.hpp
│ │ │ │ ├── Mat_bones.hpp
│ │ │ │ ├── Mat_meat.hpp
│ │ │ │ ├── OpCube_bones.hpp
│ │ │ │ ├── OpCube_meat.hpp
│ │ │ │ ├── Op_bones.hpp
│ │ │ │ ├── Op_meat.hpp
│ │ │ │ ├── Proxy.hpp
│ │ │ │ ├── ProxyCube.hpp
│ │ │ │ ├── Row_bones.hpp
│ │ │ │ ├── Row_meat.hpp
│ │ │ │ ├── SizeCube_bones.hpp
│ │ │ │ ├── SizeCube_meat.hpp
│ │ │ │ ├── SizeMat_bones.hpp
│ │ │ │ ├── SizeMat_meat.hpp
│ │ │ │ ├── SpBase_bones.hpp
│ │ │ │ ├── SpBase_meat.hpp
│ │ │ │ ├── SpCol_bones.hpp
│ │ │ │ ├── SpCol_meat.hpp
│ │ │ │ ├── SpGlue_bones.hpp
│ │ │ │ ├── SpGlue_meat.hpp
│ │ │ │ ├── SpMat_bones.hpp
│ │ │ │ ├── SpMat_iterators_meat.hpp
│ │ │ │ ├── SpMat_meat.hpp
│ │ │ │ ├── SpOp_bones.hpp
│ │ │ │ ├── SpOp_meat.hpp
│ │ │ │ ├── SpProxy.hpp
│ │ │ │ ├── SpRow_bones.hpp
│ │ │ │ ├── SpRow_meat.hpp
│ │ │ │ ├── SpSubview_bones.hpp
│ │ │ │ ├── SpSubview_iterators_meat.hpp
│ │ │ │ ├── SpSubview_meat.hpp
│ │ │ │ ├── SpValProxy_bones.hpp
│ │ │ │ ├── SpValProxy_meat.hpp
│ │ │ │ ├── access.hpp
│ │ │ │ ├── arma_boost.hpp
│ │ │ │ ├── arma_cmath.hpp
│ │ │ │ ├── arma_config.hpp
│ │ │ │ ├── arma_ostream_bones.hpp
│ │ │ │ ├── arma_ostream_meat.hpp
│ │ │ │ ├── arma_rng.hpp
│ │ │ │ ├── arma_rng_cxx11.hpp
│ │ │ │ ├── arma_rng_cxx98.hpp
│ │ │ │ ├── arma_static_check.hpp
│ │ │ │ ├── arma_version.hpp
│ │ │ │ ├── arpack_bones.hpp
│ │ │ │ ├── arpack_wrapper.hpp
│ │ │ │ ├── arrayops_bones.hpp
│ │ │ │ ├── arrayops_meat.hpp
│ │ │ │ ├── atlas_bones.hpp
│ │ │ │ ├── atlas_wrapper.hpp
│ │ │ │ ├── auxlib_bones.hpp
│ │ │ │ ├── auxlib_meat.hpp
│ │ │ │ ├── blas_bones.hpp
│ │ │ │ ├── blas_wrapper.hpp
│ │ │ │ ├── compiler_setup.hpp
│ │ │ │ ├── compiler_setup_post.hpp
│ │ │ │ ├── cond_rel_bones.hpp
│ │ │ │ ├── cond_rel_meat.hpp
│ │ │ │ ├── config.hpp
│ │ │ │ ├── config.hpp.cmake
│ │ │ │ ├── constants.hpp
│ │ │ │ ├── constants_compat.hpp
│ │ │ │ ├── debug.hpp
│ │ │ │ ├── diagmat_proxy.hpp
│ │ │ │ ├── diagview_bones.hpp
│ │ │ │ ├── diagview_meat.hpp
│ │ │ │ ├── diskio_bones.hpp
│ │ │ │ ├── diskio_meat.hpp
│ │ │ │ ├── distr_param.hpp
│ │ │ │ ├── eGlueCube_bones.hpp
│ │ │ │ ├── eGlueCube_meat.hpp
│ │ │ │ ├── eGlue_bones.hpp
│ │ │ │ ├── eGlue_meat.hpp
│ │ │ │ ├── eOpCube_bones.hpp
│ │ │ │ ├── eOpCube_meat.hpp
│ │ │ │ ├── eOp_bones.hpp
│ │ │ │ ├── eOp_meat.hpp
│ │ │ │ ├── eglue_core_bones.hpp
│ │ │ │ ├── eglue_core_meat.hpp
│ │ │ │ ├── eop_aux.hpp
│ │ │ │ ├── eop_core_bones.hpp
│ │ │ │ ├── eop_core_meat.hpp
│ │ │ │ ├── fft_engine.hpp
│ │ │ │ ├── field_bones.hpp
│ │ │ │ ├── field_meat.hpp
│ │ │ │ ├── fn_accu.hpp
│ │ │ │ ├── fn_all.hpp
│ │ │ │ ├── fn_any.hpp
│ │ │ │ ├── fn_as_scalar.hpp
│ │ │ │ ├── fn_chol.hpp
│ │ │ │ ├── fn_clamp.hpp
│ │ │ │ ├── fn_cond.hpp
│ │ │ │ ├── fn_conv.hpp
│ │ │ │ ├── fn_conv_to.hpp
│ │ │ │ ├── fn_cor.hpp
│ │ │ │ ├── fn_cov.hpp
│ │ │ │ ├── fn_cross.hpp
│ │ │ │ ├── fn_cumsum.hpp
│ │ │ │ ├── fn_det.hpp
│ │ │ │ ├── fn_diagmat.hpp
│ │ │ │ ├── fn_diagvec.hpp
│ │ │ │ ├── fn_dot.hpp
│ │ │ │ ├── fn_eig_gen.hpp
│ │ │ │ ├── fn_eig_pair.hpp
│ │ │ │ ├── fn_eig_sym.hpp
│ │ │ │ ├── fn_eigs_gen.hpp
│ │ │ │ ├── fn_eigs_sym.hpp
│ │ │ │ ├── fn_elem.hpp
│ │ │ │ ├── fn_eps.hpp
│ │ │ │ ├── fn_expmat.hpp
│ │ │ │ ├── fn_eye.hpp
│ │ │ │ ├── fn_fft.hpp
│ │ │ │ ├── fn_fft2.hpp
│ │ │ │ ├── fn_find.hpp
│ │ │ │ ├── fn_flip.hpp
│ │ │ │ ├── fn_hist.hpp
│ │ │ │ ├── fn_histc.hpp
│ │ │ │ ├── fn_inplace_strans.hpp
│ │ │ │ ├── fn_inplace_trans.hpp
│ │ │ │ ├── fn_interp1.hpp
│ │ │ │ ├── fn_inv.hpp
│ │ │ │ ├── fn_join.hpp
│ │ │ │ ├── fn_kron.hpp
│ │ │ │ ├── fn_log_det.hpp
│ │ │ │ ├── fn_lu.hpp
│ │ │ │ ├── fn_max.hpp
│ │ │ │ ├── fn_mean.hpp
│ │ │ │ ├── fn_median.hpp
│ │ │ │ ├── fn_min.hpp
│ │ │ │ ├── fn_misc.hpp
│ │ │ │ ├── fn_n_unique.hpp
│ │ │ │ ├── fn_nonzeros.hpp
│ │ │ │ ├── fn_norm.hpp
│ │ │ │ ├── fn_norm_sparse.hpp
│ │ │ │ ├── fn_normalise.hpp
│ │ │ │ ├── fn_numel.hpp
│ │ │ │ ├── fn_ones.hpp
│ │ │ │ ├── fn_pinv.hpp
│ │ │ │ ├── fn_princomp.hpp
│ │ │ │ ├── fn_prod.hpp
│ │ │ │ ├── fn_qr.hpp
│ │ │ │ ├── fn_qz.hpp
│ │ │ │ ├── fn_randg.hpp
│ │ │ │ ├── fn_randi.hpp
│ │ │ │ ├── fn_randn.hpp
│ │ │ │ ├── fn_randu.hpp
│ │ │ │ ├── fn_rank.hpp
│ │ │ │ ├── fn_repmat.hpp
│ │ │ │ ├── fn_reshape.hpp
│ │ │ │ ├── fn_resize.hpp
│ │ │ │ ├── fn_shuffle.hpp
│ │ │ │ ├── fn_size.hpp
│ │ │ │ ├── fn_solve.hpp
│ │ │ │ ├── fn_sort.hpp
│ │ │ │ ├── fn_sort_index.hpp
│ │ │ │ ├── fn_speye.hpp
│ │ │ │ ├── fn_spones.hpp
│ │ │ │ ├── fn_sprandn.hpp
│ │ │ │ ├── fn_sprandu.hpp
│ │ │ │ ├── fn_spsolve.hpp
│ │ │ │ ├── fn_stddev.hpp
│ │ │ │ ├── fn_strans.hpp
│ │ │ │ ├── fn_sum.hpp
│ │ │ │ ├── fn_svd.hpp
│ │ │ │ ├── fn_svds.hpp
│ │ │ │ ├── fn_syl_lyap.hpp
│ │ │ │ ├── fn_symmat.hpp
│ │ │ │ ├── fn_toeplitz.hpp
│ │ │ │ ├── fn_trace.hpp
│ │ │ │ ├── fn_trans.hpp
│ │ │ │ ├── fn_trig.hpp
│ │ │ │ ├── fn_trimat.hpp
│ │ │ │ ├── fn_trunc_exp.hpp
│ │ │ │ ├── fn_trunc_log.hpp
│ │ │ │ ├── fn_unique.hpp
│ │ │ │ ├── fn_var.hpp
│ │ │ │ ├── fn_vectorise.hpp
│ │ │ │ ├── fn_zeros.hpp
│ │ │ │ ├── forward_bones.hpp
│ │ │ │ ├── glue_conv_bones.hpp
│ │ │ │ ├── glue_conv_meat.hpp
│ │ │ │ ├── glue_cor_bones.hpp
│ │ │ │ ├── glue_cor_meat.hpp
│ │ │ │ ├── glue_cov_bones.hpp
│ │ │ │ ├── glue_cov_meat.hpp
│ │ │ │ ├── glue_cross_bones.hpp
│ │ │ │ ├── glue_cross_meat.hpp
│ │ │ │ ├── glue_hist_bones.hpp
│ │ │ │ ├── glue_hist_meat.hpp
│ │ │ │ ├── glue_histc_bones.hpp
│ │ │ │ ├── glue_histc_meat.hpp
│ │ │ │ ├── glue_join_bones.hpp
│ │ │ │ ├── glue_join_meat.hpp
│ │ │ │ ├── glue_kron_bones.hpp
│ │ │ │ ├── glue_kron_meat.hpp
│ │ │ │ ├── glue_max_bones.hpp
│ │ │ │ ├── glue_max_meat.hpp
│ │ │ │ ├── glue_min_bones.hpp
│ │ │ │ ├── glue_min_meat.hpp
│ │ │ │ ├── glue_mixed_bones.hpp
│ │ │ │ ├── glue_mixed_meat.hpp
│ │ │ │ ├── glue_relational_bones.hpp
│ │ │ │ ├── glue_relational_meat.hpp
│ │ │ │ ├── glue_solve_bones.hpp
│ │ │ │ ├── glue_solve_meat.hpp
│ │ │ │ ├── glue_times_bones.hpp
│ │ │ │ ├── glue_times_meat.hpp
│ │ │ │ ├── glue_toeplitz_bones.hpp
│ │ │ │ ├── glue_toeplitz_meat.hpp
│ │ │ │ ├── gmm_diag_bones.hpp
│ │ │ │ ├── gmm_diag_meat.hpp
│ │ │ │ ├── gmm_misc_bones.hpp
│ │ │ │ ├── gmm_misc_meat.hpp
│ │ │ │ ├── hdf5_bones.hpp
│ │ │ │ ├── hdf5_misc.hpp
│ │ │ │ ├── include_atlas.hpp
│ │ │ │ ├── include_hdf5.hpp
│ │ │ │ ├── include_superlu.hpp
│ │ │ │ ├── injector_bones.hpp
│ │ │ │ ├── injector_meat.hpp
│ │ │ │ ├── lapack_bones.hpp
│ │ │ │ ├── lapack_wrapper.hpp
│ │ │ │ ├── memory.hpp
│ │ │ │ ├── mtGlueCube_bones.hpp
│ │ │ │ ├── mtGlueCube_meat.hpp
│ │ │ │ ├── mtGlue_bones.hpp
│ │ │ │ ├── mtGlue_meat.hpp
│ │ │ │ ├── mtOpCube_bones.hpp
│ │ │ │ ├── mtOpCube_meat.hpp
│ │ │ │ ├── mtOp_bones.hpp
│ │ │ │ ├── mtOp_meat.hpp
│ │ │ │ ├── mtSpOp_bones.hpp
│ │ │ │ ├── mtSpOp_meat.hpp
│ │ │ │ ├── mul_gemm.hpp
│ │ │ │ ├── mul_gemm_mixed.hpp
│ │ │ │ ├── mul_gemv.hpp
│ │ │ │ ├── mul_herk.hpp
│ │ │ │ ├── mul_syrk.hpp
│ │ │ │ ├── op_all_bones.hpp
│ │ │ │ ├── op_all_meat.hpp
│ │ │ │ ├── op_any_bones.hpp
│ │ │ │ ├── op_any_meat.hpp
│ │ │ │ ├── op_chol_bones.hpp
│ │ │ │ ├── op_chol_meat.hpp
│ │ │ │ ├── op_clamp_bones.hpp
│ │ │ │ ├── op_clamp_meat.hpp
│ │ │ │ ├── op_cor_bones.hpp
│ │ │ │ ├── op_cor_meat.hpp
│ │ │ │ ├── op_cov_bones.hpp
│ │ │ │ ├── op_cov_meat.hpp
│ │ │ │ ├── op_cumsum_bones.hpp
│ │ │ │ ├── op_cumsum_meat.hpp
│ │ │ │ ├── op_cx_scalar_bones.hpp
│ │ │ │ ├── op_cx_scalar_meat.hpp
│ │ │ │ ├── op_diagmat_bones.hpp
│ │ │ │ ├── op_diagmat_meat.hpp
│ │ │ │ ├── op_diagvec_bones.hpp
│ │ │ │ ├── op_diagvec_meat.hpp
│ │ │ │ ├── op_dot_bones.hpp
│ │ │ │ ├── op_dot_meat.hpp
│ │ │ │ ├── op_dotext_bones.hpp
│ │ │ │ ├── op_dotext_meat.hpp
│ │ │ │ ├── op_expmat_bones.hpp
│ │ │ │ ├── op_expmat_meat.hpp
│ │ │ │ ├── op_fft_bones.hpp
│ │ │ │ ├── op_fft_meat.hpp
│ │ │ │ ├── op_find_bones.hpp
│ │ │ │ ├── op_find_meat.hpp
│ │ │ │ ├── op_flip_bones.hpp
│ │ │ │ ├── op_flip_meat.hpp
│ │ │ │ ├── op_hist_bones.hpp
│ │ │ │ ├── op_hist_meat.hpp
│ │ │ │ ├── op_htrans_bones.hpp
│ │ │ │ ├── op_htrans_meat.hpp
│ │ │ │ ├── op_inv_bones.hpp
│ │ │ │ ├── op_inv_meat.hpp
│ │ │ │ ├── op_max_bones.hpp
│ │ │ │ ├── op_max_meat.hpp
│ │ │ │ ├── op_mean_bones.hpp
│ │ │ │ ├── op_mean_meat.hpp
│ │ │ │ ├── op_median_bones.hpp
│ │ │ │ ├── op_median_meat.hpp
│ │ │ │ ├── op_min_bones.hpp
│ │ │ │ ├── op_min_meat.hpp
│ │ │ │ ├── op_misc_bones.hpp
│ │ │ │ ├── op_misc_meat.hpp
│ │ │ │ ├── op_nonzeros_bones.hpp
│ │ │ │ ├── op_nonzeros_meat.hpp
│ │ │ │ ├── op_normalise_bones.hpp
│ │ │ │ ├── op_normalise_meat.hpp
│ │ │ │ ├── op_pinv_bones.hpp
│ │ │ │ ├── op_pinv_meat.hpp
│ │ │ │ ├── op_princomp_bones.hpp
│ │ │ │ ├── op_princomp_meat.hpp
│ │ │ │ ├── op_prod_bones.hpp
│ │ │ │ ├── op_prod_meat.hpp
│ │ │ │ ├── op_relational_bones.hpp
│ │ │ │ ├── op_relational_meat.hpp
│ │ │ │ ├── op_repmat_bones.hpp
│ │ │ │ ├── op_repmat_meat.hpp
│ │ │ │ ├── op_reshape_bones.hpp
│ │ │ │ ├── op_reshape_meat.hpp
│ │ │ │ ├── op_resize_bones.hpp
│ │ │ │ ├── op_resize_meat.hpp
│ │ │ │ ├── op_shuffle_bones.hpp
│ │ │ │ ├── op_shuffle_meat.hpp
│ │ │ │ ├── op_sort_bones.hpp
│ │ │ │ ├── op_sort_index_bones.hpp
│ │ │ │ ├── op_sort_index_meat.hpp
│ │ │ │ ├── op_sort_meat.hpp
│ │ │ │ ├── op_stddev_bones.hpp
│ │ │ │ ├── op_stddev_meat.hpp
│ │ │ │ ├── op_strans_bones.hpp
│ │ │ │ ├── op_strans_meat.hpp
│ │ │ │ ├── op_sum_bones.hpp
│ │ │ │ ├── op_sum_meat.hpp
│ │ │ │ ├── op_symmat_bones.hpp
│ │ │ │ ├── op_symmat_meat.hpp
│ │ │ │ ├── op_toeplitz_bones.hpp
│ │ │ │ ├── op_toeplitz_meat.hpp
│ │ │ │ ├── op_trimat_bones.hpp
│ │ │ │ ├── op_trimat_meat.hpp
│ │ │ │ ├── op_unique_bones.hpp
│ │ │ │ ├── op_unique_meat.hpp
│ │ │ │ ├── op_var_bones.hpp
│ │ │ │ ├── op_var_meat.hpp
│ │ │ │ ├── op_vectorise_bones.hpp
│ │ │ │ ├── op_vectorise_meat.hpp
│ │ │ │ ├── operator_cube_div.hpp
│ │ │ │ ├── operator_cube_minus.hpp
│ │ │ │ ├── operator_cube_plus.hpp
│ │ │ │ ├── operator_cube_relational.hpp
│ │ │ │ ├── operator_cube_schur.hpp
│ │ │ │ ├── operator_cube_times.hpp
│ │ │ │ ├── operator_div.hpp
│ │ │ │ ├── operator_minus.hpp
│ │ │ │ ├── operator_ostream.hpp
│ │ │ │ ├── operator_plus.hpp
│ │ │ │ ├── operator_relational.hpp
│ │ │ │ ├── operator_schur.hpp
│ │ │ │ ├── operator_times.hpp
│ │ │ │ ├── podarray_bones.hpp
│ │ │ │ ├── podarray_meat.hpp
│ │ │ │ ├── promote_type.hpp
│ │ │ │ ├── restrictors.hpp
│ │ │ │ ├── running_stat_bones.hpp
│ │ │ │ ├── running_stat_meat.hpp
│ │ │ │ ├── running_stat_vec_bones.hpp
│ │ │ │ ├── running_stat_vec_meat.hpp
│ │ │ │ ├── sp_auxlib_bones.hpp
│ │ │ │ ├── sp_auxlib_meat.hpp
│ │ │ │ ├── span.hpp
│ │ │ │ ├── spdiagview_bones.hpp
│ │ │ │ ├── spdiagview_meat.hpp
│ │ │ │ ├── spglue_join_bones.hpp
│ │ │ │ ├── spglue_join_meat.hpp
│ │ │ │ ├── spglue_minus_bones.hpp
│ │ │ │ ├── spglue_minus_meat.hpp
│ │ │ │ ├── spglue_plus_bones.hpp
│ │ │ │ ├── spglue_plus_meat.hpp
│ │ │ │ ├── spglue_times_bones.hpp
│ │ │ │ ├── spglue_times_meat.hpp
│ │ │ │ ├── spop_htrans_bones.hpp
│ │ │ │ ├── spop_htrans_meat.hpp
│ │ │ │ ├── spop_max_bones.hpp
│ │ │ │ ├── spop_max_meat.hpp
│ │ │ │ ├── spop_mean_bones.hpp
│ │ │ │ ├── spop_mean_meat.hpp
│ │ │ │ ├── spop_min_bones.hpp
│ │ │ │ ├── spop_min_meat.hpp
│ │ │ │ ├── spop_misc_bones.hpp
│ │ │ │ ├── spop_misc_meat.hpp
│ │ │ │ ├── spop_strans_bones.hpp
│ │ │ │ ├── spop_strans_meat.hpp
│ │ │ │ ├── spop_sum_bones.hpp
│ │ │ │ ├── spop_sum_meat.hpp
│ │ │ │ ├── spop_var_bones.hpp
│ │ │ │ ├── spop_var_meat.hpp
│ │ │ │ ├── strip.hpp
│ │ │ │ ├── subview_bones.hpp
│ │ │ │ ├── subview_cube_bones.hpp
│ │ │ │ ├── subview_cube_meat.hpp
│ │ │ │ ├── subview_each_bones.hpp
│ │ │ │ ├── subview_each_meat.hpp
│ │ │ │ ├── subview_elem1_bones.hpp
│ │ │ │ ├── subview_elem1_meat.hpp
│ │ │ │ ├── subview_elem2_bones.hpp
│ │ │ │ ├── subview_elem2_meat.hpp
│ │ │ │ ├── subview_field_bones.hpp
│ │ │ │ ├── subview_field_meat.hpp
│ │ │ │ ├── subview_meat.hpp
│ │ │ │ ├── superlu_bones.hpp
│ │ │ │ ├── superlu_wrapper.hpp
│ │ │ │ ├── traits.hpp
│ │ │ │ ├── typedef_elem.hpp
│ │ │ │ ├── typedef_elem_check.hpp
│ │ │ │ ├── typedef_mat.hpp
│ │ │ │ ├── typedef_mat_fixed.hpp
│ │ │ │ ├── unwrap.hpp
│ │ │ │ ├── unwrap_cube.hpp
│ │ │ │ ├── unwrap_spmat.hpp
│ │ │ │ ├── upgrade_val.hpp
│ │ │ │ ├── wall_clock_bones.hpp
│ │ │ │ ├── wall_clock_meat.hpp
│ │ │ │ ├── xtrans_mat_bones.hpp
│ │ │ │ ├── xtrans_mat_meat.hpp
│ │ │ │ ├── xvec_htrans_bones.hpp
│ │ │ │ └── xvec_htrans_meat.hpp
│ │ │ └── src/
│ │ │ └── wrapper.cpp
│ │ ├── armanpy/
│ │ │ ├── example/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── FindNumPy.cmake
│ │ │ │ ├── example.cpp
│ │ │ │ ├── example.hpp
│ │ │ │ ├── example.i
│ │ │ │ └── example.py
│ │ │ └── include/
│ │ │ ├── armanpy.hpp
│ │ │ ├── armanpy.i
│ │ │ ├── armanpy_1d.i
│ │ │ ├── armanpy_2d.i
│ │ │ ├── armanpy_3d.i
│ │ │ └── numpy.i
│ │ ├── clipper/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── include/
│ │ │ │ └── clipper.hpp
│ │ │ └── src/
│ │ │ └── clipper.cpp
│ │ ├── easylogging/
│ │ │ └── easylogging++.h
│ │ ├── eikonal/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── include/
│ │ │ │ ├── FMM_API.h
│ │ │ │ ├── FMM_Config2d.h
│ │ │ │ ├── FMM_Config3d.h
│ │ │ │ ├── FMM_Core.h
│ │ │ │ ├── FMM_Heap.h
│ │ │ │ └── FMM_Macros.h
│ │ │ └── src/
│ │ │ ├── FMM_Core.c
│ │ │ ├── FMM_Heap.c
│ │ │ ├── FMM_eikonal2d.c
│ │ │ └── FMM_eikonal3d.c
│ │ ├── fftw3-win32/
│ │ │ ├── fftw3.f
│ │ │ ├── fftw3.f03
│ │ │ ├── fftw3.h
│ │ │ ├── fftw3l.f03
│ │ │ ├── fftw3q.f03
│ │ │ ├── libfftw3-3.def
│ │ │ ├── libfftw3.a
│ │ │ ├── libfftw3f-3.def
│ │ │ └── libfftw3l-3.def
│ │ ├── fourier/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── include/
│ │ │ │ ├── basics.h
│ │ │ │ ├── fourier.h
│ │ │ │ └── primes.h
│ │ │ ├── src/
│ │ │ │ ├── check.c
│ │ │ │ ├── fourier.c
│ │ │ │ └── primes.c
│ │ │ └── tools/
│ │ │ └── generate_twiddles.m
│ │ └── kissfft/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ ├── _kiss_fft_guts.h
│ │ │ ├── kiss_fft.h
│ │ │ └── kiss_fftnd.h
│ │ └── src/
│ │ ├── kiss_fft.c
│ │ └── kiss_fftnd.c
│ ├── optolithiumc.i
│ ├── plugins/
│ │ ├── CMakeLists.txt
│ │ └── src/
│ │ ├── dev_models/
│ │ │ ├── enhanced.c
│ │ │ ├── enhanced_notch.c
│ │ │ ├── mack.c
│ │ │ ├── notch.c
│ │ │ └── notch_depth.c
│ │ ├── masks/
│ │ │ ├── fiveBarLine.c
│ │ │ ├── line1D.c
│ │ │ ├── line1D_SRAF.c
│ │ │ └── space1D.c
│ │ ├── pupil_filters/
│ │ │ └── central_obscuration.c
│ │ └── source_shapes/
│ │ ├── annular.c
│ │ ├── coherent.c
│ │ └── convenient.c
│ └── src/
│ ├── opl_capi.cpp
│ ├── opl_contours.cpp
│ ├── opl_geometry.cpp
│ ├── opl_interp.cpp
│ ├── opl_log.cpp
│ └── opl_sim.cpp
├── OptolithiumGui/
│ ├── auxmath.py
│ ├── config.py
│ ├── core.py
│ ├── database/
│ │ ├── Enum.py
│ │ ├── __init__.py
│ │ ├── base.py
│ │ ├── common.py
│ │ ├── dbparser.py
│ │ ├── orm.py
│ │ └── settings.py
│ ├── helpers.py
│ ├── info.py
│ ├── main.py
│ ├── matplotlibrc
│ ├── metrics.py
│ ├── mpl-data/
│ │ ├── fonts/
│ │ │ ├── afm/
│ │ │ │ ├── cmex10.afm
│ │ │ │ ├── cmmi10.afm
│ │ │ │ ├── cmr10.afm
│ │ │ │ ├── cmsy10.afm
│ │ │ │ ├── cmtt10.afm
│ │ │ │ ├── pagd8a.afm
│ │ │ │ ├── pagdo8a.afm
│ │ │ │ ├── pagk8a.afm
│ │ │ │ ├── pagko8a.afm
│ │ │ │ ├── pbkd8a.afm
│ │ │ │ ├── pbkdi8a.afm
│ │ │ │ ├── pbkl8a.afm
│ │ │ │ ├── pbkli8a.afm
│ │ │ │ ├── pcrb8a.afm
│ │ │ │ ├── pcrbo8a.afm
│ │ │ │ ├── pcrr8a.afm
│ │ │ │ ├── pcrro8a.afm
│ │ │ │ ├── phvb8a.afm
│ │ │ │ ├── phvb8an.afm
│ │ │ │ ├── phvbo8a.afm
│ │ │ │ ├── phvbo8an.afm
│ │ │ │ ├── phvl8a.afm
│ │ │ │ ├── phvlo8a.afm
│ │ │ │ ├── phvr8a.afm
│ │ │ │ ├── phvr8an.afm
│ │ │ │ ├── phvro8a.afm
│ │ │ │ ├── phvro8an.afm
│ │ │ │ ├── pncb8a.afm
│ │ │ │ ├── pncbi8a.afm
│ │ │ │ ├── pncr8a.afm
│ │ │ │ ├── pncri8a.afm
│ │ │ │ ├── pplb8a.afm
│ │ │ │ ├── pplbi8a.afm
│ │ │ │ ├── pplr8a.afm
│ │ │ │ ├── pplri8a.afm
│ │ │ │ ├── psyr.afm
│ │ │ │ ├── ptmb8a.afm
│ │ │ │ ├── ptmbi8a.afm
│ │ │ │ ├── ptmr8a.afm
│ │ │ │ ├── ptmri8a.afm
│ │ │ │ ├── putb8a.afm
│ │ │ │ ├── putbi8a.afm
│ │ │ │ ├── putr8a.afm
│ │ │ │ ├── putri8a.afm
│ │ │ │ ├── pzcmi8a.afm
│ │ │ │ └── pzdr.afm
│ │ │ ├── pdfcorefonts/
│ │ │ │ ├── Courier-Bold.afm
│ │ │ │ ├── Courier-BoldOblique.afm
│ │ │ │ ├── Courier-Oblique.afm
│ │ │ │ ├── Courier.afm
│ │ │ │ ├── Helvetica-Bold.afm
│ │ │ │ ├── Helvetica-BoldOblique.afm
│ │ │ │ ├── Helvetica-Oblique.afm
│ │ │ │ ├── Helvetica.afm
│ │ │ │ ├── Symbol.afm
│ │ │ │ ├── Times-Bold.afm
│ │ │ │ ├── Times-BoldItalic.afm
│ │ │ │ ├── Times-Italic.afm
│ │ │ │ ├── Times-Roman.afm
│ │ │ │ └── ZapfDingbats.afm
│ │ │ └── ttf/
│ │ │ └── LICENSE_STIX
│ │ ├── images/
│ │ │ ├── back.ppm
│ │ │ ├── back.xpm
│ │ │ ├── filesave.ppm
│ │ │ ├── filesave.xpm
│ │ │ ├── forward.ppm
│ │ │ ├── forward.xpm
│ │ │ ├── hand.ppm
│ │ │ ├── hand.xpm
│ │ │ ├── home.ppm
│ │ │ ├── home.xpm
│ │ │ ├── move.ppm
│ │ │ ├── move.xpm
│ │ │ ├── stock_close.ppm
│ │ │ ├── stock_close.xpm
│ │ │ ├── stock_down.ppm
│ │ │ ├── stock_down.xpm
│ │ │ ├── stock_left.ppm
│ │ │ ├── stock_left.xpm
│ │ │ ├── stock_refresh.ppm
│ │ │ ├── stock_refresh.xpm
│ │ │ ├── stock_right.ppm
│ │ │ ├── stock_right.xpm
│ │ │ ├── stock_save_as.ppm
│ │ │ ├── stock_save_as.xpm
│ │ │ ├── stock_up.ppm
│ │ │ ├── stock_up.xpm
│ │ │ ├── stock_zoom-in.ppm
│ │ │ ├── stock_zoom-in.xpm
│ │ │ ├── stock_zoom-out.ppm
│ │ │ ├── stock_zoom-out.xpm
│ │ │ ├── subplots.ppm
│ │ │ ├── subplots.xpm
│ │ │ ├── zoom_to_rect.ppm
│ │ │ └── zoom_to_rect.xpm
│ │ └── lineprops.glade
│ ├── options/
│ │ ├── __init__.py
│ │ ├── common.py
│ │ └── structures.py
│ ├── optolithium.py
│ ├── pcpi.py
│ ├── physc.py
│ ├── plugins.py
│ ├── qt.py
│ ├── resources.py
│ ├── setup.py
│ ├── share/
│ │ ├── data/
│ │ │ ├── Air-Vacuum.MAT
│ │ │ ├── Si Dioxide.MAT
│ │ │ ├── Si Nitride.MAT
│ │ │ ├── Silicon.MAT
│ │ │ ├── a-Polysilicon.MAT
│ │ │ ├── fivebar.MSK
│ │ │ └── i-line.res
│ │ └── misc/
│ │ ├── magic
│ │ └── magic.mgc
│ ├── views/
│ │ ├── __init__.py
│ │ ├── appconfig.py
│ │ ├── common.py
│ │ ├── controls.py
│ │ ├── dbview.py
│ │ ├── development.py
│ │ ├── diffraction.py
│ │ ├── exposure.py
│ │ ├── imaging.py
│ │ ├── mask.py
│ │ ├── metrology.py
│ │ ├── numerics.py
│ │ ├── peb.py
│ │ ├── resist.py
│ │ ├── sets.py
│ │ ├── simulations.py
│ │ ├── summary.py
│ │ └── wafer.py
│ └── xhtml/
│ └── report.xhtml
├── README.md
└── installer/
├── GPL-V2.rtf
└── Optolithium.aip
Showing preview only (539K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (6773 symbols across 437 files)
FILE: OptolithiumC/examples/aerial_image_various_source_shapes.py
function get_quasar_source_shape_model (line 8) | def get_quasar_source_shape_model(x, y, sigma_in, sigma_out, blade_angle):
function get_conventional_coherent_source_shape_model (line 25) | def get_conventional_coherent_source_shape_model(step, x, y):
function get_conventional_partially_coherent_source_shape_model (line 33) | def get_conventional_partially_coherent_source_shape_model(x, y, sigma):
function get_annular_source_shape_model (line 43) | def get_annular_source_shape_model(x, y, sigma_in, sigma_out):
function get_dipole_source_shape_model (line 54) | def get_dipole_source_shape_model(x, y, center_sigma, radius_sigma):
function get_monopole_source_shape_model (line 65) | def get_monopole_source_shape_model(x, y, center_x, center_y, radius_sig...
function get_quadrupole_source_shape_model (line 75) | def get_quadrupole_source_shape_model(x, y, center_sigma, radius_sigma, ...
function get_shrinc_source_shape_model (line 95) | def get_shrinc_source_shape_model(x, y, sigma_out, stripe_width):
function get_square_source_shape_model (line 107) | def get_square_source_shape_model(x, y, half_width_sigma):
class AerialImage (line 118) | class AerialImage(object):
method __init__ (line 119) | def __init__(self):
method source_shape_model_choice (line 154) | def source_shape_model_choice(self, x, y):
method aerial_image_formation (line 179) | def aerial_image_formation(self):
function main (line 232) | def main():
FILE: OptolithiumC/examples/resist_images_and_contours.py
function get_quasar_source_shape_model (line 8) | def get_quasar_source_shape_model(x, y, sigma_in, sigma_out, blade_angle):
function get_conventional_coherent_source_shape_model (line 25) | def get_conventional_coherent_source_shape_model(step, x, y):
function get_conventional_partially_coherent_source_shape_model (line 33) | def get_conventional_partially_coherent_source_shape_model(x, y, sigma):
function get_annular_source_shape_model (line 43) | def get_annular_source_shape_model(x, y, sigma_in, sigma_out):
function get_dipole_source_shape_model (line 54) | def get_dipole_source_shape_model(x, y, center_sigma, radius_sigma):
function get_monopole_source_shape_model (line 65) | def get_monopole_source_shape_model(x, y, center_x, center_y, radius_sig...
function get_quadrupole_source_shape_model (line 75) | def get_quadrupole_source_shape_model(x, y, center_sigma, radius_sigma, ...
function get_shrinc_source_shape_model (line 95) | def get_shrinc_source_shape_model(x, y, sigma_out, stripe_width):
function get_square_source_shape_model (line 107) | def get_square_source_shape_model(x, y, half_width_sigma):
class ResistImagesAndContours (line 118) | class ResistImagesAndContours(object):
method __init__ (line 119) | def __init__(self):
method source_shape_model_choice (line 176) | def source_shape_model_choice(self, x, y):
method image_formation (line 201) | def image_formation(self):
function main (line 305) | def main():
FILE: OptolithiumC/include/opl_capi.h
function namespace (line 48) | namespace oplc {
type std (line 240) | typedef std::shared_ptr<AbstractMaskGeometry> SharedAbstractMaskGeometry;
type std (line 241) | typedef std::vector<SharedAbstractMaskGeometry> ArrayOfSharedAbstractMas...
type std (line 243) | typedef std::shared_ptr<Region> SharedRegion;
type std (line 244) | typedef std::shared_ptr<const Region> ConstSharedRegion;
type std (line 245) | typedef std::vector<SharedRegion> ArrayOfSharedRegions;
type std (line 246) | typedef std::shared_ptr<Box> SharedBox;
type std (line 247) | typedef std::shared_ptr<const Box> ConstSharedBox;
type std (line 275) | typedef std::shared_ptr<Mask> SharedMask;
type common_model_type_t (line 278) | typedef enum {
function class (line 285) | class AbstractSourceShapeModel {
function class (line 296) | class SourceShapeModelPlugin : public AbstractSourceShapeModel {
function class (line 308) | class SourceShapeModelSheet : public AbstractSourceShapeModel {
function class (line 319) | class AbstractResistRateModel {
function class (line 330) | class ResistRateModelExpression : public AbstractResistRateModel {
function class (line 342) | class ResistRateModelDepthSheet : public AbstractResistRateModel {
function class (line 353) | class ResistRateModelSheet : public AbstractResistRateModel {
function class (line 364) | class AbstractPupilFilterModel {
function class (line 375) | class PupilFilterModelPlugin : public AbstractPupilFilterModel {
function class (line 387) | class PupilFilterModelSheet : public AbstractPupilFilterModel {
function class (line 399) | class PupilFilterModelEmpty : public AbstractPupilFilterModel {
type std (line 407) | typedef std::shared_ptr<AbstractResistRateModel> SharedAbstractResistRat...
type std (line 408) | typedef std::shared_ptr<const AbstractResistRateModel> ConstSharedAbstra...
type std (line 409) | typedef std::shared_ptr<ResistRateModelExpression> SharedResistRateModel...
type std (line 410) | typedef std::shared_ptr<ResistRateModelSheet> SharedResistRateModelSheet;
type std (line 412) | typedef std::shared_ptr<AbstractSourceShapeModel> SharedAbstractSourceSh...
type std (line 413) | typedef std::shared_ptr<const AbstractSourceShapeModel> ConstSharedAbstr...
type std (line 414) | typedef std::shared_ptr<SourceShapeModelPlugin> SharedSourceShapePlugin;
type std (line 415) | typedef std::shared_ptr<SourceShapeModelSheet> SharedSourceShapeSheet;
type std (line 417) | typedef std::shared_ptr<AbstractPupilFilterModel> SharedAbstractPupilFil...
type std (line 418) | typedef std::shared_ptr<const AbstractPupilFilterModel> ConstSharedAbstr...
type std (line 419) | typedef std::shared_ptr<PupilFilterModelPlugin> SharedPupilFilterPlugin;
type std (line 420) | typedef std::shared_ptr<PupilFilterModelSheet> SharedPupilFilterSheet;
function class (line 423) | class SourceShape {
type std (line 484) | typedef std::shared_ptr<SourceShape> SharedSourceShape;
type std (line 485) | typedef std::shared_ptr<const SourceShape> ConstSharedSourceShape;
function class (line 488) | class ImagingTool {
type std (line 510) | typedef std::shared_ptr<ImagingTool> SharedImagingTool;
type std (line 511) | typedef std::shared_ptr<const ImagingTool> ConstSharedImagingTool;
function class (line 514) | class Exposure {
type std (line 527) | typedef std::shared_ptr<Exposure> SharedExposure;
type std (line 528) | typedef std::shared_ptr<const Exposure> ConstSharedExposure;
function within_circle (line 531) | inline bool within_circle(double dx, double dy, double r) {
function within_circle (line 546) | inline bool within_circle(double x, double y, double cx, double cy, doub...
function class (line 551) | class Diffraction {
function std (line 617) | static std::shared_ptr<T> _select_axis(uint32_t axis, std::shared_ptr<T>...
FILE: OptolithiumC/include/opl_contours.h
function namespace (line 39) | namespace contours {
FILE: OptolithiumC/include/opl_conv.h
function namespace (line 36) | namespace conv {
FILE: OptolithiumC/include/opl_eikonal.h
function namespace (line 36) | namespace eikonal {
FILE: OptolithiumC/include/opl_fft.h
function namespace (line 47) | namespace fft {
FILE: OptolithiumC/include/opl_geometry.h
function namespace (line 63) | namespace geometry {
FILE: OptolithiumC/include/opl_interp.h
function namespace (line 38) | namespace interp {
FILE: OptolithiumC/include/opl_iter.h
function namespace (line 32) | namespace Iterable
FILE: OptolithiumC/include/opl_log.h
function class (line 13) | class OptolithiumCoreLog {
FILE: OptolithiumC/include/opl_misc.h
function namespace (line 30) | namespace misc {
FILE: OptolithiumC/include/opl_physc.h
function namespace (line 31) | namespace physc {
FILE: OptolithiumC/include/optolithium.h
type plugin_type_t (line 59) | typedef enum {
type plugin_descriptor_t (line 70) | typedef struct {
type standard_plugin_arg_t (line 80) | typedef struct {
type standard_plugin_arg_t (line 93) | typedef standard_plugin_arg_t dev_model_arg_t;
type dev_model_t (line 95) | typedef struct {
type mask_type_t (line 107) | typedef enum {
type mask_point_t (line 112) | typedef struct {
type mask_region_t (line 117) | typedef struct {
type mask_t (line 124) | typedef struct {
type standard_plugin_arg_t (line 132) | typedef standard_plugin_arg_t mask_parameter_t;
type mask_plugin_t (line 134) | typedef struct {
type standard_plugin_arg_t (line 152) | typedef standard_plugin_arg_t source_shape_arg_t;
type source_shape_plugin_t (line 154) | typedef struct {
type standard_plugin_arg_t (line 167) | typedef standard_plugin_arg_t pupil_filter_arg_t;
type pupil_filter_plugin_t (line 169) | typedef struct {
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/BaseCube_bones.hpp
type BaseCube_eval_Cube (line 15) | struct BaseCube_eval_Cube
type BaseCube_eval_expr (line 22) | struct BaseCube_eval_expr
type BaseCube_eval (line 29) | struct BaseCube_eval {}
type BaseCube_eval<elem_type, derived, true> (line 32) | struct BaseCube_eval<elem_type, derived, true> { typedef BaseCube_eval_...
type BaseCube_eval<elem_type, derived, false> (line 35) | struct BaseCube_eval<elem_type, derived, false> { typedef BaseCube_eval_...
type BaseCube (line 41) | struct BaseCube
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/BaseCube_meat.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 76) | arma_inline
function arma_inline (line 91) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Base_bones.hpp
type Base_inv_yes (line 15) | struct Base_inv_yes
type Base_inv_no (line 23) | struct Base_inv_no
type Base_inv (line 29) | struct Base_inv {}
type Base_inv<derived, true> (line 32) | struct Base_inv<derived, true> { typedef Base_inv_yes<derived> result; }
type Base_inv<derived, false> (line 35) | struct Base_inv<derived, false> { typedef Base_inv_no<derived> result; }
type Base_eval_Mat (line 40) | struct Base_eval_Mat
type Base_eval_expr (line 47) | struct Base_eval_expr
type Base_eval (line 54) | struct Base_eval {}
type Base_eval<elem_type, derived, true> (line 57) | struct Base_eval<elem_type, derived, true> { typedef Base_eval_Mat<elem...
type Base_eval<elem_type, derived, false> (line 60) | struct Base_eval<elem_type, derived, false> { typedef Base_eval_expr<ele...
type Base_trans_cx (line 65) | struct Base_trans_cx
type Base_trans_default (line 74) | struct Base_trans_default
type Base_trans (line 83) | struct Base_trans {}
type Base_trans<derived, true> (line 86) | struct Base_trans<derived, true> { typedef Base_trans_cx<derived> ...
type Base_trans<derived, false> (line 89) | struct Base_trans<derived, false> { typedef Base_trans_default<derived> ...
type Base (line 99) | struct Base
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Base_meat.hpp
function arma_inline (line 15) | arma_inline
function arma_warn_unused (line 81) | inline
function arma_warn_unused (line 92) | inline
function elem_type (line 103) | inline
function elem_type (line 115) | inline
function elem_type (line 127) | inline
function elem_type (line 148) | inline
function arma_inline (line 172) | arma_inline
function arma_inline (line 182) | arma_inline
function arma_inline (line 199) | arma_inline
function arma_inline (line 214) | arma_inline
function arma_inline (line 229) | arma_inline
function arma_inline (line 239) | arma_inline
function arma_inline (line 249) | arma_inline
function arma_inline (line 262) | arma_inline
function arma_inline (line 272) | arma_inline
function arma_inline (line 282) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Col_bones.hpp
class Col (line 15) | class Col : public Mat<eT>
class fixed (line 134) | class fixed
class Col<eT>::fixed (line 153) | class Col<eT>::fixed : public Col<eT>
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Col_meat.hpp
function arma_inline (line 488) | arma_inline
function arma_inline (line 498) | arma_inline
function arma_inline (line 508) | arma_inline
function arma_inline (line 518) | arma_inline
function arma_inline (line 532) | arma_inline
function arma_inline (line 546) | arma_inline
function arma_inline (line 562) | arma_inline
function arma_inline (line 578) | arma_inline
function arma_inline (line 594) | arma_inline
function arma_inline (line 610) | arma_inline
function arma_inline (line 622) | arma_inline
function arma_inline (line 634) | arma_inline
function arma_inline (line 656) | arma_inline
function arma_inline (line 678) | arma_inline
function arma_inline (line 690) | arma_inline
function arma_inline (line 702) | arma_inline
function arma_inline (line 716) | arma_inline
function arma_inline (line 730) | arma_inline
function arma_inline (line 746) | arma_inline
function arma_inline (line 762) | arma_inline
function arma_inline (line 774) | arma_inline
function arma_inline (line 786) | arma_inline
function arma_inline (line 798) | arma_inline
function arma_inline (line 922) | arma_inline
function arma_inline (line 933) | arma_inline
function arma_inline (line 944) | arma_inline
function arma_inline (line 955) | arma_inline
function arma_inline (line 1023) | arma_inline
function arma_inline (line 1289) | arma_inline
function arma_inline (line 1386) | arma_inline
function arma_inline (line 1397) | arma_inline
function arma_inline (line 1408) | arma_inline
function arma_inline (line 1419) | arma_inline
function arma_inline (line 1441) | arma_inline
function arma_inline (line 1453) | arma_inline
function arma_inline (line 1465) | arma_inline
function arma_inline (line 1477) | arma_inline
function arma_inline (line 1489) | arma_inline
function arma_inline (line 1503) | arma_inline
function arma_inline (line 1517) | arma_inline
function arma_inline (line 1529) | arma_inline
function arma_inline (line 1541) | arma_inline
function arma_inline (line 1555) | arma_inline
function arma_inline (line 1569) | arma_inline
function arma_inline (line 1581) | arma_inline
function arma_hot (line 1593) | arma_hot
function arma_hot (line 1611) | arma_hot
function arma_hot (line 1629) | arma_hot
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Cube_bones.hpp
type Cube_prealloc (line 14) | struct Cube_prealloc
class Cube (line 25) | class Cube : public BaseCube< eT, Cube<eT> >
class fixed (line 334) | class fixed
class Cube<eT>::fixed (line 364) | class Cube<eT>::fixed : public Cube<eT>
class Cube_aux (line 412) | class Cube_aux
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Cube_meat.hpp
function arma_inline (line 438) | arma_inline
function arma_inline (line 453) | arma_inline
function arma_inline (line 468) | arma_inline
function arma_inline (line 483) | arma_inline
function arma_inline (line 498) | arma_inline
function arma_inline (line 816) | arma_inline
function arma_inline (line 836) | arma_inline
function arma_inline (line 856) | arma_inline
function arma_inline (line 877) | arma_inline
function arma_inline (line 898) | arma_inline
function arma_inline (line 922) | arma_inline
function arma_inline (line 1137) | arma_inline
function arma_inline (line 1155) | arma_inline
function arma_inline (line 1173) | arma_inline
function arma_inline (line 1195) | arma_inline
function arma_inline (line 1217) | arma_inline
function arma_inline (line 1241) | arma_inline
function arma_inline (line 1336) | arma_inline
function arma_inline (line 1349) | arma_inline
function arma_inline (line 1362) | arma_inline
function arma_inline (line 1375) | arma_inline
function arma_inline (line 2326) | arma_inline
function arma_inline (line 2341) | arma_inline
function arma_inline (line 2354) | arma_inline
function arma_inline (line 2366) | arma_inline
function arma_inline (line 2378) | arma_inline
function arma_inline (line 2390) | arma_inline
function arma_inline (line 2402) | arma_inline
function arma_inline (line 2414) | arma_inline
function arma_inline (line 2435) | arma_inline
function arma_inline (line 2456) | arma_inline
function arma_inline (line 2468) | arma_inline
function arma_inline (line 2480) | arma_inline
function arma_inline (line 2492) | arma_inline
function arma_inline (line 2503) | arma_inline
function arma_inline (line 2515) | arma_inline
function arma_inline (line 2526) | arma_inline
function arma_inline (line 2538) | arma_inline
function arma_warn_unused (line 2549) | inline
function arma_warn_unused (line 2562) | inline
function arma_inline (line 2576) | arma_inline
function arma_inline (line 2588) | arma_inline
function arma_inline (line 2612) | arma_inline
function arma_warn_unused (line 2623) | inline
function arma_warn_unused (line 2651) | inline
function arma_inline (line 2677) | arma_inline
function arma_inline (line 2689) | arma_inline
function arma_inline (line 2701) | arma_inline
function arma_inline (line 2713) | arma_inline
function arma_inline (line 2725) | arma_inline
function arma_inline (line 2737) | arma_inline
function arma_warn_unused (line 3118) | inline
function arma_warn_unused (line 3138) | inline
function eT (line 3158) | inline
function eT (line 3177) | inline
function eT (line 3196) | inline
function eT (line 3227) | inline
function uword (line 3686) | inline
function arma_inline (line 3829) | arma_inline
function arma_inline (line 3963) | arma_inline
function arma_inline (line 3975) | arma_inline
function arma_inline (line 3987) | arma_inline
function arma_inline (line 3999) | arma_inline
function arma_inline (line 4011) | arma_inline
function arma_inline (line 4025) | arma_inline
function arma_inline (line 4039) | arma_inline
function arma_inline (line 4053) | arma_inline
function arma_inline (line 4067) | arma_inline
function arma_inline (line 4090) | arma_inline
function arma_inline (line 4118) | arma_inline
function arma_inline (line 4143) | arma_inline
function arma_inline (line 4154) | arma_inline
function arma_inline (line 4179) | arma_inline
function arma_inline (line 4190) | arma_inline
function arma_inline (line 4215) | arma_inline
function arma_inline (line 4226) | arma_inline
function arma_inline (line 4251) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/GenCube_bones.hpp
class GenCube (line 15) | class GenCube : public BaseCube<eT, GenCube<eT, gen_type> >
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/GenCube_meat.hpp
function arma_inline (line 27) | arma_inline
function arma_inline (line 36) | arma_inline
function arma_inline (line 50) | arma_inline
function arma_inline (line 60) | arma_inline
function arma_inline (line 70) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Gen_bones.hpp
class Gen (line 15) | class Gen : public Base<typename T1::elem_type, Gen<T1, gen_type> >
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Gen_meat.hpp
function arma_inline (line 26) | arma_inline
function arma_inline (line 35) | arma_inline
function arma_inline (line 51) | arma_inline
function arma_inline (line 70) | arma_inline
function arma_inline (line 89) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/GlueCube_bones.hpp
class GlueCube (line 16) | class GlueCube : public BaseCube<typename T1::elem_type, GlueCube<T1, T2...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Glue_bones.hpp
class Glue (line 28) | class Glue : public Base<typename T1::elem_type, Glue<T1, T2, glue_type> >
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Mat_bones.hpp
class Mat (line 18) | class Mat : public Base< eT, Mat<eT> >
class row_iterator (line 480) | class row_iterator
class const_row_iterator (line 503) | class const_row_iterator
class const_row_col_iterator (line 527) | class const_row_col_iterator
class row_col_iterator (line 529) | class row_col_iterator
class const_row_col_iterator (line 567) | class const_row_col_iterator
class fixed (line 644) | class fixed
class Mat<eT>::fixed (line 687) | class Mat<eT>::fixed : public Mat<eT>
class Mat_aux (line 774) | class Mat_aux
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Mat_meat.hpp
function arma_inline (line 676) | arma_inline
function arma_inline (line 691) | arma_inline
function arma_inline (line 706) | arma_inline
function arma_inline (line 721) | arma_inline
function arma_inline (line 736) | arma_inline
function arma_inline (line 2777) | arma_inline
function arma_inline (line 2792) | arma_inline
function arma_inline (line 2865) | arma_inline
function arma_inline (line 2880) | arma_inline
function arma_inline (line 2993) | arma_inline
function arma_inline (line 3014) | arma_inline
function arma_inline (line 3035) | arma_inline
function arma_inline (line 3056) | arma_inline
function arma_inline (line 3133) | arma_inline
function arma_inline (line 3161) | arma_inline
function arma_inline (line 3189) | arma_inline
function arma_inline (line 3211) | arma_inline
function arma_inline (line 3233) | arma_inline
function arma_inline (line 3258) | arma_inline
function arma_inline (line 3523) | arma_inline
function arma_inline (line 3536) | arma_inline
function arma_inline (line 3549) | arma_inline
function arma_inline (line 3562) | arma_inline
function arma_inline (line 3575) | arma_inline
function arma_inline (line 3588) | arma_inline
function arma_inline (line 3601) | arma_inline
function arma_inline (line 3614) | arma_inline
function arma_inline (line 3627) | arma_inline
function arma_inline (line 3640) | arma_inline
function arma_inline (line 3653) | arma_inline
function arma_inline (line 3666) | arma_inline
function arma_inline (line 3679) | arma_inline
function arma_inline (line 3692) | arma_inline
function arma_inline (line 3704) | arma_inline
function arma_inline (line 3716) | arma_inline
function arma_inline (line 3755) | arma_inline
function arma_inline (line 3779) | arma_inline
function arma_inline (line 5156) | arma_inline
function arma_inline (line 5171) | arma_inline
function arma_inline (line 5184) | arma_inline
function arma_inline (line 5196) | arma_inline
function arma_inline (line 5208) | arma_inline
function arma_inline (line 5220) | arma_inline
function arma_inline (line 5232) | arma_inline
function arma_inline (line 5244) | arma_inline
function arma_inline (line 5257) | arma_inline
function arma_inline (line 5270) | arma_inline
function arma_inline (line 5282) | arma_inline
function arma_inline (line 5294) | arma_inline
function arma_inline (line 5306) | arma_inline
function arma_inline (line 5317) | arma_inline
function arma_inline (line 5329) | arma_inline
function arma_inline (line 5340) | arma_inline
function arma_inline (line 5352) | arma_inline
function arma_inline (line 5364) | arma_inline
function arma_inline (line 5376) | arma_inline
function arma_inline (line 5388) | arma_inline
function arma_warn_unused (line 5400) | inline
function arma_warn_unused (line 5411) | inline
function arma_warn_unused (line 5424) | inline
function arma_warn_unused (line 5437) | inline
function arma_warn_unused (line 5450) | inline
function arma_inline (line 5591) | arma_inline
function arma_inline (line 5603) | arma_inline
function arma_inline (line 5627) | arma_inline
function arma_inline (line 5638) | arma_inline
function arma_inline (line 5661) | arma_inline
function arma_inline (line 5684) | arma_inline
function arma_inline (line 5706) | arma_inline
function arma_inline (line 5728) | arma_inline
function arma_inline (line 5740) | arma_inline
function arma_inline (line 5752) | arma_inline
function arma_inline (line 5764) | arma_inline
function arma_hot (line 6070) | arma_hot
function arma_hot (line 6087) | arma_hot
function arma_warn_unused (line 6358) | inline
function arma_warn_unused (line 6378) | inline
function eT (line 6398) | inline
function eT (line 6417) | inline
function eT (line 6436) | inline
function eT (line 6462) | inline
function eT (line 6793) | inline
function eT (line 6908) | inline
function eT (line 7039) | inline
function uword (line 7119) | inline
function uword (line 7129) | inline
function eT (line 7232) | inline
function uword (line 7313) | inline
function uword (line 7323) | inline
function uword (line 7618) | inline
function arma_inline (line 7811) | arma_inline
function arma_inline (line 7908) | arma_inline
function arma_inline (line 7919) | arma_inline
function arma_inline (line 7930) | arma_inline
function arma_inline (line 7941) | arma_inline
function arma_inline (line 7963) | arma_inline
function arma_inline (line 7975) | arma_inline
function arma_inline (line 7987) | arma_inline
function arma_inline (line 7999) | arma_inline
function arma_inline (line 8011) | arma_inline
function arma_inline (line 8025) | arma_inline
function arma_inline (line 8039) | arma_inline
function arma_inline (line 8053) | arma_inline
function arma_inline (line 8067) | arma_inline
function arma_inline (line 8083) | arma_inline
function arma_inline (line 8099) | arma_inline
function arma_inline (line 8113) | arma_inline
function arma_inline (line 8127) | arma_inline
function arma_inline (line 8139) | arma_inline
function arma_inline (line 8151) | arma_inline
function arma_hot (line 8163) | arma_hot
function arma_hot (line 8181) | arma_hot
function arma_hot (line 8199) | arma_hot
function arma_inline (line 8217) | arma_inline
function arma_inline (line 8242) | arma_inline
function arma_inline (line 8253) | arma_inline
function arma_inline (line 8278) | arma_inline
function arma_inline (line 8289) | arma_inline
function arma_inline (line 8314) | arma_inline
function arma_inline (line 8325) | arma_inline
function arma_inline (line 8350) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/OpCube_bones.hpp
class OpCube (line 16) | class OpCube : public BaseCube<typename T1::elem_type, OpCube<T1, op_typ...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Op_bones.hpp
class Op (line 25) | class Op : public Base<typename T1::elem_type, Op<T1, op_type> >
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Proxy.hpp
type Proxy_default (line 19) | struct Proxy_default
method Proxy_default (line 21) | inline Proxy_default(const T1&)
type Proxy_fixed (line 30) | struct Proxy_fixed
method Proxy_fixed (line 47) | inline explicit Proxy_fixed(const T1& A)
method arma_inline (line 53) | arma_inline static uword get_n_rows() { return T1::n_rows; }
method arma_inline (line 54) | arma_inline static uword get_n_cols() { return T1::n_cols; }
method arma_inline (line 55) | arma_inline static uword get_n_elem() { return T1::n_elem; }
method arma_inline (line 57) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 58) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 59) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 61) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 62) | get_aligned_ea() const { return Q; }
method arma_inline (line 65) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 67) | arma_inline bool is_aligned() const
type Proxy_redirect (line 80) | struct Proxy_redirect {}
type Proxy_redirect<T1, false> (line 83) | struct Proxy_redirect<T1, false> { typedef Proxy_default<T1> result; }
type Proxy_redirect<T1, true> (line 86) | struct Proxy_redirect<T1, true> { typedef Proxy_fixed<T1> result; }
class Proxy (line 91) | class Proxy : public Proxy_redirect<T1, is_Mat_fixed<T1>::value >::result
method Proxy (line 94) | inline Proxy(const T1& A)
class Proxy< Mat<eT> > (line 103) | class Proxy< Mat<eT> >
method Proxy (line 122) | inline explicit Proxy(const Mat<eT>& A)
method arma_inline (line 128) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 129) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 130) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 132) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 133) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 134) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 136) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 137) | get_aligned_ea() const { return Q; }
method arma_inline (line 140) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 142) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< Col<eT> > (line 148) | class Proxy< Col<eT> >
method Proxy (line 167) | inline explicit Proxy(const Col<eT>& A)
method arma_inline (line 173) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 174) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 175) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 177) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 178) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 179) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 181) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 182) | get_aligned_ea() const { return Q; }
method arma_inline (line 185) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 187) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< Row<eT> > (line 193) | class Proxy< Row<eT> >
method Proxy (line 212) | inline explicit Proxy(const Row<eT>& A)
method arma_inline (line 218) | arma_inline uword get_n_rows() const { return 1; }
method arma_inline (line 219) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 220) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 222) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 223) | arma_inline elem_type at (const uword, const uword col) const ...
method arma_inline (line 224) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 226) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 227) | get_aligned_ea() const { return Q; }
method arma_inline (line 230) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 232) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< Gen<T1, gen_type > > (line 238) | class Proxy< Gen<T1, gen_type > >
method Proxy (line 257) | inline explicit Proxy(const Gen<T1, gen_type>& A)
method arma_inline (line 263) | arma_inline uword get_n_rows() const { return (is_row ? 1 : Q.n_rows);...
method arma_inline (line 264) | arma_inline uword get_n_cols() const { return (is_col ? 1 : Q.n_cols);...
method arma_inline (line 265) | arma_inline uword get_n_elem() const { return (is_row ? 1 : Q.n_rows) ...
method arma_inline (line 267) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 268) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 269) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 271) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 272) | get_aligned_ea() const { return Q; }
method arma_inline (line 275) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 277) | arma_inline bool is_aligned() const { return Gen<T1, gen_type>::is_sim...
class Proxy< Op<T1, op_type> > (line 283) | class Proxy< Op<T1, op_type> >
method Proxy (line 302) | inline explicit Proxy(const Op<T1, op_type>& A)
method arma_inline (line 308) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; }
method arma_inline (line 309) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; }
method arma_inline (line 310) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 312) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 313) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 314) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 316) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 317) | get_aligned_ea() const { return Q; }
method arma_inline (line 320) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 322) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy_diagvec_mat (line 328) | class Proxy_diagvec_mat
method Proxy_diagvec_mat (line 330) | inline Proxy_diagvec_mat(const T1&) {}
class Proxy_diagvec_mat< Op<T1, op_diagvec> > (line 336) | class Proxy_diagvec_mat< Op<T1, op_diagvec> >
method Proxy_diagvec_mat (line 356) | inline explicit Proxy_diagvec_mat(const Op<T1, op_diagvec>& A)
method arma_inline (line 362) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 363) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 364) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 366) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 367) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 368) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 370) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 371) | get_aligned_ea() const { return Q; }
method arma_inline (line 374) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 376) | arma_inline bool is_aligned() const { return false; }
class Proxy_diagvec_expr (line 382) | class Proxy_diagvec_expr
method Proxy_diagvec_expr (line 384) | inline Proxy_diagvec_expr(const T1&) {}
class Proxy_diagvec_expr< Op<T1, op_diagvec> > (line 390) | class Proxy_diagvec_expr< Op<T1, op_diagvec> >
method Proxy_diagvec_expr (line 409) | inline explicit Proxy_diagvec_expr(const Op<T1, op_diagvec>& A)
method arma_inline (line 415) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 416) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 417) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 419) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 420) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 421) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 423) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 424) | get_aligned_ea() const { return Q; }
method arma_inline (line 427) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 429) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
type Proxy_diagvec_redirect (line 435) | struct Proxy_diagvec_redirect {}
type Proxy_diagvec_redirect< Op<T1, op_diagvec>, true > (line 438) | struct Proxy_diagvec_redirect< Op<T1, op_diagvec>, true > { typedef Prox...
type Proxy_diagvec_redirect< Op<T1, op_diagvec>, false> (line 441) | struct Proxy_diagvec_redirect< Op<T1, op_diagvec>, false> { typedef Prox...
class Proxy< Op<T1, op_diagvec> > (line 446) | class Proxy< Op<T1, op_diagvec> >
method Proxy (line 453) | inline explicit Proxy(const Op<T1, op_diagvec>& A)
type Proxy_xtrans_default (line 463) | struct Proxy_xtrans_default
method Proxy_xtrans_default (line 465) | inline Proxy_xtrans_default(const T1&) {}
type Proxy_xtrans_default< Op<T1, op_htrans> > (line 471) | struct Proxy_xtrans_default< Op<T1, op_htrans> >
method Proxy_xtrans_default (line 491) | inline explicit Proxy_xtrans_default(const Op<T1, op_htrans>& A)
method arma_inline (line 498) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 499) | get_aligned_ea() const { return Q; }
method arma_inline (line 502) | arma_inline bool is_alias(const Mat<eT2>& X) const { return void_ptr(&...
method arma_inline (line 504) | arma_inline bool is_aligned() const { return false; }
type Proxy_xtrans_default< Op<T1, op_strans> > (line 510) | struct Proxy_xtrans_default< Op<T1, op_strans> >
method Proxy_xtrans_default (line 530) | inline explicit Proxy_xtrans_default(const Op<T1, op_strans>& A)
method arma_inline (line 537) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 538) | get_aligned_ea() const { return Q; }
method arma_inline (line 541) | arma_inline bool is_alias(const Mat<eT2>& X) const { return void_ptr(&...
method arma_inline (line 543) | arma_inline bool is_aligned() const { return false; }
type Proxy_xtrans_vector (line 549) | struct Proxy_xtrans_vector
method Proxy_xtrans_vector (line 551) | inline Proxy_xtrans_vector(const T1&) {}
type Proxy_xtrans_vector< Op<T1, op_htrans> > (line 557) | struct Proxy_xtrans_vector< Op<T1, op_htrans> >
method Proxy_xtrans_vector (line 576) | inline Proxy_xtrans_vector(const Op<T1, op_htrans>& A)
method arma_inline (line 583) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 584) | get_aligned_ea() const { return Q; }
method arma_inline (line 587) | arma_inline bool is_alias(const Mat<eT2>& X) const { return U.is_alias...
method arma_inline (line 589) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
type Proxy_xtrans_vector< Op<T1, op_strans> > (line 595) | struct Proxy_xtrans_vector< Op<T1, op_strans> >
method Proxy_xtrans_vector (line 614) | inline Proxy_xtrans_vector(const Op<T1, op_strans>& A)
method arma_inline (line 621) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 622) | get_aligned_ea() const { return Q; }
method arma_inline (line 625) | arma_inline bool is_alias(const Mat<eT2>& X) const { return U.is_alias...
method arma_inline (line 627) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
type Proxy_xtrans_redirect (line 633) | struct Proxy_xtrans_redirect {}
type Proxy_xtrans_redirect<T1, false> (line 636) | struct Proxy_xtrans_redirect<T1, false> { typedef Proxy_xtrans_default<T...
type Proxy_xtrans_redirect<T1, true> (line 639) | struct Proxy_xtrans_redirect<T1, true> { typedef Proxy_xtrans_vector<T1...
class Proxy< Op<T1, op_htrans> > (line 644) | class Proxy< Op<T1, op_htrans> >
method Proxy (line 678) | inline explicit Proxy(const Op<T1, op_htrans>& A)
method arma_inline (line 684) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; }
method arma_inline (line 685) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; }
method arma_inline (line 686) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 688) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 689) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 690) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 692) | arma_inline ea_type get_ea() const { return Proxy_xtra...
method get_aligned_ea (line 693) | get_aligned_ea() const { return Proxy_xtrans::get_aligned_ea(); }
method arma_inline (line 696) | arma_inline bool is_alias(const Mat<eT2>& X) const { return Proxy_xtra...
method arma_inline (line 698) | arma_inline bool is_aligned() const { return Proxy_xtrans::is_aligned(...
class Proxy< Op<T1, op_strans> > (line 704) | class Proxy< Op<T1, op_strans> >
method Proxy (line 738) | inline explicit Proxy(const Op<T1, op_strans>& A)
method arma_inline (line 744) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; }
method arma_inline (line 745) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; }
method arma_inline (line 746) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 748) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 749) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 750) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 752) | arma_inline ea_type get_ea() const { return Proxy_xtra...
method get_aligned_ea (line 753) | get_aligned_ea() const { return Proxy_xtrans::get_aligned_ea(); }
method arma_inline (line 756) | arma_inline bool is_alias(const Mat<eT2>& X) const { return Proxy_xtra...
method arma_inline (line 758) | arma_inline bool is_aligned() const { return Proxy_xtrans::is_aligned(...
type Proxy_subview_row_htrans_cx (line 764) | struct Proxy_subview_row_htrans_cx
method Proxy_subview_row_htrans_cx (line 781) | inline explicit Proxy_subview_row_htrans_cx(const Op<subview_row<eT>, ...
method arma_inline (line 788) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
type Proxy_subview_row_htrans_non_cx (line 794) | struct Proxy_subview_row_htrans_non_cx
method Proxy_subview_row_htrans_non_cx (line 811) | inline explicit Proxy_subview_row_htrans_non_cx(const Op<subview_row<e...
method arma_inline (line 818) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
type Proxy_subview_row_htrans_redirect (line 824) | struct Proxy_subview_row_htrans_redirect {}
type Proxy_subview_row_htrans_redirect<eT, true> (line 827) | struct Proxy_subview_row_htrans_redirect<eT, true> { typedef Proxy_subv...
type Proxy_subview_row_htrans_redirect<eT, false> (line 830) | struct Proxy_subview_row_htrans_redirect<eT, false> { typedef Proxy_subv...
class Proxy< Op<subview_row<eT>, op_htrans> > (line 835) | class Proxy< Op<subview_row<eT>, op_htrans> >
method Proxy (line 869) | inline explicit Proxy(const Op<subview_row<eT>, op_htrans>& A)
method arma_inline (line 875) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 876) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 877) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 879) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 880) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 881) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 883) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 884) | get_aligned_ea() const { return Q; }
method arma_inline (line 887) | arma_inline bool is_alias(const Mat<eT2>& X) const { return Proxy_sv_r...
method arma_inline (line 889) | arma_inline bool is_aligned() const { return false; }
class Proxy< Op<subview_row<eT>, op_strans> > (line 895) | class Proxy< Op<subview_row<eT>, op_strans> >
method Proxy (line 914) | inline explicit Proxy(const Op<subview_row<eT>, op_strans>& A)
method arma_inline (line 920) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 921) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 922) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 924) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 925) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 926) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 928) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 929) | get_aligned_ea() const { return Q; }
method arma_inline (line 932) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 934) | arma_inline bool is_aligned() const { return false; }
class Proxy< Op< Row< std::complex<T> >, op_htrans> > (line 940) | class Proxy< Op< Row< std::complex<T> >, op_htrans> >
method Proxy (line 962) | inline explicit Proxy(const Op< Row< std::complex<T> >, op_htrans>& A)
method arma_inline (line 969) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 970) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 971) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 973) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 974) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 975) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 977) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 978) | get_aligned_ea() const { return Q; }
method arma_inline (line 981) | arma_inline bool is_alias(const Mat<eT2>& X) const { return void_ptr(&...
method arma_inline (line 983) | arma_inline bool is_aligned() const { return false; }
class Proxy< Op< Col< std::complex<T> >, op_htrans> > (line 989) | class Proxy< Op< Col< std::complex<T> >, op_htrans> >
method Proxy (line 1011) | inline explicit Proxy(const Op< Col< std::complex<T> >, op_htrans>& A)
method arma_inline (line 1018) | arma_inline uword get_n_rows() const { return 1; }
method arma_inline (line 1019) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 1020) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1022) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1023) | arma_inline elem_type at (const uword, const uword col) const ...
method arma_inline (line 1024) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1026) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1027) | get_aligned_ea() const { return Q; }
method arma_inline (line 1030) | arma_inline bool is_alias(const Mat<eT2>& X) const { return void_ptr(&...
method arma_inline (line 1032) | arma_inline bool is_aligned() const { return false; }
class Proxy< Op< subview_col< std::complex<T> >, op_htrans> > (line 1038) | class Proxy< Op< subview_col< std::complex<T> >, op_htrans> >
method Proxy (line 1060) | inline explicit Proxy(const Op< subview_col< std::complex<T> >, op_htr...
method arma_inline (line 1067) | arma_inline uword get_n_rows() const { return 1; }
method arma_inline (line 1068) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 1069) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1071) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1072) | arma_inline elem_type at (const uword, const uword col) const ...
method arma_inline (line 1073) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1075) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1076) | get_aligned_ea() const { return Q; }
method arma_inline (line 1079) | arma_inline bool is_alias(const Mat<eT2>& X) const { return void_ptr(&...
method arma_inline (line 1081) | arma_inline bool is_aligned() const { return false; }
class Proxy< Op<T1, op_htrans2> > (line 1087) | class Proxy< Op<T1, op_htrans2> >
method Proxy (line 1108) | inline explicit Proxy(const Op<T1, op_htrans2>& A)
method arma_inline (line 1115) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.get_n_row...
method arma_inline (line 1116) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.get_n_col...
method arma_inline (line 1117) | arma_inline uword get_n_elem() const { return Q.get_n_elem(); ...
method arma_inline (line 1119) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1120) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1121) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1123) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1124) | get_aligned_ea() const { return Q; }
method arma_inline (line 1127) | arma_inline bool is_alias(const Mat<eT2>& X) const { return Q.P.is_ali...
method arma_inline (line 1129) | arma_inline bool is_aligned() const { return Q.P.is_aligned(); }
class Proxy< Op<T1, op_vectorise_col> > (line 1135) | class Proxy< Op<T1, op_vectorise_col> >
method Proxy (line 1155) | inline explicit Proxy(const Op<T1, op_vectorise_col>& A)
method arma_inline (line 1162) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1163) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 1164) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1166) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1167) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 1168) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1170) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 1171) | get_aligned_ea() const { return Q; }
method arma_inline (line 1174) | arma_inline bool is_alias(const Mat<eT2>& X) const { return ( void_ptr...
method arma_inline (line 1176) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< Glue<T1, T2, glue_type> > (line 1182) | class Proxy< Glue<T1, T2, glue_type> >
method Proxy (line 1201) | inline explicit Proxy(const Glue<T1, T2, glue_type>& A)
method arma_inline (line 1207) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; }
method arma_inline (line 1208) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; }
method arma_inline (line 1209) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1211) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1212) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1213) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1215) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 1216) | get_aligned_ea() const { return Q; }
method arma_inline (line 1219) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 1221) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< subview<eT> > (line 1227) | class Proxy< subview<eT> >
method Proxy (line 1246) | inline explicit Proxy(const subview<eT>& A)
method arma_inline (line 1252) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1253) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 1254) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1256) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1257) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1258) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1260) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1261) | get_aligned_ea() const { return Q; }
method arma_inline (line 1264) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 1266) | arma_inline bool is_aligned() const { return false; }
class Proxy< subview_col<eT> > (line 1272) | class Proxy< subview_col<eT> >
method Proxy (line 1291) | inline explicit Proxy(const subview_col<eT>& A)
method arma_inline (line 1297) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1298) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 1299) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1301) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1302) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 1303) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1305) | arma_inline ea_type get_ea() const { return Q.colmem; }
method get_aligned_ea (line 1306) | get_aligned_ea() const { return Q; }
method arma_inline (line 1309) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 1311) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.colm...
class Proxy< subview_row<eT> > (line 1317) | class Proxy< subview_row<eT> >
method Proxy (line 1336) | inline explicit Proxy(const subview_row<eT>& A)
method arma_inline (line 1342) | arma_inline uword get_n_rows() const { return 1; }
method arma_inline (line 1343) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 1344) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1346) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1347) | arma_inline elem_type at (const uword, const uword col) const ...
method arma_inline (line 1348) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1350) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1351) | get_aligned_ea() const { return Q; }
method arma_inline (line 1354) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 1356) | arma_inline bool is_aligned() const { return false; }
class Proxy< subview_row_strans<eT> > (line 1362) | class Proxy< subview_row_strans<eT> >
method Proxy (line 1381) | inline explicit Proxy(const subview_row_strans<eT>& A)
method arma_inline (line 1387) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1388) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 1389) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1391) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1392) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 1393) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1395) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1396) | get_aligned_ea() const { return Q; }
method arma_inline (line 1399) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 1401) | arma_inline bool is_aligned() const { return false; }
class Proxy< subview_row_htrans<eT> > (line 1407) | class Proxy< subview_row_htrans<eT> >
method Proxy (line 1426) | inline explicit Proxy(const subview_row_htrans<eT>& A)
method arma_inline (line 1432) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1433) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 1434) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1436) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1437) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 1438) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1440) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1441) | get_aligned_ea() const { return Q; }
method arma_inline (line 1444) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 1446) | arma_inline bool is_aligned() const { return false; }
class Proxy< xtrans_mat<eT, do_conj> > (line 1452) | class Proxy< xtrans_mat<eT, do_conj> >
method Proxy (line 1471) | inline explicit Proxy(const xtrans_mat<eT, do_conj>& A)
method arma_inline (line 1477) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1478) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 1479) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1481) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1482) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1483) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1485) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 1486) | get_aligned_ea() const { return Q; }
method arma_inline (line 1489) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 1491) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< xvec_htrans<eT> > (line 1497) | class Proxy< xvec_htrans<eT> >
method Proxy (line 1516) | inline explicit Proxy(const xvec_htrans<eT>& A)
method arma_inline (line 1522) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1523) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 1524) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1526) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1527) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1528) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1530) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 1531) | get_aligned_ea() const { return Q; }
method arma_inline (line 1534) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 1536) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< subview_elem1<eT,T1> > (line 1542) | class Proxy< subview_elem1<eT,T1> >
method Proxy (line 1561) | inline explicit Proxy(const subview_elem1<eT,T1>& A)
method arma_inline (line 1567) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1568) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 1569) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1571) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1572) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 1573) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1575) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 1576) | get_aligned_ea() const { return Q; }
method arma_inline (line 1579) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 1581) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< subview_elem2<eT,T1,T2> > (line 1587) | class Proxy< subview_elem2<eT,T1,T2> >
method Proxy (line 1606) | inline explicit Proxy(const subview_elem2<eT,T1,T2>& A)
method arma_inline (line 1612) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1613) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 1614) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1616) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1617) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1618) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1620) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 1621) | get_aligned_ea() const { return Q; }
method arma_inline (line 1624) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 1626) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< diagview<eT> > (line 1632) | class Proxy< diagview<eT> >
method Proxy (line 1651) | inline explicit Proxy(const diagview<eT>& A)
method arma_inline (line 1657) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1658) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 1659) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1661) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1662) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 1663) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1665) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1666) | get_aligned_ea() const { return Q; }
method arma_inline (line 1669) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(...
method arma_inline (line 1671) | arma_inline bool is_aligned() const { return false; }
class Proxy< spdiagview<eT> > (line 1677) | class Proxy< spdiagview<eT> >
method Proxy (line 1696) | inline explicit Proxy(const spdiagview<eT>& A)
method arma_inline (line 1702) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 1703) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 1704) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1706) | arma_inline elem_type operator[] (const uword i) const ...
method arma_inline (line 1707) | arma_inline elem_type at (const uword row, const uword) const ...
method arma_inline (line 1708) | arma_inline elem_type at_alt (const uword i) const ...
method arma_inline (line 1710) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1711) | get_aligned_ea() const { return Q; }
method arma_inline (line 1714) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 1716) | arma_inline bool is_aligned() const { return false; }
class Proxy< eOp<T1, eop_type > > (line 1722) | class Proxy< eOp<T1, eop_type > >
method Proxy (line 1741) | inline explicit Proxy(const eOp<T1, eop_type>& A)
method arma_inline (line 1747) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.get_n_row...
method arma_inline (line 1748) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.get_n_col...
method arma_inline (line 1749) | arma_inline uword get_n_elem() const { return Q.get_n_elem(); ...
method arma_inline (line 1751) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1752) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1753) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1755) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1756) | get_aligned_ea() const { return Q; }
method arma_inline (line 1759) | arma_inline bool is_alias(const Mat<eT2>& X) const { return Q.P.is_ali...
method arma_inline (line 1761) | arma_inline bool is_aligned() const { return Q.P.is_aligned(); }
class Proxy< eGlue<T1, T2, eglue_type > > (line 1767) | class Proxy< eGlue<T1, T2, eglue_type > >
method Proxy (line 1786) | inline explicit Proxy(const eGlue<T1, T2, eglue_type>& A)
method arma_inline (line 1792) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.get_n_row...
method arma_inline (line 1793) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.get_n_col...
method arma_inline (line 1794) | arma_inline uword get_n_elem() const { return Q.get_n_elem(); ...
method arma_inline (line 1796) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1797) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1798) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1800) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 1801) | get_aligned_ea() const { return Q; }
method arma_inline (line 1804) | arma_inline bool is_alias(const Mat<eT2>& X) const { return (Q.P1.is_a...
method arma_inline (line 1806) | arma_inline bool is_aligned() const { return (Q.P1.is_aligned() && Q.P...
class Proxy< mtOp<out_eT, T1, op_type> > (line 1812) | class Proxy< mtOp<out_eT, T1, op_type> >
method Proxy (line 1831) | inline explicit Proxy(const mtOp<out_eT, T1, op_type>& A)
method arma_inline (line 1837) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; }
method arma_inline (line 1838) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; }
method arma_inline (line 1839) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1841) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1842) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1843) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1845) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 1846) | get_aligned_ea() const { return Q; }
method arma_inline (line 1849) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 1851) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class Proxy< mtGlue<out_eT, T1, T2, glue_type > > (line 1857) | class Proxy< mtGlue<out_eT, T1, T2, glue_type > >
method Proxy (line 1876) | inline explicit Proxy(const mtGlue<out_eT, T1, T2, glue_type>& A)
method arma_inline (line 1882) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; }
method arma_inline (line 1883) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; }
method arma_inline (line 1884) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 1886) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 1887) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 1888) | arma_inline elem_type at_alt (const uword i) co...
method arma_inline (line 1890) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 1891) | get_aligned_ea() const { return Q; }
method arma_inline (line 1894) | arma_inline bool is_alias(const Mat<eT2>&) const { return false; }
method arma_inline (line 1896) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/ProxyCube.hpp
class ProxyCube (line 15) | class ProxyCube
method ProxyCube (line 18) | inline ProxyCube(const T1&)
class ProxyCube< Cube<eT> > (line 30) | class ProxyCube< Cube<eT> >
method ProxyCube (line 45) | inline explicit ProxyCube(const Cube<eT>& A)
method arma_inline (line 51) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 52) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 53) | arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; }
method arma_inline (line 54) | arma_inline uword get_n_slices() const { return Q.n_slices; }
method arma_inline (line 55) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 57) | arma_inline elem_type operator[] (const uword i) ...
method arma_inline (line 58) | arma_inline elem_type at (const uword row, const uword col, co...
method arma_inline (line 59) | arma_inline elem_type at_alt (const uword i) ...
method arma_inline (line 61) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 62) | get_aligned_ea() const { return Q; }
method arma_inline (line 65) | arma_inline bool is_alias(const Cube<eT2>& X) const { return (void_ptr...
method arma_inline (line 67) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class ProxyCube< GenCube<eT, gen_type > > (line 73) | class ProxyCube< GenCube<eT, gen_type > >
method ProxyCube (line 88) | inline explicit ProxyCube(const GenCube<eT, gen_type>& A)
method arma_inline (line 94) | arma_inline uword get_n_rows() const { return Q.n_rows; ...
method arma_inline (line 95) | arma_inline uword get_n_cols() const { return Q.n_cols; ...
method arma_inline (line 96) | arma_inline uword get_n_elem_slice() const { return Q.n_rows*Q.n_cols;...
method arma_inline (line 97) | arma_inline uword get_n_slices() const { return Q.n_slices; ...
method arma_inline (line 98) | arma_inline uword get_n_elem() const { return Q.n_rows*Q.n_cols*...
method arma_inline (line 100) | arma_inline elem_type operator[] (const uword i) ...
method arma_inline (line 101) | arma_inline elem_type at (const uword row, const uword col, co...
method arma_inline (line 102) | arma_inline elem_type at_alt (const uword i) ...
method arma_inline (line 104) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 105) | get_aligned_ea() const { return Q; }
method arma_inline (line 108) | arma_inline bool is_alias(const Cube<eT2>&) const { return false; }
method arma_inline (line 110) | arma_inline bool is_aligned() const { return GenCube<eT, gen_type>::is...
class ProxyCube< OpCube<T1, op_type> > (line 116) | class ProxyCube< OpCube<T1, op_type> >
method ProxyCube (line 131) | inline explicit ProxyCube(const OpCube<T1, op_type>& A)
method arma_inline (line 137) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 138) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 139) | arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; }
method arma_inline (line 140) | arma_inline uword get_n_slices() const { return Q.n_slices; }
method arma_inline (line 141) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 143) | arma_inline elem_type operator[] (const uword i) ...
method arma_inline (line 144) | arma_inline elem_type at (const uword row, const uword col, co...
method arma_inline (line 145) | arma_inline elem_type at_alt (const uword i) ...
method arma_inline (line 147) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 148) | get_aligned_ea() const { return Q; }
method arma_inline (line 151) | arma_inline bool is_alias(const Cube<eT2>&) const { return false; }
method arma_inline (line 153) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class ProxyCube< GlueCube<T1, T2, glue_type> > (line 159) | class ProxyCube< GlueCube<T1, T2, glue_type> >
method ProxyCube (line 174) | inline explicit ProxyCube(const GlueCube<T1, T2, glue_type>& A)
method arma_inline (line 180) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 181) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 182) | arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; }
method arma_inline (line 183) | arma_inline uword get_n_slices() const { return Q.n_slices; }
method arma_inline (line 184) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 186) | arma_inline elem_type operator[] (const uword i) ...
method arma_inline (line 187) | arma_inline elem_type at (const uword row, const uword col, co...
method arma_inline (line 188) | arma_inline elem_type at_alt (const uword i) ...
method arma_inline (line 190) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 191) | get_aligned_ea() const { return Q; }
method arma_inline (line 194) | arma_inline bool is_alias(const Cube<eT2>&) const { return false; }
method arma_inline (line 196) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class ProxyCube< subview_cube<eT> > (line 202) | class ProxyCube< subview_cube<eT> >
method ProxyCube (line 217) | inline explicit ProxyCube(const subview_cube<eT>& A)
method arma_inline (line 223) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 224) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 225) | arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; }
method arma_inline (line 226) | arma_inline uword get_n_slices() const { return Q.n_slices; }
method arma_inline (line 227) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 229) | arma_inline elem_type operator[] (const uword i) ...
method arma_inline (line 230) | arma_inline elem_type at (const uword row, const uword col, co...
method arma_inline (line 231) | arma_inline elem_type at_alt (const uword i) ...
method arma_inline (line 233) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 234) | get_aligned_ea() const { return Q; }
method arma_inline (line 237) | arma_inline bool is_alias(const Cube<eT2>& X) const { return (void_ptr...
method arma_inline (line 239) | arma_inline bool is_aligned() const { return false; }
class ProxyCube< eOpCube<T1, eop_type > > (line 245) | class ProxyCube< eOpCube<T1, eop_type > >
method ProxyCube (line 260) | inline explicit ProxyCube(const eOpCube<T1, eop_type>& A)
method arma_inline (line 266) | arma_inline uword get_n_rows() const { return Q.get_n_rows(); ...
method arma_inline (line 267) | arma_inline uword get_n_cols() const { return Q.get_n_cols(); ...
method arma_inline (line 268) | arma_inline uword get_n_elem_slice() const { return Q.get_n_elem_slice...
method arma_inline (line 269) | arma_inline uword get_n_slices() const { return Q.get_n_slices(); ...
method arma_inline (line 270) | arma_inline uword get_n_elem() const { return Q.get_n_elem(); ...
method arma_inline (line 272) | arma_inline elem_type operator[] (const uword i) ...
method arma_inline (line 273) | arma_inline elem_type at (const uword row, const uword col, co...
method arma_inline (line 274) | arma_inline elem_type at_alt (const uword i) ...
method arma_inline (line 276) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 277) | get_aligned_ea() const { return Q; }
method arma_inline (line 280) | arma_inline bool is_alias(const Cube<eT2>& X) const { return Q.P.is_al...
method arma_inline (line 282) | arma_inline bool is_aligned() const { return Q.P.is_aligned(); }
class ProxyCube< eGlueCube<T1, T2, eglue_type > > (line 288) | class ProxyCube< eGlueCube<T1, T2, eglue_type > >
method ProxyCube (line 303) | inline explicit ProxyCube(const eGlueCube<T1, T2, eglue_type>& A)
method arma_inline (line 309) | arma_inline uword get_n_rows() const { return Q.get_n_rows(); ...
method arma_inline (line 310) | arma_inline uword get_n_cols() const { return Q.get_n_cols(); ...
method arma_inline (line 311) | arma_inline uword get_n_elem_slice() const { return Q.get_n_elem_slice...
method arma_inline (line 312) | arma_inline uword get_n_slices() const { return Q.get_n_slices(); ...
method arma_inline (line 313) | arma_inline uword get_n_elem() const { return Q.get_n_elem(); ...
method arma_inline (line 315) | arma_inline elem_type operator[] (const uword i) ...
method arma_inline (line 316) | arma_inline elem_type at (const uword row, const uword col, co...
method arma_inline (line 317) | arma_inline elem_type at_alt (const uword i) ...
method arma_inline (line 319) | arma_inline ea_type get_ea() const { return Q; }
method get_aligned_ea (line 320) | get_aligned_ea() const { return Q; }
method arma_inline (line 323) | arma_inline bool is_alias(const Cube<eT2>& X) const { return (Q.P1.is_...
method arma_inline (line 325) | arma_inline bool is_aligned() const { return Q.P1.is_aligned() && Q.P2...
class ProxyCube< mtOpCube<out_eT, T1, op_type> > (line 331) | class ProxyCube< mtOpCube<out_eT, T1, op_type> >
method ProxyCube (line 346) | inline explicit ProxyCube(const mtOpCube<out_eT, T1, op_type>& A)
method arma_inline (line 352) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 353) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 354) | arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; }
method arma_inline (line 355) | arma_inline uword get_n_slices() const { return Q.n_slices; }
method arma_inline (line 356) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 358) | arma_inline elem_type operator[] (const uword i) ...
method arma_inline (line 359) | arma_inline elem_type at (const uword row, const uword col, co...
method arma_inline (line 360) | arma_inline elem_type at_alt (const uword i) ...
method arma_inline (line 362) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 363) | get_aligned_ea() const { return Q; }
method arma_inline (line 366) | arma_inline bool is_alias(const Cube<eT2>&) const { return false; }
method arma_inline (line 368) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
class ProxyCube< mtGlueCube<out_eT, T1, T2, glue_type > > (line 374) | class ProxyCube< mtGlueCube<out_eT, T1, T2, glue_type > >
method ProxyCube (line 389) | inline explicit ProxyCube(const mtGlueCube<out_eT, T1, T2, glue_type>& A)
method arma_inline (line 395) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 396) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 397) | arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; }
method arma_inline (line 398) | arma_inline uword get_n_slices() const { return Q.n_slices; }
method arma_inline (line 399) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 401) | arma_inline elem_type operator[] (const uword i) ...
method arma_inline (line 402) | arma_inline elem_type at (const uword row, const uword col, co...
method arma_inline (line 403) | arma_inline elem_type at_alt (const uword i) ...
method arma_inline (line 405) | arma_inline ea_type get_ea() const { return Q.memptr(); }
method get_aligned_ea (line 406) | get_aligned_ea() const { return Q; }
method arma_inline (line 409) | arma_inline bool is_alias(const Cube<eT2>&) const { return false; }
method arma_inline (line 411) | arma_inline bool is_aligned() const { return memory::is_aligned(Q.memp...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Row_bones.hpp
class Row (line 15) | class Row : public Mat<eT>
class fixed (line 134) | class fixed
class Row<eT>::fixed (line 153) | class Row<eT>::fixed : public Row<eT>
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/Row_meat.hpp
function arma_inline (line 454) | arma_inline
function arma_inline (line 464) | arma_inline
function arma_inline (line 474) | arma_inline
function arma_inline (line 484) | arma_inline
function arma_inline (line 498) | arma_inline
function arma_inline (line 512) | arma_inline
function arma_inline (line 528) | arma_inline
function arma_inline (line 544) | arma_inline
function arma_inline (line 560) | arma_inline
function arma_inline (line 576) | arma_inline
function arma_inline (line 588) | arma_inline
function arma_inline (line 600) | arma_inline
function arma_inline (line 622) | arma_inline
function arma_inline (line 644) | arma_inline
function arma_inline (line 656) | arma_inline
function arma_inline (line 668) | arma_inline
function arma_inline (line 682) | arma_inline
function arma_inline (line 696) | arma_inline
function arma_inline (line 712) | arma_inline
function arma_inline (line 728) | arma_inline
function arma_inline (line 740) | arma_inline
function arma_inline (line 752) | arma_inline
function arma_inline (line 764) | arma_inline
function arma_inline (line 888) | arma_inline
function arma_inline (line 899) | arma_inline
function arma_inline (line 910) | arma_inline
function arma_inline (line 921) | arma_inline
function arma_inline (line 1227) | arma_inline
function arma_inline (line 1324) | arma_inline
function arma_inline (line 1335) | arma_inline
function arma_inline (line 1346) | arma_inline
function arma_inline (line 1357) | arma_inline
function arma_inline (line 1379) | arma_inline
function arma_inline (line 1391) | arma_inline
function arma_inline (line 1403) | arma_inline
function arma_inline (line 1415) | arma_inline
function arma_inline (line 1427) | arma_inline
function arma_inline (line 1441) | arma_inline
function arma_inline (line 1455) | arma_inline
function arma_inline (line 1467) | arma_inline
function arma_inline (line 1479) | arma_inline
function arma_inline (line 1493) | arma_inline
function arma_inline (line 1507) | arma_inline
function arma_inline (line 1519) | arma_inline
function arma_hot (line 1531) | arma_hot
function arma_hot (line 1549) | arma_hot
function arma_hot (line 1567) | arma_hot
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SizeCube_bones.hpp
class SizeCube (line 14) | class SizeCube
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SizeMat_bones.hpp
class SizeMat (line 14) | class SizeMat
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpBase_bones.hpp
type SpBase_eval_SpMat (line 15) | struct SpBase_eval_SpMat
type SpBase_eval_expr (line 22) | struct SpBase_eval_expr
type SpBase_eval (line 29) | struct SpBase_eval {}
type SpBase_eval<elem_type, derived, true> (line 32) | struct SpBase_eval<elem_type, derived, true> { typedef SpBase_eval_SpMa...
type SpBase_eval<elem_type, derived, false> (line 35) | struct SpBase_eval<elem_type, derived, false> { typedef SpBase_eval_expr...
type SpBase (line 40) | struct SpBase
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpBase_meat.hpp
function arma_inline (line 15) | arma_inline
function derived (line 153) | inline
function arma_warn_unused (line 180) | inline
function arma_warn_unused (line 191) | inline
function elem_type (line 202) | inline
function elem_type (line 214) | inline
function elem_type (line 226) | inline
function elem_type (line 247) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpCol_bones.hpp
class SpCol (line 15) | class SpCol : public SpMat<eT>
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpGlue_bones.hpp
class SpGlue (line 14) | class SpGlue : public SpBase<typename T1::elem_type, SpGlue<T1, T2, spgl...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpMat_bones.hpp
class SpMat (line 15) | class SpMat : public SpBase< eT, SpMat<eT> >
class iterator_base (line 344) | class iterator_base
method arma_inline (line 363) | arma_inline uword row() const { return M->row_indices[internal_pos]; }
method arma_inline (line 364) | arma_inline uword col() const { return internal_col; }
method arma_inline (line 365) | arma_inline uword pos() const { return internal_pos; }
class iterator (line 345) | class iterator
method iterator (line 420) | inline iterator() : const_iterator() { }
method iterator (line 421) | inline iterator(SpMat& in_M, uword initial_pos = 0) : const_iterator...
method iterator (line 422) | inline iterator(SpMat& in_M, uword in_row, uword in_col) : const_ite...
method iterator (line 423) | inline iterator(SpMat& in_M, uword in_row, uword in_col, uword in_po...
method iterator (line 424) | inline iterator(const const_iterator& other) : const_iterator(other)...
class const_iterator (line 346) | class const_iterator
class row_iterator (line 347) | class row_iterator
method row_iterator (line 481) | inline row_iterator() : const_row_iterator() {}
method row_iterator (line 482) | inline row_iterator(SpMat& in_M, uword initial_pos = 0) : const_row_...
method row_iterator (line 484) | inline row_iterator(SpMat& in_M, uword in_row, uword in_col) : const...
method row_iterator (line 485) | inline row_iterator(const row_iterator& other) : const_row_iterator(...
class const_row_iterator (line 348) | class const_row_iterator
method arma_inline (line 460) | arma_inline eT operator*() const { return iterator_base::M->values[a...
method arma_inline (line 462) | arma_inline uword row() const { return internal_row; }
class iterator_base (line 352) | class iterator_base
method arma_inline (line 363) | arma_inline uword row() const { return M->row_indices[internal_pos]; }
method arma_inline (line 364) | arma_inline uword col() const { return internal_col; }
method arma_inline (line 365) | arma_inline uword pos() const { return internal_pos; }
class const_iterator (line 379) | class const_iterator : public iterator_base
class iterator (line 416) | class iterator : public const_iterator
method iterator (line 420) | inline iterator() : const_iterator() { }
method iterator (line 421) | inline iterator(SpMat& in_M, uword initial_pos = 0) : const_iterator...
method iterator (line 422) | inline iterator(SpMat& in_M, uword in_row, uword in_col) : const_ite...
method iterator (line 423) | inline iterator(SpMat& in_M, uword in_row, uword in_col, uword in_po...
method iterator (line 424) | inline iterator(const const_iterator& other) : const_iterator(other)...
class const_row_iterator (line 441) | class const_row_iterator : public iterator_base
method arma_inline (line 460) | arma_inline eT operator*() const { return iterator_base::M->values[a...
method arma_inline (line 462) | arma_inline uword row() const { return internal_row; }
class row_iterator (line 477) | class row_iterator : public const_row_iterator
method row_iterator (line 481) | inline row_iterator() : const_row_iterator() {}
method row_iterator (line 482) | inline row_iterator(SpMat& in_M, uword initial_pos = 0) : const_row_...
method row_iterator (line 484) | inline row_iterator(SpMat& in_M, uword in_row, uword in_col) : const...
method row_iterator (line 485) | inline row_iterator(const row_iterator& other) : const_row_iterator(...
class SpMat_aux (line 629) | class SpMat_aux
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpMat_iterators_meat.hpp
function arma_hot (line 54) | inline
function arma_hot (line 140) | inline
function arma_hot (line 165) | inline
function arma_hot (line 180) | inline
function arma_hot (line 208) | inline
function arma_hot (line 223) | inline
function arma_hot (line 234) | inline
function arma_hot (line 245) | inline
function arma_hot (line 256) | inline
function arma_hot (line 267) | inline
function arma_hot (line 278) | inline
function arma_hot (line 289) | inline
function arma_hot (line 300) | inline
function arma_hot (line 315) | inline
function arma_hot (line 330) | inline
function arma_hot (line 342) | inline
function arma_hot (line 357) | inline
function arma_hot (line 369) | inline
function arma_hot (line 513) | inline
function arma_hot (line 565) | inline
function arma_hot (line 583) | inline
function arma_hot (line 625) | inline
function arma_hot (line 640) | inline
function arma_hot (line 651) | inline
function arma_hot (line 662) | inline
function arma_hot (line 673) | inline
function arma_hot (line 684) | inline
function arma_hot (line 695) | inline
function arma_hot (line 706) | inline
function arma_hot (line 717) | inline
function arma_hot (line 732) | inline
function arma_hot (line 747) | inline
function arma_hot (line 759) | inline
function arma_hot (line 774) | inline
function arma_hot (line 786) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpMat_meat.hpp
function arma_inline (line 1549) | arma_inline
function arma_inline (line 1563) | arma_inline
function arma_inline (line 1635) | arma_inline
function arma_inline (line 1649) | arma_inline
function arma_inline (line 1721) | arma_inline
function arma_inline (line 1741) | arma_inline
function arma_inline (line 1761) | arma_inline
function arma_inline (line 1781) | arma_inline
function arma_inline (line 1801) | arma_inline
function arma_inline (line 1822) | arma_inline
function arma_inline (line 1843) | arma_inline
function arma_inline (line 1867) | arma_inline
function arma_inline (line 1985) | arma_inline
function arma_inline (line 1997) | arma_inline
function arma_inline (line 2498) | arma_inline
function arma_inline (line 2509) | arma_inline
function arma_inline (line 2520) | arma_inline
function arma_inline (line 2531) | arma_inline
function arma_inline (line 2542) | arma_inline
function arma_inline (line 2554) | arma_inline
function arma_inline (line 2571) | arma_inline
function arma_inline (line 2582) | arma_inline
function arma_inline (line 2593) | arma_inline
function arma_inline (line 2605) | arma_inline
function arma_inline (line 2620) | arma_inline
function arma_inline (line 2632) | arma_inline
function arma_inline (line 2644) | arma_inline
function arma_inline (line 2656) | arma_inline
function arma_inline (line 2668) | arma_inline
function arma_warn_unused (line 2680) | inline
function arma_warn_unused (line 2693) | inline
function arma_warn_unused (line 2706) | inline
function arma_inline (line 2720) | arma_inline
function arma_inline (line 2731) | arma_inline
function arma_inline (line 2755) | arma_inline
function arma_inline (line 2766) | arma_inline
function arma_inline (line 2789) | arma_inline
function arma_inline (line 2812) | arma_inline
function arma_inline (line 2834) | arma_inline
function arma_hot (line 4434) | arma_hot
function arma_hot (line 4467) | arma_hot
function uword (line 4746) | inline
function arma_hot (line 4756) | inline
function arma_hot (line 4772) | inline
function arma_hot (line 4788) | inline
function arma_hot (line 4823) | inline
function arma_hot (line 4861) | arma_hot
function arma_hot (line 4878) | arma_hot
function arma_hot (line 4908) | inline
function arma_hot (line 5017) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpOp_bones.hpp
class SpOp (line 14) | class SpOp : public SpBase<typename T1::elem_type, SpOp<T1, op_type> >
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpProxy.hpp
class SpProxy< SpMat<eT> > (line 14) | class SpProxy< SpMat<eT> >
method SpProxy (line 33) | inline explicit SpProxy(const SpMat<eT>& A)
method arma_inline (line 39) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 40) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 41) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 42) | arma_inline uword get_n_nonzero() const { return Q.n_nonzero; }
method arma_inline (line 44) | arma_inline elem_type operator[](const uword i) con...
method arma_inline (line 45) | arma_inline elem_type at (const uword row, const uword col) con...
method arma_inline (line 47) | arma_inline const eT* get_values() const { return Q.values; ...
method arma_inline (line 48) | arma_inline const uword* get_row_indices() const { return Q.row_indice...
method arma_inline (line 49) | arma_inline const uword* get_col_ptrs() const { return Q.col_ptrs; ...
method begin (line 51) | begin() const { return Q.begin(); }
method begin_col (line 52) | begin_col(const uword col_num) const { return Q.begin_col(col_num); }
method begin_row (line 53) | begin_row(const uword row_num = 0) const { return Q.begin_row(row_num); }
method end (line 55) | end() const { return Q.end(); }
method end_row (line 56) | end_row() const { return Q.end_row(); }
method end_row (line 57) | end_row(const uword row_num) const { return Q.end_row(row_num); }
method arma_inline (line 60) | arma_inline bool is_alias(const SpMat<eT2>& X) const { return (void_pt...
class SpProxy< SpCol<eT> > (line 66) | class SpProxy< SpCol<eT> >
method SpProxy (line 85) | inline explicit SpProxy(const SpCol<eT>& A)
method arma_inline (line 91) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 92) | arma_inline uword get_n_cols() const { return 1; }
method arma_inline (line 93) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 94) | arma_inline uword get_n_nonzero() const { return Q.n_nonzero; }
method arma_inline (line 96) | arma_inline elem_type operator[](const uword i) con...
method arma_inline (line 97) | arma_inline elem_type at (const uword row, const uword col) con...
method arma_inline (line 99) | arma_inline const eT* get_values() const { return Q.values; ...
method arma_inline (line 100) | arma_inline const uword* get_row_indices() const { return Q.row_indice...
method arma_inline (line 101) | arma_inline const uword* get_col_ptrs() const { return Q.col_ptrs; ...
method begin (line 103) | begin() const { return Q.begin(); }
method begin_col (line 104) | begin_col(const uword) const { return Q.begin(); }
method begin_row (line 105) | begin_row(const uword row_num = 0) const { return Q.begin_row(row_num); }
method end (line 107) | end() const { return Q.end(); }
method end_row (line 108) | end_row() const { return Q.end_row(); }
method end_row (line 109) | end_row(const uword row_num) const { return Q.end_row(row_num); }
method arma_inline (line 112) | arma_inline bool is_alias(const SpMat<eT2>& X) const { return (void_pt...
class SpProxy< SpRow<eT> > (line 118) | class SpProxy< SpRow<eT> >
method SpProxy (line 137) | inline explicit SpProxy(const SpRow<eT>& A)
method arma_inline (line 143) | arma_inline uword get_n_rows() const { return 1; }
method arma_inline (line 144) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 145) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 146) | arma_inline uword get_n_nonzero() const { return Q.n_nonzero; }
method arma_inline (line 148) | arma_inline elem_type operator[](const uword i) con...
method arma_inline (line 149) | arma_inline elem_type at (const uword row, const uword col) con...
method arma_inline (line 151) | arma_inline const eT* get_values() const { return Q.values; ...
method arma_inline (line 152) | arma_inline const uword* get_row_indices() const { return Q.row_indice...
method arma_inline (line 153) | arma_inline const uword* get_col_ptrs() const { return Q.col_ptrs; ...
method begin (line 155) | begin() const { return Q.begin(); }
method begin_col (line 156) | begin_col(const uword col_num) const { return Q.begin_col(col_num); }
method begin_row (line 157) | begin_row(const uword row_num = 0) const { return Q.begin_row(row_num); }
method end (line 159) | end() const { return Q.end(); }
method end_row (line 160) | end_row() const { return Q.end_row(); }
method end_row (line 161) | end_row(const uword row_num) const { return Q.end_row(row_num); }
method arma_inline (line 164) | arma_inline bool is_alias(const SpMat<eT2>& X) const { return (void_pt...
class SpProxy< SpSubview<eT> > (line 170) | class SpProxy< SpSubview<eT> >
method SpProxy (line 189) | inline explicit SpProxy(const SpSubview<eT>& A)
method arma_inline (line 195) | arma_inline uword get_n_rows() const { return Q.n_rows; }
method arma_inline (line 196) | arma_inline uword get_n_cols() const { return Q.n_cols; }
method arma_inline (line 197) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 198) | arma_inline uword get_n_nonzero() const { return Q.n_nonzero; }
method arma_inline (line 200) | arma_inline elem_type operator[](const uword i) con...
method arma_inline (line 201) | arma_inline elem_type at (const uword row, const uword col) con...
method arma_inline (line 203) | arma_inline const eT* get_values() const { return Q.m.values; ...
method arma_inline (line 204) | arma_inline const uword* get_row_indices() const { return Q.m.row_indi...
method arma_inline (line 205) | arma_inline const uword* get_col_ptrs() const { return Q.m.col_ptrs...
method begin (line 207) | begin() const { return Q.begin(); }
method begin_col (line 208) | begin_col(const uword col_num) const { return Q.begin_col(col_num); }
method begin_row (line 209) | begin_row(const uword row_num = 0) const { return Q.begin_row(row_num); }
method end (line 211) | end() const { return Q.end(); }
method end_row (line 212) | end_row() const { return Q.end_row(); }
method end_row (line 213) | end_row(const uword row_num) const { return Q.end_row(row_num); }
method arma_inline (line 216) | arma_inline bool is_alias(const SpMat<eT2>& X) const { return (void_pt...
class SpProxy< SpOp<T1, spop_type> > (line 222) | class SpProxy< SpOp<T1, spop_type> >
method SpProxy (line 242) | inline explicit SpProxy(const SpOp<T1, spop_type>& A)
method arma_inline (line 248) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; }
method arma_inline (line 249) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; }
method arma_inline (line 250) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 251) | arma_inline uword get_n_nonzero() const { return Q.n_nonzero; }
method arma_inline (line 253) | arma_inline elem_type operator[](const uword i) con...
method arma_inline (line 254) | arma_inline elem_type at (const uword row, const uword col) con...
method arma_inline (line 256) | arma_inline const eT* get_values() const { return Q.values; ...
method arma_inline (line 257) | arma_inline const uword* get_row_indices() const { return Q.row_indice...
method arma_inline (line 258) | arma_inline const uword* get_col_ptrs() const { return Q.col_ptrs; ...
method begin (line 260) | begin() const { return Q.begin(); }
method begin_col (line 261) | begin_col(const uword col_num) const { return Q.begin_col(col_num); }
method begin_row (line 262) | begin_row(const uword row_num = 0) const { return Q.begin_row(row_num); }
method end (line 264) | end() const { return Q.end(); }
method end_row (line 265) | end_row() const { return Q.end_row(); }
method end_row (line 266) | end_row(const uword row_num) const { return Q.end_row(row_num); }
method arma_inline (line 269) | arma_inline bool is_alias(const SpMat<eT2>&) const { return false; }
class SpProxy< SpGlue<T1, T2, spglue_type> > (line 275) | class SpProxy< SpGlue<T1, T2, spglue_type> >
method SpProxy (line 295) | inline explicit SpProxy(const SpGlue<T1, T2, spglue_type>& A)
method arma_inline (line 301) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; }
method arma_inline (line 302) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; }
method arma_inline (line 303) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 304) | arma_inline uword get_n_nonzero() const { return Q.n_nonzero; }
method arma_inline (line 306) | arma_inline elem_type operator[](const uword i) con...
method arma_inline (line 307) | arma_inline elem_type at (const uword row, const uword col) con...
method arma_inline (line 309) | arma_inline const eT* get_values() const { return Q.values; ...
method arma_inline (line 310) | arma_inline const uword* get_row_indices() const { return Q.row_indice...
method arma_inline (line 311) | arma_inline const uword* get_col_ptrs() const { return Q.col_ptrs; ...
method begin (line 313) | begin() const { return Q.begin(); }
method begin_col (line 314) | begin_col(const uword col_num) const { return Q.begin_col(col_num); }
method begin_row (line 315) | begin_row(const uword row_num = 0) const { return Q.begin_row(row_num); }
method end (line 317) | end() const { return Q.end(); }
method end_row (line 318) | end_row() const { return Q.end_row(); }
method end_row (line 319) | end_row(const uword row_num) const { return Q.end_row(row_num); }
method arma_inline (line 322) | arma_inline bool is_alias(const SpMat<eT2>&) const { return false; }
class SpProxy< mtSpOp<out_eT, T1, spop_type> > (line 328) | class SpProxy< mtSpOp<out_eT, T1, spop_type> >
method SpProxy (line 348) | inline explicit SpProxy(const mtSpOp<out_eT, T1, spop_type>& A)
method arma_inline (line 354) | arma_inline uword get_n_rows() const { return is_row ? 1 : Q.n_rows; }
method arma_inline (line 355) | arma_inline uword get_n_cols() const { return is_col ? 1 : Q.n_cols; }
method arma_inline (line 356) | arma_inline uword get_n_elem() const { return Q.n_elem; }
method arma_inline (line 357) | arma_inline uword get_n_nonzero() const { return Q.n_nonzero; }
method arma_inline (line 359) | arma_inline elem_type operator[](const uword i) con...
method arma_inline (line 360) | arma_inline elem_type at (const uword row, const uword col) con...
method arma_inline (line 362) | arma_inline const eT* get_values() const { return Q.values; ...
method arma_inline (line 363) | arma_inline const uword* get_row_indices() const { return Q.row_indice...
method arma_inline (line 364) | arma_inline const uword* get_col_ptrs() const { return Q.col_ptrs; ...
method begin (line 366) | begin() const { return Q.begin(); }
method begin_col (line 367) | begin_col(const uword col_num) const { return Q.begin_col(col_num); }
method begin_row (line 368) | begin_row(const uword row_num = 0) const { return Q.begin_row(row_num); }
method end (line 370) | end() const { return Q.end(); }
method end_row (line 371) | end_row() const { return Q.end_row(); }
method end_row (line 372) | end_row(const uword row_num) const { return Q.end_row(row_num); }
method arma_inline (line 375) | arma_inline bool is_alias(const SpMat<eT2>&) const { return false; }
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpRow_bones.hpp
class SpRow (line 15) | class SpRow : public SpMat<eT>
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpSubview_bones.hpp
class SpSubview (line 13) | class SpSubview : public SpBase<eT, SpSubview<eT> >
class iterator_base (line 132) | class iterator_base
method arma_inline (line 149) | arma_inline uword row() const { return M.m.row_indices[internal_pos ...
method arma_inline (line 150) | arma_inline uword col() const { return internal_col; ...
method arma_inline (line 151) | arma_inline uword pos() const { return internal_pos; ...
class const_iterator (line 133) | class const_iterator
class iterator (line 134) | class iterator
method iterator (line 198) | inline iterator(SpSubview& in_M, const uword initial_pos = 0) : cons...
method iterator (line 199) | inline iterator(SpSubview& in_M, const uword in_row, const uword in_...
method iterator (line 200) | inline iterator(SpSubview& in_M, const uword in_row, const uword in_...
method iterator (line 201) | inline iterator(const iterator& other) : const_iterator(other) { }
class const_row_iterator (line 135) | class const_row_iterator
method arma_inline (line 235) | arma_inline eT operator*() const { return iterator_base::M.m.values[...
method arma_inline (line 237) | arma_inline uword row() const { return internal_row; }
class row_iterator (line 136) | class row_iterator
method row_iterator (line 256) | inline row_iterator(SpSubview& in_M, uword initial_pos = 0) : const_...
method row_iterator (line 257) | inline row_iterator(SpSubview& in_M, uword in_row, uword in_col) : c...
method row_iterator (line 258) | inline row_iterator(const row_iterator& other) : const_row_iterator(...
class iterator_base (line 139) | class iterator_base
method arma_inline (line 149) | arma_inline uword row() const { return M.m.row_indices[internal_pos ...
method arma_inline (line 150) | arma_inline uword col() const { return internal_col; ...
method arma_inline (line 151) | arma_inline uword pos() const { return internal_pos; ...
class const_iterator (line 166) | class const_iterator : public iterator_base
class iterator (line 194) | class iterator : public const_iterator
method iterator (line 198) | inline iterator(SpSubview& in_M, const uword initial_pos = 0) : cons...
method iterator (line 199) | inline iterator(SpSubview& in_M, const uword in_row, const uword in_...
method iterator (line 200) | inline iterator(SpSubview& in_M, const uword in_row, const uword in_...
method iterator (line 201) | inline iterator(const iterator& other) : const_iterator(other) { }
class const_row_iterator (line 218) | class const_row_iterator : public iterator_base
method arma_inline (line 235) | arma_inline eT operator*() const { return iterator_base::M.m.values[...
method arma_inline (line 237) | arma_inline uword row() const { return internal_row; }
class row_iterator (line 252) | class row_iterator : public const_row_iterator
method row_iterator (line 256) | inline row_iterator(SpSubview& in_M, uword initial_pos = 0) : const_...
method row_iterator (line 257) | inline row_iterator(SpSubview& in_M, uword in_row, uword in_col) : c...
method row_iterator (line 258) | inline row_iterator(const row_iterator& other) : const_row_iterator(...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpSubview_iterators_meat.hpp
function eT (line 42) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpSubview_meat.hpp
function arma_hot (line 865) | arma_hot
function arma_hot (line 879) | arma_hot
function arma_hot (line 893) | arma_hot
function arma_hot (line 909) | arma_hot
function arma_hot (line 925) | arma_hot
function arma_hot (line 938) | arma_hot
function arma_hot (line 951) | arma_hot
function arma_hot (line 965) | arma_hot
function arma_hot (line 979) | arma_hot
function arma_hot (line 1010) | arma_hot
function arma_hot (line 1529) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpValProxy_bones.hpp
class SpValProxy (line 17) | class SpValProxy
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/SpValProxy_meat.hpp
function arma_inline (line 26) | arma_inline
function arma_inline (line 37) | arma_inline
function arma_inline (line 47) | arma_inline
function arma_inline (line 87) | arma_inline
function arma_inline (line 112) | arma_inline
function arma_inline (line 137) | arma_inline
function arma_inline (line 170) | arma_inline
function arma_inline (line 217) | arma_inline
function arma_inline (line 238) | arma_inline
function arma_inline (line 259) | arma_inline
function arma_inline (line 287) | arma_inline
function arma_inline (line 315) | arma_inline
function arma_inline (line 331) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/access.hpp
class access (line 13) | class access
method arma_inline (line 18) | arma_inline static T1& rw (const T1& x) { return const_cast<T1...
method arma_inline (line 19) | arma_inline static T1*& rwp(const T1* const& x) { return const_cast<T1...
method arma_inline (line 22) | arma_inline static const eT& tmp_real(const eT& X) { retu...
method arma_inline (line 23) | arma_inline static const T tmp_real(const std::complex<T>& X) { retu...
method arma_inline (line 26) | arma_inline static const typename enable_if2<is_not_complex<eT>::value...
method arma_inline (line 27) | arma_inline static const typename enable_if2< is_complex<eT>::value...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_boost.hpp
type arma_boost (line 13) | namespace arma_boost
function arma_snprintf (line 26) | inline
class format (line 47) | class format
method format (line 51) | format(const char* in_fmt)
method format (line 56) | format(const std::string& in_fmt)
class basic_format (line 71) | class basic_format
method basic_format (line 75) | basic_format(const T1& in_A, const T2& in_B)
function str (line 111) | inline
function str (line 163) | inline
function str (line 215) | inline
function str (line 267) | inline
function str (line 319) | inline
function str (line 371) | inline
type format_metaprog (line 423) | struct format_metaprog
type format_metaprog< basic_format<T1,T2> > (line 440) | struct format_metaprog< basic_format<T1,T2> >
function str (line 457) | inline
type string_only (line 476) | struct string_only { }
type string_only<std::string> (line 477) | struct string_only<std::string> { typedef std::string result; }
type char_only (line 479) | struct char_only { }
type char_only<char > (line 480) | struct char_only<char > { typedef char result; }
type basic_format_only (line 483) | struct basic_format_only { }
type basic_format_only< basic_format<T1, T2> > (line 486) | struct basic_format_only< basic_format<T1, T2> > { typedef basic_forma...
function T1 (line 491) | inline
function T1 (line 504) | inline
function str_wrapper (line 517) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_cmath.hpp
function arma_inline (line 20) | arma_inline
function arma_inline (line 32) | arma_inline
function arma_inline (line 62) | arma_inline
function arma_inline (line 92) | arma_inline
function arma_inline (line 113) | arma_inline
function arma_inline (line 125) | arma_inline
function arma_inline (line 151) | arma_inline
function arma_inline (line 177) | arma_inline
function arma_inline (line 191) | arma_inline
function arma_inline (line 203) | arma_inline
function arma_inline (line 227) | arma_inline
function arma_inline (line 251) | arma_inline
function arma_inline (line 262) | arma_inline
function arma_inline (line 291) | arma_inline
function arma_inline (line 353) | arma_inline
function arma_inline (line 378) | arma_inline
function arma_inline (line 403) | arma_inline
function arma_inline (line 428) | arma_inline
function arma_inline (line 465) | arma_inline
function arma_inline (line 488) | arma_inline
function arma_inline (line 525) | arma_inline
function arma_inline (line 550) | arma_inline
function arma_inline (line 575) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_config.hpp
type arma_config (line 14) | struct arma_config
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_ostream_bones.hpp
class arma_ostream_state (line 14) | class arma_ostream_state
class arma_ostream (line 33) | class arma_ostream
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_ostream_meat.hpp
function arma_inline (line 304) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_rng.hpp
class arma_rng (line 29) | class arma_rng
type randi (line 52) | struct randi
type randu (line 53) | struct randu
type randn (line 54) | struct randn
type timeval (line 140) | struct timeval
type arma_rng::randi (line 172) | struct arma_rng::randi
method arma_inline (line 174) | arma_inline
method max_val (line 193) | inline
method fill (line 214) | inline
type arma_rng::randu (line 238) | struct arma_rng::randu
method arma_inline (line 240) | arma_inline
method fill (line 259) | inline
type arma_rng::randu< std::complex<T> > (line 285) | struct arma_rng::randu< std::complex<T> >
method arma_inline (line 287) | arma_inline
method fill (line 297) | inline
type arma_rng::randn (line 315) | struct arma_rng::randn
method arma_inline (line 336) | arma_inline
method fill (line 357) | inline
type arma_rng::randn< std::complex<T> > (line 380) | struct arma_rng::randn< std::complex<T> >
method fill (line 393) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_rng_cxx11.hpp
class arma_rng_cxx11 (line 16) | class arma_rng_cxx11
function arma_inline (line 62) | arma_inline
function arma_inline (line 71) | arma_inline
function arma_inline (line 80) | arma_inline
function arma_inline (line 90) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_rng_cxx98.hpp
class arma_rng_cxx98 (line 14) | class arma_rng_cxx98
function arma_inline (line 46) | arma_inline
function arma_inline (line 68) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_static_check.hpp
type arma_type_check_cxx1998 (line 15) | struct arma_type_check_cxx1998
method arma_inline (line 17) | arma_inline
type arma_type_check_cxx1998<false> (line 30) | struct arma_type_check_cxx1998<false>
method arma_inline (line 32) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arma_version.hpp
type arma_version (line 21) | struct arma_version
method as_string (line 27) | static
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arpack_wrapper.hpp
type arpack (line 12) | namespace arpack
function naupd (line 18) | inline
function saupd (line 56) | inline
function seupd (line 78) | inline
function neupd (line 102) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arrayops_bones.hpp
class arrayops (line 13) | class arrayops
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/arrayops_meat.hpp
function arma_hot (line 15) | arma_hot
function arma_hot (line 33) | arma_hot
function arma_hot (line 63) | arma_hot
function arma_hot (line 89) | arma_hot
function arma_hot (line 128) | arma_hot
function arma_hot (line 139) | arma_hot
function arma_hot (line 159) | arma_hot
function arma_hot (line 177) | arma_hot
function arma_hot (line 194) | arma_hot
function arma_hot (line 246) | arma_hot
function arma_hot (line 268) | arma_hot
function arma_hot (line 306) | arma_hot
function arma_hot (line 344) | arma_hot
function arma_hot (line 382) | arma_hot
function arma_hot (line 420) | arma_hot
function arma_hot (line 456) | arma_hot
function arma_hot (line 492) | arma_hot
function arma_hot (line 528) | arma_hot
function arma_hot (line 564) | arma_hot
function arma_hot (line 600) | arma_hot
function arma_hot (line 633) | arma_hot
function arma_hot (line 663) | arma_hot
function arma_hot (line 677) | arma_hot
function arma_hot (line 697) | arma_hot
function arma_hot (line 717) | arma_hot
function arma_hot (line 737) | arma_hot
function arma_hot (line 757) | arma_hot
function arma_hot (line 790) | arma_hot
function arma_hot (line 823) | arma_hot
function arma_hot (line 856) | arma_hot
function arma_hot (line 889) | arma_hot
function arma_hot (line 937) | arma_hot
function arma_hot (line 965) | arma_hot
function arma_hot (line 998) | arma_hot
function arma_hot (line 1025) | arma_hot
function arma_hot (line 1083) | arma_hot
function arma_hot (line 1118) | arma_hot
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/atlas_bones.hpp
type atlas (line 13) | namespace atlas
type CBLAS_ORDER (line 34) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 34) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 37) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 37) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 40) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 40) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 43) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 43) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 48) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 48) | enum CBLAS_TRANSPOSE
type CBLAS_TRANSPOSE (line 48) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 52) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 52) | enum CBLAS_TRANSPOSE
type CBLAS_TRANSPOSE (line 52) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 56) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 56) | enum CBLAS_TRANSPOSE
type CBLAS_TRANSPOSE (line 56) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 60) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 60) | enum CBLAS_TRANSPOSE
type CBLAS_TRANSPOSE (line 60) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 66) | enum CBLAS_ORDER
type CBLAS_UPLO (line 66) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 66) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 70) | enum CBLAS_ORDER
type CBLAS_UPLO (line 70) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 70) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 76) | enum CBLAS_ORDER
type CBLAS_UPLO (line 76) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 76) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 80) | enum CBLAS_ORDER
type CBLAS_UPLO (line 80) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 80) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 86) | enum CBLAS_ORDER
type CBLAS_ORDER (line 87) | enum CBLAS_ORDER
type CBLAS_ORDER (line 88) | enum CBLAS_ORDER
type CBLAS_ORDER (line 89) | enum CBLAS_ORDER
type CBLAS_ORDER (line 91) | enum CBLAS_ORDER
type CBLAS_ORDER (line 92) | enum CBLAS_ORDER
type CBLAS_ORDER (line 93) | enum CBLAS_ORDER
type CBLAS_ORDER (line 94) | enum CBLAS_ORDER
type CBLAS_ORDER (line 96) | enum CBLAS_ORDER
type CBLAS_ORDER (line 97) | enum CBLAS_ORDER
type CBLAS_ORDER (line 98) | enum CBLAS_ORDER
type CBLAS_ORDER (line 99) | enum CBLAS_ORDER
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/atlas_wrapper.hpp
type atlas (line 13) | namespace atlas
function eT (line 17) | inline static const eT& tmp_real(const eT& X) { return X; }
function T (line 20) | inline static const T tmp_real(const std::complex<T>& X) { return X....
function arma_inline (line 25) | arma_inline
function arma_inline (line 51) | arma_inline
function cblas_gemv (line 85) | inline
function cblas_gemm (line 128) | inline
function cblas_syrk (line 169) | inline
function cblas_herk (line 196) | inline
function clapack_getrf (line 227) | inline
function clapack_getri (line 269) | inline
function clapack_gesv (line 311) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/auxlib_bones.hpp
class auxlib (line 17) | class auxlib
type pos (line 23) | struct pos
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/auxlib_meat.hpp
function eT (line 486) | inline
function eT (line 519) | inline
function eT (line 608) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/blas_wrapper.hpp
type blas (line 14) | namespace blas
function gemv (line 19) | inline
function gemm (line 54) | inline
function syrk (line 89) | inline
function herk (line 111) | inline
function eT (line 137) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/cond_rel_bones.hpp
class cond_rel (line 17) | class cond_rel
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/cond_rel_meat.hpp
function arma_inline (line 16) | arma_inline
function arma_inline (line 27) | arma_inline
function arma_inline (line 38) | arma_inline
function arma_inline (line 49) | arma_inline
function arma_inline (line 60) | arma_inline
function arma_inline (line 71) | arma_inline
function arma_inline (line 82) | arma_inline
function arma_inline (line 93) | arma_inline
function arma_inline (line 104) | arma_inline
function arma_inline (line 115) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/constants.hpp
type priv (line 13) | namespace priv
class Datum_helper (line 15) | class Datum_helper
method nan (line 20) | static
method nan (line 38) | static
method nan (line 51) | static
method inf (line 62) | static
method inf (line 80) | static
method inf (line 93) | static
function arma_inline (line 220) | static
function arma_inline (line 240) | static
function arma_inline (line 253) | static
function arma_inline (line 273) | static
class Datum (line 115) | class Datum
type priv (line 216) | namespace priv
class Datum_helper (line 15) | class Datum_helper
method nan (line 20) | static
method nan (line 38) | static
method nan (line 51) | static
method inf (line 62) | static
method inf (line 80) | static
method inf (line 93) | static
function arma_inline (line 220) | static
function arma_inline (line 240) | static
function arma_inline (line 253) | static
function arma_inline (line 273) | static
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/constants_compat.hpp
class Math (line 18) | class Math
method eT (line 26) | static eT pi() { return eT(3.1415926535897932384626433832795028...
method eT (line 29) | static eT e() { return eT(2.7182818284590452353602874713526624...
method eT (line 32) | static eT euler() { return eT(0.5772156649015328606065120900824024...
method eT (line 35) | static eT gratio() { return eT(1.6180339887498948482045868343656381...
method eT (line 38) | static eT sqrt2() { return eT(1.4142135623730950488016887242096980...
method eT (line 41) | static eT eps() { return std::numeric_limits<eT>::epsilon(); }
method eT (line 44) | static eT log_min() { static const eT out = std::log(std::numeric_li...
method eT (line 47) | static eT log_max() { static const eT out = std::log(std::numeric_li...
method eT (line 50) | static eT nan() { return priv::Datum_helper::nan<eT>(); }
method eT (line 53) | static eT inf() { return priv::Datum_helper::inf<eT>(); }
class Phy (line 63) | class Phy
method eT (line 68) | static eT m_u() { return eT(1.660539040e-27); }
method eT (line 71) | static eT N_A() { return eT(6.022140857e23); }
method eT (line 74) | static eT k() { return eT(1.38064852e-23); }
method eT (line 77) | static eT k_evk() { return eT(8.6173303e-5); }
method eT (line 80) | static eT a_0() { return eT(0.52917721067e-10); }
method eT (line 83) | static eT mu_B() { return eT(927.4009994e-26); }
method eT (line 86) | static eT Z_0() { return eT(3.76730313461771e-2); }
method eT (line 89) | static eT G_0() { return eT(7.7480917310e-5); }
method eT (line 92) | static eT k_e() { return eT(8.9875517873681764e9); }
method eT (line 95) | static eT eps_0() { return eT(8.85418781762039e-12); }
method eT (line 98) | static eT m_e() { return eT(9.10938356e-31); }
method eT (line 101) | static eT eV() { return eT(1.6021766208e-19); }
method eT (line 104) | static eT e() { return eT(1.6021766208e-19); }
method eT (line 107) | static eT F() { return eT(96485.33289); }
method eT (line 110) | static eT alpha() { return eT(7.2973525664e-3); }
method eT (line 113) | static eT alpha_inv() { return eT(137.035999139); }
method eT (line 116) | static eT K_J() { return eT(483597.8525e9); }
method eT (line 119) | static eT mu_0() { return eT(1.25663706143592e-06); }
method eT (line 122) | static eT phi_0() { return eT(2.067833667e-15); }
method eT (line 125) | static eT R() { return eT(8.3144598); }
method eT (line 128) | static eT G() { return eT(6.67408e-11); }
method eT (line 131) | static eT h() { return eT(6.626070040e-34); }
method eT (line 134) | static eT h_bar() { return eT(1.054571800e-34); }
method eT (line 137) | static eT m_p() { return eT(1.672621898e-27); }
method eT (line 140) | static eT R_inf() { return eT(10973731.568508); }
method eT (line 143) | static eT c_0() { return eT(299792458.0); }
method eT (line 146) | static eT sigma() { return eT(5.670367e-8); }
method eT (line 149) | static eT R_k() { return eT(25812.8074555); }
method eT (line 152) | static eT b() { return eT(2.8977729e-3); }
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/debug.hpp
function set_stream_err1 (line 49) | inline
function set_stream_err2 (line 58) | inline
function arma_cold (line 90) | arma_cold
function arma_cold (line 117) | arma_cold
function arma_cold (line 148) | arma_cold
function arma_cold (line 181) | arma_cold
function arma_cold (line 191) | arma_cold
function arma_cold (line 203) | arma_cold
function arma_cold (line 215) | arma_cold
function arma_sigprint (line 236) | inline
function arma_bktprint (line 249) | inline
function arma_bktprint (line 258) | inline
function arma_bktprint (line 268) | inline
function arma_thisprint (line 283) | inline
function arma_cold (line 298) | arma_cold
function arma_cold (line 312) | arma_cold
function arma_cold (line 326) | arma_cold
function arma_hot (line 345) | arma_hot
function arma_hot (line 358) | arma_hot
function arma_hot (line 371) | arma_hot
function arma_hot (line 388) | arma_hot
function arma_cold (line 406) | arma_cold
function arma_cold (line 421) | arma_cold
function arma_cold (line 437) | arma_cold
function arma_inline (line 465) | arma_inline
function arma_hot (line 480) | arma_hot
function arma_hot (line 501) | arma_hot
function arma_hot (line 521) | arma_hot
function arma_hot (line 541) | arma_hot
function arma_hot (line 561) | arma_hot
function arma_hot (line 581) | arma_hot
function arma_hot (line 601) | arma_hot
function arma_hot (line 621) | arma_hot
function arma_hot (line 641) | arma_hot
function arma_hot (line 666) | arma_hot
function arma_hot (line 690) | arma_hot
function arma_hot (line 705) | arma_hot
function arma_hot (line 719) | arma_hot
function arma_hot (line 733) | arma_hot
function arma_hot (line 747) | arma_hot
function arma_hot (line 762) | arma_hot
function arma_hot (line 789) | arma_hot
function arma_hot (line 803) | arma_hot
function arma_hot (line 817) | arma_hot
function arma_hot (line 831) | arma_hot
function arma_assert_cube_as_mat (line 845) | inline
function arma_hot (line 999) | arma_hot
function arma_hot (line 1014) | arma_hot
function arma_hot (line 1032) | arma_hot
function arma_hot (line 1052) | arma_hot
function arma_hot (line 1072) | arma_hot
function arma_hot (line 1086) | arma_hot
function arma_hot (line 1100) | arma_hot
function arma_hot (line 1114) | arma_hot
function arma_hot (line 1136) | arma_hot
function arma_hot (line 1160) | arma_hot
function arma_hot (line 1182) | arma_hot
type junk (line 1269) | namespace junk
class arma_first_extra_debug_message (line 1271) | class arma_first_extra_debug_message
method arma_first_extra_debug_message (line 1275) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/diagmat_proxy.hpp
class diagmat_proxy_default (line 15) | class diagmat_proxy_default
method diagmat_proxy_default (line 22) | inline
method arma_inline (line 39) | arma_inline
method arma_inline (line 61) | arma_inline
method arma_inline (line 90) | arma_inline bool is_alias(const Mat<elem_type>&) const { return false; }
class diagmat_proxy_fixed (line 101) | class diagmat_proxy_fixed
method diagmat_proxy_fixed (line 108) | inline
method arma_inline (line 122) | arma_inline
method arma_inline (line 130) | arma_inline
method arma_inline (line 144) | arma_inline bool is_alias(const Mat<elem_type>& X) const { return (voi...
type diagmat_proxy_redirect (line 155) | struct diagmat_proxy_redirect {}
type diagmat_proxy_redirect<T1, false> (line 158) | struct diagmat_proxy_redirect<T1, false> { typedef diagmat_proxy_default...
type diagmat_proxy_redirect<T1, true> (line 161) | struct diagmat_proxy_redirect<T1, true> { typedef diagmat_proxy_fixed<T...
class diagmat_proxy (line 165) | class diagmat_proxy : public diagmat_proxy_redirect<T1, is_Mat_fixed<T1>...
method diagmat_proxy (line 168) | inline diagmat_proxy(const T1& X)
class diagmat_proxy< Mat<eT> > (line 177) | class diagmat_proxy< Mat<eT> >
method diagmat_proxy (line 184) | inline
method arma_inline (line 199) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 200) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 202) | arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&...
class diagmat_proxy< Row<eT> > (line 212) | class diagmat_proxy< Row<eT> >
method diagmat_proxy (line 220) | inline
method arma_inline (line 228) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 229) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 231) | arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&...
class diagmat_proxy< Col<eT> > (line 242) | class diagmat_proxy< Col<eT> >
method diagmat_proxy (line 250) | inline
method arma_inline (line 258) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 259) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 261) | arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&...
class diagmat_proxy< subview_row<eT> > (line 272) | class diagmat_proxy< subview_row<eT> >
method diagmat_proxy (line 280) | inline
method arma_inline (line 288) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 289) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 291) | arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&...
class diagmat_proxy< subview_col<eT> > (line 302) | class diagmat_proxy< subview_col<eT> >
method diagmat_proxy (line 310) | inline
method arma_inline (line 318) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 319) | arma_inline elem_type at (const uword row, const uword col) co...
method arma_inline (line 321) | arma_inline bool is_alias(const Mat<eT>& X) const { return (void_ptr(&...
class diagmat_proxy_check_default (line 338) | class diagmat_proxy_check_default
method diagmat_proxy_check_default (line 345) | inline
method arma_inline (line 360) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 361) | arma_inline elem_type at (const uword row, const uword col) co...
class diagmat_proxy_check_fixed (line 371) | class diagmat_proxy_check_fixed
method diagmat_proxy_check_fixed (line 379) | inline
method arma_inline (line 393) | arma_inline eT operator[] (const uword i) const { r...
method arma_inline (line 394) | arma_inline eT at (const uword row, const uword col) const { r...
type diagmat_proxy_check_redirect (line 405) | struct diagmat_proxy_check_redirect {}
type diagmat_proxy_check_redirect<T1, false> (line 408) | struct diagmat_proxy_check_redirect<T1, false> { typedef diagmat_proxy_c...
type diagmat_proxy_check_redirect<T1, true> (line 411) | struct diagmat_proxy_check_redirect<T1, true> { typedef diagmat_proxy_c...
class diagmat_proxy_check (line 415) | class diagmat_proxy_check : public diagmat_proxy_check_redirect<T1, is_M...
method diagmat_proxy_check (line 418) | inline diagmat_proxy_check(const T1& X, const Mat<typename T1::elem_ty...
class diagmat_proxy_check< Mat<eT> > (line 427) | class diagmat_proxy_check< Mat<eT> >
method diagmat_proxy_check (line 435) | inline
method arma_inline (line 456) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 457) | arma_inline elem_type at (const uword row, const uword col) co...
class diagmat_proxy_check< Row<eT> > (line 468) | class diagmat_proxy_check< Row<eT> >
method diagmat_proxy_check (line 475) | inline
method arma_inline (line 489) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 490) | arma_inline elem_type at (const uword row, const uword col) co...
class diagmat_proxy_check< Col<eT> > (line 502) | class diagmat_proxy_check< Col<eT> >
method diagmat_proxy_check (line 509) | inline
method arma_inline (line 523) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 524) | arma_inline elem_type at (const uword row, const uword col) co...
class diagmat_proxy_check< subview_row<eT> > (line 536) | class diagmat_proxy_check< subview_row<eT> >
method diagmat_proxy_check (line 543) | inline
method arma_inline (line 551) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 552) | arma_inline elem_type at (const uword row, const uword col) co...
class diagmat_proxy_check< subview_col<eT> > (line 563) | class diagmat_proxy_check< subview_col<eT> >
method diagmat_proxy_check (line 570) | inline
method arma_inline (line 578) | arma_inline elem_type operator[] (const uword i) co...
method arma_inline (line 579) | arma_inline elem_type at (const uword row, const uword col) co...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/diagview_bones.hpp
class diagview (line 15) | class diagview : public Base<eT, diagview<eT> >
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/diagview_meat.hpp
function arma_inline (line 716) | arma_inline
function arma_inline (line 726) | arma_inline
function arma_inline (line 736) | arma_inline
function arma_inline (line 746) | arma_inline
function arma_inline (line 756) | arma_inline
function arma_inline (line 766) | arma_inline
function arma_inline (line 778) | arma_inline
function arma_inline (line 790) | arma_inline
function arma_inline (line 800) | arma_inline
function arma_inline (line 810) | arma_inline
function arma_inline (line 822) | arma_inline
function arma_inline (line 834) | arma_inline
function arma_inline (line 844) | arma_inline
function arma_inline (line 854) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/diskio_bones.hpp
class diskio (line 17) | class diskio
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/diskio_meat.hpp
function else (line 60) | else
function else (line 65) | else
function else (line 72) | else
function else (line 77) | else
function else (line 82) | else
function else (line 87) | else
function else (line 93) | else
function else (line 98) | else
function else (line 103) | else
function else (line 108) | else
function else (line 166) | else
function else (line 171) | else
function else (line 178) | else
function else (line 183) | else
function else (line 188) | else
function else (line 193) | else
function else (line 199) | else
function else (line 204) | else
function else (line 209) | else
function else (line 214) | else
function else (line 272) | else
function else (line 277) | else
function else (line 284) | else
function else (line 289) | else
function else (line 294) | else
function else (line 299) | else
function else (line 305) | else
function else (line 310) | else
function else (line 315) | else
function else (line 320) | else
function else (line 377) | else
function else (line 382) | else
function else (line 389) | else
function else (line 394) | else
function else (line 399) | else
function else (line 404) | else
function else (line 410) | else
function else (line 415) | else
function else (line 420) | else
function else (line 425) | else
function else (line 483) | else
function else (line 488) | else
function else (line 495) | else
function else (line 500) | else
function else (line 505) | else
function else (line 510) | else
function else (line 516) | else
function else (line 521) | else
function else (line 526) | else
function else (line 531) | else
function file_type (line 545) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/distr_param.hpp
class distr_param (line 15) | class distr_param
method distr_param (line 34) | inline distr_param()
method distr_param (line 40) | inline explicit distr_param(const int a, const int b)
method distr_param (line 48) | inline explicit distr_param(const double a, const double b)
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eGlueCube_bones.hpp
class eGlueCube (line 14) | class eGlueCube : public BaseCube<typename T1::elem_type, eGlueCube<T1, ...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eGlueCube_meat.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 42) | arma_inline
function arma_inline (line 52) | arma_inline
function arma_inline (line 62) | arma_inline
function arma_inline (line 72) | arma_inline
function arma_inline (line 82) | arma_inline
function arma_inline (line 92) | arma_inline
function arma_inline (line 109) | arma_inline
function arma_inline (line 127) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eGlue_bones.hpp
class eGlue (line 14) | class eGlue : public Base<typename T1::elem_type, eGlue<T1, T2, eglue_ty...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eGlue_meat.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 43) | arma_inline
function arma_inline (line 53) | arma_inline
function arma_inline (line 63) | arma_inline
function arma_inline (line 73) | arma_inline
function arma_inline (line 91) | arma_inline
function arma_inline (line 109) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eOpCube_bones.hpp
class eOpCube (line 15) | class eOpCube : public BaseCube<typename T1::elem_type, eOpCube<T1, eop_...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eOpCube_meat.hpp
function arma_inline (line 78) | arma_inline
function arma_inline (line 88) | arma_inline
function arma_inline (line 98) | arma_inline
function arma_inline (line 108) | arma_inline
function arma_inline (line 118) | arma_inline
function arma_inline (line 128) | arma_inline
function arma_inline (line 138) | arma_inline
function arma_inline (line 148) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eOp_bones.hpp
class eOp (line 15) | class eOp : public Base<typename T1::elem_type, eOp<T1, eop_type> >
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eOp_meat.hpp
function arma_inline (line 65) | arma_inline
function arma_inline (line 75) | arma_inline
function arma_inline (line 85) | arma_inline
function arma_inline (line 95) | arma_inline
function arma_inline (line 105) | arma_inline
function arma_inline (line 127) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eglue_core_bones.hpp
type eglue_core (line 15) | struct eglue_core
class eglue_plus (line 40) | class eglue_plus : public eglue_core<eglue_plus>
class eglue_minus (line 49) | class eglue_minus : public eglue_core<eglue_minus>
class eglue_div (line 58) | class eglue_div : public eglue_core<eglue_div>
class eglue_schur (line 67) | class eglue_schur : public eglue_core<eglue_schur>
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eglue_core_meat.hpp
function arma_hot (line 175) | arma_hot
function arma_hot (line 251) | arma_hot
function arma_hot (line 325) | arma_hot
function arma_hot (line 399) | arma_hot
function arma_hot (line 473) | arma_hot
function arma_hot (line 552) | arma_hot
function arma_hot (line 629) | arma_hot
function arma_hot (line 704) | arma_hot
function arma_hot (line 779) | arma_hot
function arma_hot (line 854) | arma_hot
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eop_aux.hpp
class eop_aux (line 17) | class eop_aux
method arma_inline (line 21) | arma_inline static typename arma_integral_only<eT>::result acos (c...
method arma_inline (line 22) | arma_inline static typename arma_integral_only<eT>::result asin (c...
method arma_inline (line 23) | arma_inline static typename arma_integral_only<eT>::result atan (c...
method arma_inline (line 25) | arma_inline static typename arma_real_only<eT>::result acos (c...
method arma_inline (line 26) | arma_inline static typename arma_real_only<eT>::result asin (c...
method arma_inline (line 27) | arma_inline static typename arma_real_only<eT>::result atan (c...
method arma_inline (line 29) | arma_inline static typename arma_cx_only<eT>::result acos (c...
method arma_inline (line 30) | arma_inline static typename arma_cx_only<eT>::result asin (c...
method arma_inline (line 31) | arma_inline static typename arma_cx_only<eT>::result atan (c...
method arma_inline (line 33) | arma_inline static typename arma_integral_only<eT>::result acosh (c...
method arma_inline (line 34) | arma_inline static typename arma_integral_only<eT>::result asinh (c...
method arma_inline (line 35) | arma_inline static typename arma_integral_only<eT>::result atanh (c...
method arma_inline (line 37) | arma_inline static typename arma_real_or_cx_only<eT>::result acosh (co...
method arma_inline (line 38) | arma_inline static typename arma_real_or_cx_only<eT>::result asinh (co...
method arma_inline (line 39) | arma_inline static typename arma_real_or_cx_only<eT>::result atanh (co...
method arma_inline (line 41) | arma_inline static typename arma_not_cx<eT>::result conj(const eT ...
method arma_inline (line 42) | arma_inline static std::complex<T> conj(const std::co...
method arma_inline (line 44) | arma_inline static typename arma_integral_only<eT>::result sqrt (cons...
method arma_inline (line 45) | arma_inline static typename arma_integral_only<eT>::result log10 (cons...
method arma_inline (line 46) | arma_inline static typename arma_integral_only<eT>::result log (cons...
method arma_inline (line 47) | arma_inline static typename arma_integral_only<eT>::result exp (cons...
method arma_inline (line 48) | arma_inline static typename arma_integral_only<eT>::result cos (cons...
method arma_inline (line 49) | arma_inline static typename arma_integral_only<eT>::result sin (cons...
method arma_inline (line 50) | arma_inline static typename arma_integral_only<eT>::result tan (cons...
method arma_inline (line 51) | arma_inline static typename arma_integral_only<eT>::result cosh (cons...
method arma_inline (line 52) | arma_inline static typename arma_integral_only<eT>::result sinh (cons...
method arma_inline (line 53) | arma_inline static typename arma_integral_only<eT>::result tanh (cons...
method arma_inline (line 55) | arma_inline static typename arma_real_or_cx_only<eT>::result sqrt (co...
method arma_inline (line 56) | arma_inline static typename arma_real_or_cx_only<eT>::result log10 (co...
method arma_inline (line 57) | arma_inline static typename arma_real_or_cx_only<eT>::result log (co...
method arma_inline (line 58) | arma_inline static typename arma_real_or_cx_only<eT>::result exp (co...
method arma_inline (line 59) | arma_inline static typename arma_real_or_cx_only<eT>::result cos (co...
method arma_inline (line 60) | arma_inline static typename arma_real_or_cx_only<eT>::result sin (co...
method arma_inline (line 61) | arma_inline static typename arma_real_or_cx_only<eT>::result tan (co...
method arma_inline (line 62) | arma_inline static typename arma_real_or_cx_only<eT>::result cosh (co...
method arma_inline (line 63) | arma_inline static typename arma_real_or_cx_only<eT>::result sinh (co...
method arma_inline (line 64) | arma_inline static typename arma_real_or_cx_only<eT>::result tanh (co...
method arma_inline (line 66) | arma_inline static typename arma_unsigned_integral_only<eT>::result ne...
method arma_inline (line 67) | arma_inline static typename arma_signed_only<eT>::result ne...
method arma_inline (line 69) | arma_inline static typename arma_integral_only<eT>::result floor (cons...
method arma_inline (line 70) | arma_inline static typename arma_real_only<eT>::result floor (cons...
method arma_inline (line 71) | arma_inline static typename arma_cx_only<eT>::result floor (cons...
method arma_inline (line 73) | arma_inline static typename arma_integral_only<eT>::result ceil (cons...
method arma_inline (line 74) | arma_inline static typename arma_real_only<eT>::result ceil (cons...
method arma_inline (line 75) | arma_inline static typename arma_cx_only<eT>::result ceil (cons...
method arma_inline (line 79) | arma_inline static typename arma_integral_only<eT>::result round (cons...
method arma_inline (line 80) | arma_inline static typename arma_real_only<eT>::result round (cons...
method arma_inline (line 81) | arma_inline static typename arma_cx_only<eT>::result round (cons...
method arma_inline (line 83) | arma_inline static typename arma_integral_only<eT>::result round (cons...
method arma_inline (line 84) | arma_inline static typename arma_real_only<eT>::result round (cons...
method arma_inline (line 85) | arma_inline static typename arma_cx_only<eT>::result round (cons...
method arma_inline (line 90) | arma_inline static typename arma_integral_only<eT>::result log2 (con...
method arma_inline (line 91) | arma_inline static typename arma_real_only<eT>::result log2 (con...
method arma_inline (line 92) | arma_inline static typename arma_cx_only<eT>::result log2 (con...
method arma_inline (line 94) | arma_inline static typename arma_integral_only<eT>::result log2 (con...
method arma_inline (line 95) | arma_inline static typename arma_real_or_cx_only<eT>::result log2 (con...
method arma_inline (line 100) | arma_inline static typename arma_integral_only<eT>::result exp2 (con...
method arma_inline (line 101) | arma_inline static typename arma_real_only<eT>::result exp2 (con...
method arma_inline (line 102) | arma_inline static typename arma_cx_only<eT>::result exp2 (con...
method arma_inline (line 104) | arma_inline static typename arma_integral_only<eT>::result exp2 (con...
method arma_inline (line 105) | arma_inline static typename arma_real_or_cx_only<eT>::result exp2 (con...
method arma_inline (line 109) | arma_inline static typename arma_integral_only<eT>::result exp10 (co...
method arma_inline (line 110) | arma_inline static typename arma_real_or_cx_only<eT>::result exp10 (co...
method arma_inline (line 112) | arma_inline static typename arma_unsigned_integral_only<eT>::result ar...
method arma_inline (line 113) | arma_inline static typename arma_signed_integral_only<eT>::result ar...
method arma_inline (line 114) | arma_inline static typename arma_real_only<eT>::result ar...
method arma_inline (line 115) | arma_inline static typename arma_real_only< T>::result ar...
method arma_inline (line 117) | arma_inline static typename arma_unsigned_integral_only<eT>::result si...
method arma_inline (line 118) | arma_inline static typename arma_signed_integral_only<eT>::result si...
method arma_inline (line 119) | arma_inline static typename arma_real_only<eT>::result si...
method arma_inline (line 120) | arma_inline static typename arma_cx_only<eT>::result si...
method arma_inline (line 123) | arma_inline static typename arma_integral_only<T1>::result pow (cons...
method arma_inline (line 124) | arma_inline static typename arma_real_or_cx_only<T1>::result pow (cons...
method arma_inline (line 128) | arma_inline
method direct_eps (line 139) | inline
method direct_eps (line 162) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eop_core_bones.hpp
class eop_core (line 15) | class eop_core
class eop_neg (line 46) | class eop_neg : public eop_core<eop_neg> {}
class eop_scalar_plus (line 47) | class eop_scalar_plus : public eop_core<eop_scalar_plus> {}
class eop_scalar_minus_pre (line 48) | class eop_scalar_minus_pre : public eop_core<eop_scalar_minus_pre> {}
class eop_scalar_minus_post (line 49) | class eop_scalar_minus_post : public eop_core<eop_scalar_minus_post> {}
class eop_scalar_times (line 50) | class eop_scalar_times : public eop_core<eop_scalar_times> {}
class eop_scalar_div_pre (line 51) | class eop_scalar_div_pre : public eop_core<eop_scalar_div_pre> {}
class eop_scalar_div_post (line 52) | class eop_scalar_div_post : public eop_core<eop_scalar_div_post> {}
class eop_square (line 53) | class eop_square : public eop_core<eop_square> {}
class eop_sqrt (line 54) | class eop_sqrt : public eop_core<eop_sqrt> {}
class eop_log (line 55) | class eop_log : public eop_core<eop_log> {}
class eop_log2 (line 56) | class eop_log2 : public eop_core<eop_log2> {}
class eop_log10 (line 57) | class eop_log10 : public eop_core<eop_log10> {}
class eop_trunc_log (line 58) | class eop_trunc_log : public eop_core<eop_trunc_log> {}
class eop_exp (line 59) | class eop_exp : public eop_core<eop_exp> {}
class eop_exp2 (line 60) | class eop_exp2 : public eop_core<eop_exp2> {}
class eop_exp10 (line 61) | class eop_exp10 : public eop_core<eop_exp10> {}
class eop_trunc_exp (line 62) | class eop_trunc_exp : public eop_core<eop_trunc_exp> {}
class eop_cos (line 63) | class eop_cos : public eop_core<eop_cos> {}
class eop_sin (line 64) | class eop_sin : public eop_core<eop_sin> {}
class eop_tan (line 65) | class eop_tan : public eop_core<eop_tan> {}
class eop_acos (line 66) | class eop_acos : public eop_core<eop_acos> {}
class eop_asin (line 67) | class eop_asin : public eop_core<eop_asin> {}
class eop_atan (line 68) | class eop_atan : public eop_core<eop_atan> {}
class eop_cosh (line 69) | class eop_cosh : public eop_core<eop_cosh> {}
class eop_sinh (line 70) | class eop_sinh : public eop_core<eop_sinh> {}
class eop_tanh (line 71) | class eop_tanh : public eop_core<eop_tanh> {}
class eop_acosh (line 72) | class eop_acosh : public eop_core<eop_acosh> {}
class eop_asinh (line 73) | class eop_asinh : public eop_core<eop_asinh> {}
class eop_atanh (line 74) | class eop_atanh : public eop_core<eop_atanh> {}
class eop_eps (line 75) | class eop_eps : public eop_core<eop_eps> {}
class eop_abs (line 76) | class eop_abs : public eop_core<eop_abs> {}
class eop_conj (line 77) | class eop_conj : public eop_core<eop_conj> {}
class eop_pow (line 78) | class eop_pow : public eop_core<eop_pow> {}
class eop_floor (line 79) | class eop_floor : public eop_core<eop_floor> {}
class eop_ceil (line 80) | class eop_ceil : public eop_core<eop_ceil> {}
class eop_round (line 81) | class eop_round : public eop_core<eop_round> {}
class eop_sign (line 82) | class eop_sign : public eop_core<eop_sign> {}
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/eop_core_meat.hpp
function arma_hot (line 160) | arma_hot
function arma_hot (line 218) | arma_hot
function arma_hot (line 275) | arma_hot
function arma_hot (line 332) | arma_hot
function arma_hot (line 389) | arma_hot
function arma_hot (line 451) | arma_hot
function arma_hot (line 510) | arma_hot
function arma_hot (line 568) | arma_hot
function arma_hot (line 626) | arma_hot
function arma_hot (line 684) | arma_hot
function arma_hot (line 747) | arma_hot
function arma_hot (line 759) | arma_hot arma_const arma_inline eT
function arma_hot (line 762) | arma_hot arma_const arma_inline eT
function arma_hot (line 765) | arma_hot arma_const arma_inline eT
function arma_hot (line 768) | arma_hot arma_const arma_inline eT
function arma_hot (line 771) | arma_hot arma_const arma_inline eT
function arma_hot (line 774) | arma_hot arma_const arma_inline eT
function arma_hot (line 777) | arma_hot arma_const arma_inline eT
function arma_hot (line 780) | arma_hot arma_const arma_inline eT
function arma_hot (line 783) | arma_hot arma_pure arma_inline eT
function arma_hot (line 786) | arma_hot arma_pure arma_inline eT
function arma_hot (line 789) | arma_hot arma_pure arma_inline eT
function arma_hot (line 792) | arma_hot arma_pure arma_inline eT
function arma_hot (line 795) | arma_hot arma_pure arma_inline eT
function arma_hot (line 798) | arma_hot arma_pure arma_inline eT
function arma_hot (line 801) | arma_hot arma_pure arma_inline eT
function arma_hot (line 804) | arma_hot arma_pure arma_inline eT
function arma_hot (line 807) | arma_hot arma_pure arma_inline eT
function arma_hot (line 810) | arma_hot arma_pure arma_inline eT
function arma_hot (line 813) | arma_hot arma_pure arma_inline eT
function arma_hot (line 816) | arma_hot arma_pure arma_inline eT
function arma_hot (line 819) | arma_hot arma_pure arma_inline eT
function arma_hot (line 822) | arma_hot arma_pure arma_inline eT
function arma_hot (line 825) | arma_hot arma_pure arma_inline eT
function arma_hot (line 828) | arma_hot arma_pure arma_inline eT
function arma_hot (line 831) | arma_hot arma_pure arma_inline eT
function arma_hot (line 834) | arma_hot arma_pure arma_inline eT
function arma_hot (line 837) | arma_hot arma_pure arma_inline eT
function arma_hot (line 840) | arma_hot arma_pure arma_inline eT
function arma_hot (line 843) | arma_hot arma_pure arma_inline eT
function arma_hot (line 846) | arma_hot arma_pure arma_inline eT
function arma_hot (line 849) | arma_hot arma_pure arma_inline eT
function arma_hot (line 852) | arma_hot arma_pure arma_inline eT
function arma_hot (line 855) | arma_hot arma_pure arma_inline eT
function arma_hot (line 858) | arma_hot arma_pure arma_inline eT
function arma_hot (line 861) | arma_hot arma_pure arma_inline eT
function arma_hot (line 864) | arma_hot arma_pure arma_inline eT
function arma_hot (line 867) | arma_hot arma_pure arma_inline eT
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fft_engine.hpp
type store (line 46) | struct store {}
type store<cx_type, fixed_N, true> (line 49) | struct store<cx_type, fixed_N, true>
method store (line 55) | inline store() {}
method store (line 56) | inline store(uword) {}
method arma_inline (line 58) | arma_inline cx_type* coeffs_ptr() { return &coeffs_array[0...
method arma_inline (line 59) | arma_inline const cx_type* coeffs_ptr() const { return &coeffs_array[0...
type store<cx_type, fixed_N, false> (line 65) | struct store<cx_type, fixed_N, false>
method store (line 71) | inline store() : N(0) {}
method store (line 72) | inline store(uword in_N) : N(in_N) { coeffs_array.set_size(N); }
method arma_inline (line 74) | arma_inline cx_type* coeffs_ptr() { return coeffs_array.me...
method arma_inline (line 75) | arma_inline const cx_type* coeffs_ptr() const { return coeffs_array.me...
class fft_engine (line 81) | class fft_engine : public store<cx_type, fixed_N, (fixed_N > 0)>
method uword (line 97) | inline
method fft_engine (line 131) | inline
method arma_hot (line 156) | arma_hot
method arma_hot (line 176) | arma_hot
method arma_hot (line 222) | arma_hot
method arma_hot (line 265) | inline
method arma_hot (line 329) | arma_hot
method run (line 375) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/field_bones.hpp
type field_prealloc_n_elem (line 15) | struct field_prealloc_n_elem
class field (line 26) | class field
class iterator (line 187) | class iterator
class const_iterator (line 209) | class const_iterator
class field_aux (line 266) | class field_aux
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/field_meat.hpp
function arma_inline (line 220) | arma_inline
function arma_inline (line 231) | arma_inline
function arma_inline (line 242) | arma_inline
function arma_inline (line 253) | arma_inline
function arma_inline (line 264) | arma_inline
function arma_inline (line 276) | arma_inline
function arma_inline (line 288) | arma_inline
function arma_inline (line 300) | arma_inline
function arma_inline (line 312) | arma_inline
function arma_inline (line 324) | arma_inline
function arma_inline (line 336) | arma_inline
function arma_inline (line 347) | arma_inline
function arma_inline (line 358) | arma_inline
function arma_inline (line 369) | arma_inline
function arma_inline (line 1198) | arma_inline
function arma_inline (line 1209) | arma_inline
function arma_inline (line 1221) | arma_inline
function arma_inline (line 1245) | arma_inline
function arma_inline (line 1256) | arma_inline
function arma_inline (line 1279) | arma_inline
function arma_inline (line 1302) | arma_inline
function arma_inline (line 1324) | arma_inline
function arma_inline (line 1345) | arma_inline
function arma_inline (line 1356) | arma_inline
function arma_inline (line 1382) | arma_inline
function oT (line 1743) | inline
function oT (line 1842) | inline
function uword (line 2011) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_accu.hpp
function arma_hot (line 16) | arma_hot
function arma_hot (line 71) | arma_hot
function arma_hot (line 84) | arma_hot
function arma_hot (line 133) | arma_hot
function arma_warn_unused (line 151) | inline
function arma_warn_unused (line 206) | inline
function eT (line 265) | inline
function eT (line 308) | inline
function accu (line 324) | typename T1::elem_type
function arma_hot (line 409) | arma_hot
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_all.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 35) | arma_inline
function arma_warn_unused (line 53) | inline
function arma_warn_unused (line 73) | inline
function arma_inline (line 87) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_any.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 35) | arma_inline
function arma_warn_unused (line 53) | inline
function arma_warn_unused (line 73) | inline
function arma_inline (line 87) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_as_scalar.hpp
type as_scalar_redirect (line 15) | struct as_scalar_redirect
type as_scalar_redirect<2> (line 24) | struct as_scalar_redirect<2>
type as_scalar_redirect<3> (line 32) | struct as_scalar_redirect<3>
function as_scalar_diag (line 217) | inline
function as_scalar_diag (line 241) | inline
function arma_inline (line 302) | arma_inline
function arma_warn_unused (line 327) | inline
function arma_warn_unused (line 356) | inline
function arma_warn_unused (line 373) | inline
function arma_warn_unused (line 396) | inline
function arma_warn_unused (line 431) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_chol.hpp
function chol (line 15) | inline
function chol (line 37) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_clamp.hpp
function clamp (line 15) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cond.hpp
function arma_warn_unused (line 14) | arma_warn_unused
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_conv.hpp
function conv (line 17) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_conv_to.hpp
class conv_to (line 17) | class conv_to
function out_eT (line 38) | inline
function out_eT (line 58) | inline
function out_eT (line 82) | inline
function out_eT (line 102) | inline
class conv_to< Mat<out_eT> > (line 126) | class conv_to< Mat<out_eT> >
class conv_to< Row<out_eT> > (line 253) | class conv_to< Row<out_eT> >
class conv_to< Col<out_eT> > (line 368) | class conv_to< Col<out_eT> >
class conv_to< SpMat<out_eT> > (line 482) | class conv_to< SpMat<out_eT> >
class conv_to< Cube<out_eT> > (line 507) | class conv_to< Cube<out_eT> >
class conv_to< std::vector<out_eT> > (line 564) | class conv_to< std::vector<out_eT> >
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cor.hpp
function cor (line 16) | inline
function cor (line 30) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cov.hpp
function cov (line 16) | inline
function cov (line 30) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cross.hpp
function cross (line 16) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cumsum.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 35) | arma_inline
function arma_inline (line 53) | arma_inline
function arma_inline (line 72) | arma_inline
function arma_inline (line 90) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_det.hpp
function arma_warn_unused (line 16) | inline
function arma_warn_unused (line 35) | inline
function arma_warn_unused (line 61) | inline
function arma_warn_unused (line 101) | inline
function arma_warn_unused (line 123) | inline
function arma_warn_unused (line 164) | inline
function arma_warn_unused (line 186) | inline
function arma_warn_unused (line 211) | inline
function arma_warn_unused (line 237) | inline
function arma_warn_unused (line 258) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_diagmat.hpp
function arma_inline (line 15) | arma_inline
function diagmat (line 32) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_diagvec.hpp
function arma_inline (line 15) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_dot.hpp
function arma_inline (line 15) | arma_inline
function arma_warn_unused (line 37) | inline
function arma_warn_unused (line 59) | inline
function arma_inline (line 86) | arma_inline
function arma_inline (line 109) | arma_inline
function arma_inline (line 133) | arma_inline
type priv (line 160) | namespace priv
function arma_hot (line 164) | arma_hot
function dot (line 213) | typename
function dot (line 270) | typename
function dot (line 312) | typename
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eig_gen.hpp
function eig_gen (line 17) | inline
function eig_gen (line 50) | inline
function eig_gen (line 83) | inline
function eig_gen (line 113) | inline
function eig_gen (line 145) | inline
function eig_gen (line 235) | inline
function arma_deprecated (line 287) | arma_deprecated
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eig_pair.hpp
function eig_pair (line 15) | inline
function eig_pair (line 49) | inline
function eig_pair (line 83) | inline
function eig_pair (line 114) | inline
function eig_pair (line 145) | inline
function eig_pair (line 219) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eig_sym.hpp
function eig_sym (line 16) | inline
function eig_sym (line 46) | inline
function eig_sym (line 73) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eigs_gen.hpp
function eigs_gen (line 16) | inline
function eigs_gen (line 50) | inline
function eigs_gen (line 84) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eigs_sym.hpp
function eigs_sym (line 16) | inline
function eigs_sym (line 48) | inline
function eigs_sym (line 80) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_elem.hpp
function arma_inline (line 17) | arma_inline
function arma_inline (line 29) | arma_inline
function arma_inline (line 41) | arma_inline
function real (line 53) | inline
function real (line 65) | inline
function arma_inline (line 77) | arma_inline
function imag (line 92) | inline
function imag (line 106) | inline
function imag (line 120) | inline
function imag (line 134) | inline
function imag (line 146) | inline
function arma_inline (line 158) | arma_inline
function arma_inline (line 173) | arma_inline
function arma_inline (line 185) | arma_inline
function arma_inline (line 200) | arma_inline
function arma_inline (line 212) | arma_inline
function arma_inline (line 227) | arma_inline
function arma_inline (line 239) | arma_inline
function arma_inline (line 254) | arma_inline
function arma_inline (line 266) | arma_inline
function arma_inline (line 280) | arma_inline
function arma_inline (line 292) | arma_inline
function arma_inline (line 306) | arma_inline
function arma_inline (line 318) | arma_inline
function arma_inline (line 334) | arma_inline
function arma_inline (line 346) | arma_inline
function abs (line 360) | inline
function abs (line 372) | inline
function arma_inline (line 386) | arma_inline
function arma_inline (line 399) | arma_inline
function arma_inline (line 415) | arma_inline
function arma_inline (line 427) | arma_inline
function arma_inline (line 439) | arma_inline
function arma_inline (line 454) | arma_inline
function arma_inline (line 466) | arma_inline
function arma_inline (line 478) | arma_inline
function arma_inline (line 493) | arma_inline
function arma_inline (line 505) | arma_inline
function arma_inline (line 517) | arma_inline
function arma_inline (line 529) | arma_inline
function arma_inline (line 541) | arma_inline
function arma_inline (line 553) | arma_inline
function arma_inline (line 567) | arma_inline
function arma_inline (line 579) | arma_inline
function arma_inline (line 593) | arma_inline
function arma_inline (line 607) | arma_inline
function arma_inline (line 624) | arma_inline
function arma_inline (line 636) | arma_inline
function arma_inline (line 651) | arma_inline
function arma_inline (line 663) | arma_inline
function arma_inline (line 678) | arma_inline
function arma_inline (line 690) | arma_inline
function arma_inline (line 705) | arma_inline
function arma_inline (line 717) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eps.hpp
function eps (line 19) | inline
function eps (line 34) | inline
function arma_inline (line 66) | arma_inline
function arma_inline (line 79) | arma_inline
function arma_inline (line 90) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_expmat.hpp
function expmat (line 11) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eye.hpp
function arma_inline (line 14) | arma_inline
function arma_inline (line 26) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_fft.hpp
function fft (line 19) | inline
function fft (line 36) | inline
function fft (line 53) | inline
function fft (line 70) | inline
function ifft (line 87) | inline
function ifft (line 104) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_fft2.hpp
function fft2 (line 19) | inline
function fft2 (line 47) | inline
function ifft2 (line 71) | inline
function ifft2 (line 99) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_find.hpp
function find (line 15) | inline
function find (line 32) | inline
function uvec (line 58) | inline
function uvec (line 76) | inline
function uvec (line 94) | inline
function uvec (line 112) | inline
function find_finite (line 139) | inline
function find_nonfinite (line 156) | inline
function uvec (line 177) | inline
function uvec (line 195) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_flip.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 27) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_hist.hpp
function hist (line 11) | inline
function hist (line 31) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_histc.hpp
function histc (line 11) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_inplace_strans.hpp
function inplace_strans (line 16) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_inplace_trans.hpp
function inplace_htrans (line 15) | inline
function inplace_htrans (line 36) | inline
function inplace_trans (line 72) | inline
function inplace_trans (line 97) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_interp1.hpp
function interp1_helper_nearest (line 15) | inline
function interp1_helper_linear (line 76) | inline
function interp1_helper (line 161) | inline
function interp1 (line 272) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_inv.hpp
function arma_inline (line 16) | arma_inline
function arma_inline (line 34) | arma_inline
function arma_inline (line 57) | arma_inline
function arma_inline (line 76) | arma_inline
function inv (line 98) | inline
function inv (line 126) | inline
function arma_inline (line 155) | arma_inline
function inv_sympd (line 177) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_join.hpp
function join_cols (line 15) | inline
function join_vert (line 27) | inline
function join_rows (line 39) | inline
function join_horiz (line 51) | inline
function join_slices (line 63) | inline
function join_cols (line 78) | inline
function join_vert (line 90) | inline
function join_rows (line 102) | inline
function join_horiz (line 114) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_kron.hpp
function arma_inline (line 19) | arma_inline
function kron (line 34) | inline
function kron (line 63) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_log_det.hpp
function log_det (line 16) | inline
function log_det (line 35) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_lu.hpp
function lu (line 16) | inline
function lu (line 47) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_max.hpp
function arma_inline (line 21) | arma_inline
function arma_inline (line 41) | arma_inline
function arma_warn_unused (line 59) | inline
function arma_warn_unused (line 82) | inline
function arma_inline (line 96) | arma_inline
function arma_inline (line 120) | arma_inline
function arma_warn_unused (line 141) | inline
function max (line 159) | inline
function arma_warn_unused (line 176) | inline
function max (line 190) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_mean.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 35) | arma_inline
function arma_warn_unused (line 53) | inline
function arma_warn_unused (line 76) | inline
function arma_inline (line 90) | arma_inline
function arma_warn_unused (line 113) | inline
function arma_warn_unused (line 135) | inline
function arma_warn_unused (line 154) | inline
function arma_warn_unused (line 175) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_median.hpp
function arma_inline (line 14) | arma_inline
function arma_inline (line 34) | arma_inline
function arma_warn_unused (line 52) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_min.hpp
function arma_inline (line 20) | arma_inline
function arma_inline (line 39) | arma_inline
function arma_warn_unused (line 57) | inline
function arma_warn_unused (line 80) | inline
function arma_inline (line 94) | arma_inline
function arma_inline (line 118) | arma_inline
function arma_warn_unused (line 139) | inline
function min (line 157) | inline
function arma_warn_unused (line 174) | inline
function min (line 188) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_misc.hpp
function linspace (line 19) | inline
function mat (line 85) | inline
function log_add_exp (line 99) | inline
function log_add (line 124) | inline
function arma_inline (line 134) | arma_inline
function arma_warn_unused (line 147) | inline
function arma_warn_unused (line 212) | inline
function arma_warn_unused (line 245) | inline
function arma_deprecated (line 264) | arma_deprecated
function swap (line 277) | inline
function swap (line 289) | inline
function arma_inline (line 301) | arma_inline
function orth (line 316) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_n_unique.hpp
function uword (line 19) | inline
function arma_hot (line 39) | arma_hot
type op_n_unique_add (line 100) | struct op_n_unique_add
method eT (line 102) | inline static eT eval(const eT& l, const eT& r) { return (l + r); }
type op_n_unique_sub (line 105) | struct op_n_unique_sub
method eT (line 107) | inline static eT eval(const eT& l, const eT& r) { return (l - r); }
type op_n_unique_mul (line 110) | struct op_n_unique_mul
method eT (line 112) | inline static eT eval(const eT& l, const eT& r) { return (l * r); }
type op_n_unique_count (line 115) | struct op_n_unique_count
method eT (line 117) | inline static eT eval(const eT&, const eT&) { return eT(1); }
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_nonzeros.hpp
function nonzeros (line 14) | inline
function nonzeros (line 26) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_norm.hpp
function arma_hot (line 15) | arma_hot
function arma_hot (line 97) | arma_hot
function arma_hot (line 209) | arma_hot
function arma_hot (line 277) | arma_hot
function arma_hot (line 353) | arma_hot
function arma_hot (line 465) | arma_hot
function arma_hot (line 572) | arma_hot
function arma_hot (line 634) | arma_hot
function arma_hot (line 700) | arma_hot
function arma_mat_norm_1 (line 766) | inline
function arma_mat_norm_2 (line 779) | inline
function arma_mat_norm_inf (line 798) | inline
function arma_warn_unused (line 811) | inline
function arma_warn_unused (line 878) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_norm_sparse.hpp
function arma_mat_norm_1 (line 18) | inline
function arma_mat_norm_2 (line 31) | inline
function arma_mat_norm_2 (line 59) | inline
function arma_mat_norm_inf (line 87) | inline
function arma_warn_unused (line 100) | inline
function arma_warn_unused (line 174) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_normalise.hpp
function normalise (line 15) | inline
function normalise (line 40) | inline
function normalise (line 65) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_numel.hpp
function numel (line 15) | inline
function numel (line 29) | inline
function numel (line 43) | inline
function uword (line 57) | inline
function uword (line 69) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_ones.hpp
function arma_inline (line 14) | arma_inline
function arma_inline (line 26) | arma_inline
function arma_inline (line 46) | arma_inline
function ones (line 58) | inline
function arma_inline (line 80) | arma_inline
function arma_inline (line 92) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_pinv.hpp
function pinv (line 16) | inline
function pinv (line 39) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_princomp.hpp
function princomp (line 22) | inline
function princomp (line 60) | inline
function princomp (line 95) | inline
function princomp (line 127) | inline
function princomp (line 154) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_prod.hpp
function arma_inline (line 22) | arma_inline
function arma_inline (line 42) | arma_inline
function arma_warn_unused (line 60) | inline
function arma_warn_unused (line 84) | inline
function prod (line 98) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_qr.hpp
function qr (line 16) | inline
function qr_econ (line 47) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_qz.hpp
function qz (line 17) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_randg.hpp
function obj_type (line 15) | inline
function obj_type (line 92) | inline
function mat (line 112) | inline
function vec (line 123) | inline
function cube_type (line 135) | inline
function cube (line 202) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_randi.hpp
function obj_type (line 15) | inline
function obj_type (line 66) | inline
function imat (line 86) | inline
function ivec (line 97) | inline
function cube_type (line 109) | inline
function icube (line 149) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_randn.hpp
function randn (line 13) | inline
function randn (line 22) | inline
function arma_inline (line 32) | arma_inline
function arma_inline (line 44) | arma_inline
function arma_inline (line 65) | arma_inline
function arma_inline (line 77) | arma_inline
function arma_inline (line 99) | arma_inline
function arma_inline (line 111) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_randu.hpp
function randu (line 13) | inline
function randu (line 22) | inline
function arma_inline (line 32) | arma_inline
function arma_inline (line 44) | arma_inline
function arma_inline (line 65) | arma_inline
function arma_inline (line 77) | arma_inline
function arma_inline (line 99) | arma_inline
function arma_inline (line 111) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_rank.hpp
function arma_warn_unused (line 17) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_repmat.hpp
function arma_inline (line 16) | arma_inline
function arma_inline (line 28) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_reshape.hpp
function reshape (line 15) | inline
function reshape (line 27) | inline
function reshape (line 41) | inline
function reshape (line 55) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_resize.hpp
function resize (line 15) | inline
function resize (line 27) | inline
function resize (line 39) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_shuffle.hpp
function arma_inline (line 20) | arma_inline
function arma_inline (line 40) | arma_inline
function arma_inline (line 58) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_size.hpp
function SizeMat (line 14) | inline
function size (line 26) | inline
function size (line 40) | inline
function SizeCube (line 55) | inline
function size (line 67) | inline
function size (line 81) | inline
function size (line 97) | inline
function size (line 111) | inline
function SizeCube (line 128) | inline
function SizeCube (line 140) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_solve.hpp
function solve (line 23) | inline
function solve (line 42) | inline
function solve (line 65) | inline
function solve (line 85) | inline
function solve (line 108) | inline
function solve (line 137) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_sort.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 37) | arma_inline
function arma_inline (line 66) | arma_inline
function arma_inline (line 89) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_sort_index.hpp
function sort_index (line 17) | inline
function stable_sort_index (line 36) | inline
function sort_index (line 54) | inline
function stable_sort_index (line 79) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_speye.hpp
function obj_type (line 16) | inline
function sp_mat (line 43) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_spones.hpp
function spones (line 16) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_sprandn.hpp
function obj_type (line 16) | inline
function sp_mat (line 48) | inline
function sprandn (line 66) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_sprandu.hpp
function obj_type (line 16) | inline
function sp_mat (line 48) | inline
function sprandu (line 66) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_spsolve.hpp
function spsolve_helper (line 16) | inline
function spsolve (line 85) | inline
function spsolve (line 113) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_stddev.hpp
function stddev (line 15) | inline
function stddev (line 36) | inline
function arma_warn_unused (line 55) | inline
function stddev (line 78) | typename arma_scalar_only<T>::result
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_strans.hpp
function arma_inline (line 15) | arma_inline
function arma_inline (line 36) | arma_inline
function arma_inline (line 56) | arma_inline
function strans (line 73) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_sum.hpp
function arma_inline (line 22) | arma_inline
function arma_inline (line 42) | arma_inline
function arma_warn_unused (line 62) | inline
function arma_warn_unused (line 86) | inline
function arma_inline (line 100) | arma_inline
function sum (line 124) | inline
function sum (line 142) | inline
function arma_warn_unused (line 159) | inline
function arma_inline (line 173) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_svd.hpp
function svd (line 15) | inline
function svd (line 43) | inline
function svd (line 70) | inline
function svd_econ (line 112) | inline
function svd_econ (line 160) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_svds.hpp
function svds_helper (line 14) | inline
function svds_helper (line 135) | inline
function svds (line 260) | inline
function svds (line 290) | inline
function svds (line 321) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_syl_lyap.hpp
function syl (line 15) | inline
function syl (line 53) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_symmat.hpp
function arma_inline (line 14) | arma_inline
function arma_inline (line 27) | arma_inline
function arma_inline (line 40) | arma_inline
function arma_inline (line 52) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_toeplitz.hpp
function toeplitz (line 15) | inline
function circ_toeplitz (line 27) | inline
function toeplitz (line 39) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_trace.hpp
function trace (line 19) | typename enable_if2<is_arma_type<T1>::value, typename T1::elem_type>::re...
function trace (line 56) | typename T1::elem_type
function arma_hot (line 81) | arma_hot
function arma_hot (line 136) | arma_hot
function trace (line 195) | typename T1::elem_type
function trace (line 210) | typename enable_if2<is_arma_sparse_type<T1>::value, typename T1::elem_ty...
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_trans.hpp
function arma_inline (line 14) | arma_inline
function arma_inline (line 31) | arma_inline
function arma_inline (line 49) | arma_inline
function arma_inline (line 62) | arma_inline
function trans (line 79) | inline
function trans (line 101) | inline
function htrans (line 123) | inline
function htrans (line 145) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_trig.hpp
function arma_inline (line 23) | arma_inline
function arma_inline (line 35) | arma_inline
function arma_inline (line 50) | arma_inline
function arma_inline (line 62) | arma_inline
function arma_inline (line 77) | arma_inline
function arma_inline (line 89) | arma_inline
function arma_inline (line 104) | arma_inline
function arma_inline (line 116) | arma_inline
function arma_inline (line 131) | arma_inline
function arma_inline (line 143) | arma_inline
function arma_inline (line 158) | arma_inline
function arma_inline (line 170) | arma_inline
function arma_inline (line 185) | arma_inline
function arma_inline (line 197) | arma_inline
function arma_inline (line 212) | arma_inline
function arma_inline (line 224) | arma_inline
function arma_inline (line 239) | arma_inline
function arma_inline (line 251) | arma_inline
function arma_inline (line 266) | arma_inline
function arma_inline (line 278) | arma_inline
function arma_inline (line 293) | arma_inline
function arma_inline (line 305) | arma_inline
function arma_inline (line 320) | arma_inline
function arma_inline (line 332) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_trimat.hpp
function arma_inline (line 14) | arma_inline
function arma_inline (line 26) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_trunc_exp.hpp
function trunc_exp (line 16) | inline
function trunc_exp (line 34) | inline
function trunc_exp (line 45) | inline
function arma_inline (line 56) | arma_inline
function arma_inline (line 68) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_trunc_log.hpp
function trunc_log (line 15) | inline
function trunc_log (line 40) | inline
function trunc_log (line 51) | inline
function arma_inline (line 62) | arma_inline
function arma_inline (line 74) | arma_inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_unique.hpp
function unique (line 12) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_var.hpp
function var (line 15) | inline
function var (line 36) | inline
function arma_warn_unused (line 55) | inline
function var (line 78) | typename arma_scalar_only<T>::result
function var (line 87) | inline
function var (line 108) | inline
function var (line 127) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_vectorise.hpp
function vectorise (line 15) | inline
function vectorise (line 32) | inline
function vectorise (line 51) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/fn_zeros.hpp
function arma_inline (line 14) | arma_inline
function arma_inline (line 26) | arma_inline
function arma_inline (line 47) | arma_inline
function arma_inline (line 59) | arma_inline
function arma_inline (line 81) | arma_inline
function arma_inline (line 93) | arma_inline
function sp_obj_type (line 106) | inline
FILE: OptolithiumC/libs/armadillo/include/armadillo_bits/forward_bones.hpp
type Base (line 15) | struct Base
type BaseCube (line 16) | struct BaseCube
class Mat (line 18) | class Mat
class Col (line 19) | class Col
class Row (line 20) | class Row
class Cube (line 21) | class Cube
class xvec_htrans (line 22) | class xvec_htrans
class field (line 23) | class field
class xtrans_mat (line 25) | class xtrans_mat
class subview (line 28) | class subview
class subview_col (line 29) | class subview_col
class subview_row (line 30) | class subview_row
class subview_row_strans (line 31) | class subview_row_strans
class subview_row_htrans (line 32) | class subview_row_htrans
class subview_cube (line 33) | class subview_cube
class subview_field (line 34) | class subview_field
class SpValProxy (line 36) | class SpValProxy
class SpMat (line 37) | class SpMat
class SpCol (line 38) | class SpCol
class SpRow (line 39) | class SpRow
class SpSubview (line 40) | class SpSubview
class diagview (line 42) | class diagview
class spdiagview (line 43) | class spdiagview
class subview_elem1 (line 45) | class subview_elem1
class subview_elem2 (line 46) | class subview_elem2
class subview_each1 (line 48) | class subview_each1
class subview_each2 (line 49) | class subview_each2
class SizeMat (line 51) | class SizeMat
class SizeCube (line 52) | class SizeCube
class arma_empty_class (line 54) | class arma_empty_class {}
class diskio (line 56) | class diskio
class op_min (line 58) | class op_min
class op_max (line 59) | class op_max
class op_strans (line 61) | class op_strans
class op_htrans (line 62) | class op_htrans
class op_htrans2 (line 63) | class op_htrans2
class op_inv (line 64) | class op_inv
class op_sum (line 65) | class op_sum
class op_abs (line 66) | class op_abs
class op_diagmat (line 67) | class op_diagmat
class op_trimat (line 68) | class op_trimat
class op_diagvec (line 69) | class op_diagvec
class op_vectorise_col (line 70) | class op_vectorise_col
class op_normalise_colvec (line 71) | class op_normalise_colvec
class op_normalise_rowvec (line 72) | class op_normalise_rowvec
class op_clamp (line 73) | class op_clamp
class op_cumsum_vec (line 74) | class op_cumsum_vec
class op_shuffle (line 75) | class op_shuffle
class op_sort (line 76) | class op_sort
class op_find (line 77) | class op_find
class op_find_simple (line 78) | class op_find_simple
class op_flipud (line 79) | class op_flipud
class op_fliplr (line 80) | class op_fliplr
class op_real (line 81) | class op_real
class op_imag (line 82) | class op_imag
class op_nonzeros (line 83) | class op_nonzeros
class op_sort_index (line 84) | class op_sort_index
class op_stable_sort_index (line 85) | class op_stable_sort_index
class eop_conj (line 87) | class eop_conj
class glue_times (line 89) | class glue_times
class glue_times_diag (line 90) | class glue_times_diag
class glue_rel_lt (line 92) | class glue_rel_lt
class glue_rel_gt (line 93) | class glue_rel_gt
class glue_rel_lteq (line 94) | class glue_rel_lteq
class glue_rel_gteq (line 95) | class glue_rel_gteq
class glue_rel_eq (line 96) | class glue_rel_eq
class glue_rel_noteq (line 97) | class glue_rel_noteq
class glue_rel_and (line 98) | class glue_rel_and
class glue_rel_or (line 99) | class glue_rel_or
class op_rel_lt_pre (line 101) | class op_rel_lt_pre
class op_rel_lt_post (line 102) | class op_rel_lt_post
class op_rel_gt_pre (line 103) | class op_rel_gt_pre
class op_rel_gt_post (line 104) | class op_rel_gt_post
class op_rel_lteq_pre (line 105) | class op_rel_lteq_pre
class op_rel_lteq_post (line 106) | class op_rel_lteq_post
class op_rel_gteq_pre (line 107) | class op_rel_gteq_pre
class op_rel_gteq_post (line 108) | class op_rel_gteq_post
class op_rel_eq (line 109) | class op_rel_eq
class op_rel_noteq (line 110) | class op_rel_noteq
class gen_ones_diag (line 112) | class gen_ones_diag
class gen_ones_full (line 113) | class gen_ones_full
class gen_zeros (line 114) | class gen_zeros
class gen_randu (line 115) | class gen_randu
class gen_randn (line 116) | class gen_randn
class glue_mixed_pl
Condensed preview — 671 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (7,869K chars).
[
{
"path": ".hgignore",
"chars": 2005,
"preview": "syntax: glob\nOptolithiumGui/icons/.DS_Store\nOptolithiumGui/database/.DS_Store\n.DS_Store\nOptolithiumC/.idea/*\nOptolithium"
},
{
"path": "COPYRIGHT",
"chars": 1018,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "LICENSE.TXT",
"chars": 18071,
"preview": "GNU GENERAL PUBLIC LICENSE\n Version 2, June 1991\n\n Copyright (C) 1989, 1991 Free Software Foundati"
},
{
"path": "OptolithiumC/CMakeLists.txt",
"chars": 5085,
"preview": "PROJECT(\"optolithiumc\")\nCMAKE_MINIMUM_REQUIRED(VERSION 2.8)\nCMAKE_POLICY(SET CMP0015 NEW)\n\nSET(CMAKE_USE_RELATIVE_PATHS "
},
{
"path": "OptolithiumC/FindFFTW.cmake",
"chars": 651,
"preview": " # - Find FFTW\n# Find the native FFTW includes and library\n#\n# FFTW_INCLUDES - where to find fftw3.h\n# FFTW_LIBRARIES - "
},
{
"path": "OptolithiumC/FindNumPy.cmake",
"chars": 4250,
"preview": "# - Find the NumPy libraries\r\n# This module finds if NumPy is installed, and sets the following variables\r\n# indicating "
},
{
"path": "OptolithiumC/clipper.i",
"chars": 1700,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/examples/aerial_image_various_source_shapes.py",
"chars": 9158,
"preview": "__author__ = 'OlaPsema'\r\n\r\nimport optolithiumc as oplc\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n\r\ndef get"
},
{
"path": "OptolithiumC/examples/resist_images_and_contours.py",
"chars": 12882,
"preview": "__author__ = 'OlaPsema'\r\n\r\nimport optolithiumc as oplc\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n\r\ndef get"
},
{
"path": "OptolithiumC/include/opl_capi.h",
"chars": 37083,
"preview": "/*\r\n *\r\n * This file is part of Optolithium lithography modelling software.\r\n *\r\n * Copyright (C) 2015 Alexei Gladkikh\r\n"
},
{
"path": "OptolithiumC/include/opl_contours.h",
"chars": 5126,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/include/opl_conv.h",
"chars": 5547,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/include/opl_eikonal.h",
"chars": 2993,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/include/opl_fft.h",
"chars": 6581,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/include/opl_geometry.h",
"chars": 10781,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/include/opl_interp.h",
"chars": 3065,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/include/opl_iter.h",
"chars": 3156,
"preview": "/*\r\n *\r\n * This file is part of Optolithium lithography modelling software.\r\n *\r\n * Copyright (C) 2015 Alexei Gladkikh\r\n"
},
{
"path": "OptolithiumC/include/opl_log.h",
"chars": 398,
"preview": "/*\n * opl_log.h\n *\n * Created on: Jul 22, 2014\n * Author: batman\n */\n\n#ifndef OPL_LOG_H_\n#define OPL_LOG_H_\n\n#incl"
},
{
"path": "OptolithiumC/include/opl_misc.h",
"chars": 1978,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/include/opl_physc.h",
"chars": 1440,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/include/opl_sim.h",
"chars": 1971,
"preview": "/*\r\n *\r\n * This file is part of Optolithium lithography modelling software.\r\n *\r\n * Copyright (C) 2015 Alexei Gladkikh\r\n"
},
{
"path": "OptolithiumC/include/optolithium.h",
"chars": 5167,
"preview": "/*\n *\n * This file is part of Optolithium lithography modelling software.\n *\n * Copyright (C) 2015 Alexei Gladkikh\n *\n *"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo",
"chars": 21747,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/BaseCube_bones.hpp",
"chars": 1631,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/BaseCube_meat.hpp",
"chars": 2105,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Base_bones.hpp",
"chars": 3847,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Base_meat.hpp",
"chars": 5866,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Col_bones.hpp",
"chars": 8963,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Col_meat.hpp",
"chars": 33941,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Cube_bones.hpp",
"chars": 21921,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Cube_meat.hpp",
"chars": 96588,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/GenCube_bones.hpp",
"chars": 1679,
"preview": "// Copyright (C) 2011-2013 Conrad Sanderson\n// Copyright (C) 2011-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/GenCube_meat.hpp",
"chars": 5108,
"preview": "// Copyright (C) 2011-2013 Conrad Sanderson\n// Copyright (C) 2011-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Gen_bones.hpp",
"chars": 1810,
"preview": "// Copyright (C) 2011-2014 Conrad Sanderson\n// Copyright (C) 2011-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Gen_meat.hpp",
"chars": 7594,
"preview": "// Copyright (C) 2011-2014 Conrad Sanderson\n// Copyright (C) 2011-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/GlueCube_bones.hpp",
"chars": 922,
"preview": "// Copyright (C) 2008-2010 Conrad Sanderson\n// Copyright (C) 2008-2010 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/GlueCube_meat.hpp",
"chars": 773,
"preview": "// Copyright (C) 2008-2010 Conrad Sanderson\n// Copyright (C) 2008-2010 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Glue_bones.hpp",
"chars": 1748,
"preview": "// Copyright (C) 2008-2012 Conrad Sanderson\n// Copyright (C) 2008-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Glue_meat.hpp",
"chars": 907,
"preview": "// Copyright (C) 2008-2010 Conrad Sanderson\n// Copyright (C) 2008-2010 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Mat_bones.hpp",
"chars": 37299,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2012-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Mat_meat.hpp",
"chars": 171712,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2012-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/OpCube_bones.hpp",
"chars": 2110,
"preview": "// Copyright (C) 2008-2011 Conrad Sanderson\n// Copyright (C) 2008-2011 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/OpCube_meat.hpp",
"chars": 2389,
"preview": "// Copyright (C) 2008-2011 Conrad Sanderson\n// Copyright (C) 2008-2011 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Op_bones.hpp",
"chars": 3210,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Op_meat.hpp",
"chars": 1681,
"preview": "// Copyright (C) 2008-2011 Conrad Sanderson\n// Copyright (C) 2008-2011 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Proxy.hpp",
"chars": 66055,
"preview": "// Copyright (C) 2010-2014 Conrad Sanderson\n// Copyright (C) 2010-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/ProxyCube.hpp",
"chars": 16911,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Row_bones.hpp",
"chars": 8913,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/Row_meat.hpp",
"chars": 32086,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SizeCube_bones.hpp",
"chars": 963,
"preview": "// Copyright (C) 2013-2014 Conrad Sanderson\n// Copyright (C) 2013-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SizeCube_meat.hpp",
"chars": 2469,
"preview": "// Copyright (C) 2013-2014 Conrad Sanderson\n// Copyright (C) 2013-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SizeMat_bones.hpp",
"chars": 908,
"preview": "// Copyright (C) 2013-2014 Conrad Sanderson\n// Copyright (C) 2013-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SizeMat_meat.hpp",
"chars": 2171,
"preview": "// Copyright (C) 2013-2014 Conrad Sanderson\n// Copyright (C) 2013-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpBase_bones.hpp",
"chars": 2502,
"preview": "// Copyright (C) 2012-2014 Conrad Sanderson\n// Copyright (C) 2012-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpBase_meat.hpp",
"chars": 5444,
"preview": "// Copyright (C) 2012-2014 Conrad Sanderson\n// Copyright (C) 2012-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpCol_bones.hpp",
"chars": 2238,
"preview": "// Copyright (C) 2011-2012 Ryan Curtin\n// Copyright (C) 2011 Matthew Amidon\n//\n// This Source Code Form is subject to th"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpCol_meat.hpp",
"chars": 8206,
"preview": "// Copyright (C) 2011-2012 Ryan Curtin\n// Copyright (C) 2015 Conrad Sanderson\n// Copyright (C) 2011 Matthew Amidon\n// \n/"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpGlue_bones.hpp",
"chars": 1263,
"preview": "// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is subject to the terms of the Mozilla Public\n// Lic"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpGlue_meat.hpp",
"chars": 875,
"preview": "// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is subject to the terms of the Mozilla Public\n// Lic"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpMat_bones.hpp",
"chars": 29463,
"preview": "// Copyright (C) 2011-2014 Ryan Curtin\n// Copyright (C) 2012-2015 Conrad Sanderson\n// Copyright (C) 2011 Matthew Amidon\n"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpMat_iterators_meat.hpp",
"chars": 18578,
"preview": "// Copyright (C) 2011-2014 Ryan Curtin\n// Copyright (C) 2012-2014 Conrad Sanderson\n// Copyright (C) 2011 Matthew Amidon\n"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpMat_meat.hpp",
"chars": 117161,
"preview": "// Copyright (C) 2011-2015 Ryan Curtin\n// Copyright (C) 2012-2015 Conrad Sanderson\n// Copyright (C) 2011 Matthew Amidon\n"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpOp_bones.hpp",
"chars": 1534,
"preview": "// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is subject to the terms of the Mozilla Public\n// Lic"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpOp_meat.hpp",
"chars": 999,
"preview": "// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is subject to the terms of the Mozilla Public\n// Lic"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpProxy.hpp",
"chars": 16399,
"preview": "// Copyright (C) 2012 Ryan Curtin\n// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is subject to the "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpRow_bones.hpp",
"chars": 2236,
"preview": "// Copyright (C) 2011-2012 Ryan Curtin\n// Copyright (C) 2011 Matthew Amidon\n// \n// This Source Code Form is subject to t"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpRow_meat.hpp",
"chars": 8649,
"preview": "// Copyright (C) 2011-2012 Ryan Curtin\n// Copyright (C) 2015 Conrad Sanderson\n// Copyright (C) 2011 Matthew Amidon\n// \n/"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpSubview_bones.hpp",
"chars": 14845,
"preview": "// Copyright (C) 2011-2012 Ryan Curtin\n// Copyright (C) 2011 Matthew Amidon\n// Copyright (C) 2012 Conrad Sanderson\n//\n//"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpSubview_iterators_meat.hpp",
"chars": 24549,
"preview": "// Copyright (C) 2012 Ryan Curtin\n// Copyright (C) 2012 Conrad Sanderson\n//\n// This Source Code Form is subject to the t"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpSubview_meat.hpp",
"chars": 35173,
"preview": "// Copyright (C) 2011-2015 Ryan Curtin\n// Copyright (C) 2012-2015 Conrad Sanderson\n// Copyright (C) 2011 Matthew Amidon\n"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpValProxy_bones.hpp",
"chars": 2010,
"preview": "// Copyright (C) 2011-2012 Ryan Curtin\n//\n// This Source Code Form is subject to the terms of the Mozilla Public\n// Lice"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/SpValProxy_meat.hpp",
"chars": 5312,
"preview": "// Copyright (C) 2011-2012 Ryan Curtin\n// Copyright (C) 2012 Conrad Sanderson\n//\n// This Source Code Form is subject to "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/access.hpp",
"chars": 1383,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_boost.hpp",
"chars": 10307,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_cmath.hpp",
"chars": 8804,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_config.hpp",
"chars": 3091,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_ostream_bones.hpp",
"chars": 2476,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_ostream_meat.hpp",
"chars": 18357,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2012 Ry"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_rng.hpp",
"chars": 7418,
"preview": "// Copyright (C) 2013-2015 Conrad Sanderson\n// Copyright (C) 2013-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_rng_cxx11.hpp",
"chars": 2580,
"preview": "// Copyright (C) 2013-2015 Conrad Sanderson\n// Copyright (C) 2013-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_rng_cxx98.hpp",
"chars": 3209,
"preview": "// Copyright (C) 2013-2014 Conrad Sanderson\n// Copyright (C) 2013-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_static_check.hpp",
"chars": 1136,
"preview": "// Copyright (C) 2008-2011 Conrad Sanderson\n// Copyright (C) 2008-2011 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arma_version.hpp",
"chars": 1026,
"preview": "// Copyright (C) 2009-2015 Conrad Sanderson\n// Copyright (C) 2009-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arpack_bones.hpp",
"chars": 5304,
"preview": "// Copyright (C) 2013 Ryan Curtin\n//\n// This Source Code Form is subject to the terms of the Mozilla Public\n// License, "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arpack_wrapper.hpp",
"chars": 5943,
"preview": "// Copyright (C) 2013 Ryan Curtin\n//\n// This Source Code Form is subject to the terms of the Mozilla Public\n// License, "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arrayops_bones.hpp",
"chars": 5886,
"preview": "// Copyright (C) 2011-2015 Conrad Sanderson\n// Copyright (C) 2011-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/arrayops_meat.hpp",
"chars": 20950,
"preview": "// Copyright (C) 2011-2015 Conrad Sanderson\n// Copyright (C) 2011-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/atlas_bones.hpp",
"chars": 6546,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/atlas_wrapper.hpp",
"chars": 9287,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/auxlib_bones.hpp",
"chars": 8926,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// Copyright (C) 2009 Ed"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/auxlib_meat.hpp",
"chars": 105014,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2009 Ed"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/blas_bones.hpp",
"chars": 5118,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/blas_wrapper.hpp",
"chars": 6736,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/compiler_setup.hpp",
"chars": 12708,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/compiler_setup_post.hpp",
"chars": 353,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/cond_rel_bones.hpp",
"chars": 833,
"preview": "// Copyright (C) 2012 NICTA (www.nicta.com.au)\n// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/cond_rel_meat.hpp",
"chars": 1540,
"preview": "// Copyright (C) 2012 NICTA (www.nicta.com.au)\n// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/config.hpp",
"chars": 6961,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2013-2015 Ryan Curtin\n// Copyright (C) 2008-2015 NICTA (www"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/config.hpp.cmake",
"chars": 7011,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2013-2015 Ryan Curtin\n// Copyright (C) 2008-2015 NICTA (www"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/constants.hpp",
"chars": 10225,
"preview": "// Copyright (C) 2008-2012 Conrad Sanderson\n// Copyright (C) 2008-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/constants_compat.hpp",
"chars": 5611,
"preview": "// Copyright (C) 2008-2011 Conrad Sanderson\n// Copyright (C) 2008-2011 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/debug.hpp",
"chars": 29989,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2011 St"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/diagmat_proxy.hpp",
"chars": 15651,
"preview": "// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// Copyright (C) 2008-2014 Conrad Sanderson\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/diagview_bones.hpp",
"chars": 3154,
"preview": "// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// Copyright (C) 2008-2013 Conrad Sanderson\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/diagview_meat.hpp",
"chars": 20532,
"preview": "// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// Copyright (C) 2008-2013 Conrad Sanderson\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/diskio_bones.hpp",
"chars": 11493,
"preview": "// Copyright (C) 2008-2012 NICTA (www.nicta.com.au)\n// Copyright (C) 2008-2012 Conrad Sanderson\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/diskio_meat.hpp",
"chars": 103404,
"preview": "// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/distr_param.hpp",
"chars": 830,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eGlueCube_bones.hpp",
"chars": 1567,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eGlueCube_meat.hpp",
"chars": 3708,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eGlue_bones.hpp",
"chars": 1732,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eGlue_meat.hpp",
"chars": 3334,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eOpCube_bones.hpp",
"chars": 2399,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eOpCube_meat.hpp",
"chars": 3364,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eOp_bones.hpp",
"chars": 1980,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eOp_meat.hpp",
"chars": 2547,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eglue_core_bones.hpp",
"chars": 2568,
"preview": "// Copyright (C) 2010-2015 Conrad Sanderson\n// Copyright (C) 2010-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eglue_core_meat.hpp",
"chars": 32093,
"preview": "// Copyright (C) 2010-2015 Conrad Sanderson\n// Copyright (C) 2010-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eop_aux.hpp",
"chars": 13842,
"preview": "// Copyright (C) 2010-2013 Conrad Sanderson\n// Copyright (C) 2010-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eop_core_bones.hpp",
"chars": 4621,
"preview": "// Copyright (C) 2010-2015 Conrad Sanderson\n// Copyright (C) 2010-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/eop_core_meat.hpp",
"chars": 22470,
"preview": "// Copyright (C) 2010-2015 Conrad Sanderson\n// Copyright (C) 2010-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fft_engine.hpp",
"chars": 10670,
"preview": "// This Source Code Form is a compilation of:\n// (1) source code written by Conrad Sanderson, and\n// (2) a modified form"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/field_bones.hpp",
"chars": 14584,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/field_meat.hpp",
"chars": 56011,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_accu.hpp",
"chars": 8512,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2012 Ry"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_all.hpp",
"chars": 1900,
"preview": "// Copyright (C) 2013-2015 Conrad Sanderson\n// Copyright (C) 2013-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_any.hpp",
"chars": 1900,
"preview": "// Copyright (C) 2013-2015 Conrad Sanderson\n// Copyright (C) 2013-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_as_scalar.hpp",
"chars": 11614,
"preview": "// Copyright (C) 2010-2015 Conrad Sanderson\n// Copyright (C) 2010-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_chol.hpp",
"chars": 1301,
"preview": "// Copyright (C) 2009-2014 Conrad Sanderson\n// Copyright (C) 2009-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_clamp.hpp",
"chars": 854,
"preview": "// Copyright (C) 2014 Conrad Sanderson\n// Copyright (C) 2014 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cond.hpp",
"chars": 890,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_conv.hpp",
"chars": 700,
"preview": "// Copyright (C) 2010 Conrad Sanderson\n// Copyright (C) 2010 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_conv_to.hpp",
"chars": 15370,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cor.hpp",
"chars": 1085,
"preview": "// Copyright (C) 2009-2010 Conrad Sanderson\n// Copyright (C) 2009-2010 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cov.hpp",
"chars": 1083,
"preview": "// Copyright (C) 2009-2010 Conrad Sanderson\n// Copyright (C) 2009-2010 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cross.hpp",
"chars": 662,
"preview": "// Copyright (C) 2010 Conrad Sanderson\n// Copyright (C) 2010 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_cumsum.hpp",
"chars": 2338,
"preview": "// Copyright (C) 2010-2012 Conrad Sanderson\n// Copyright (C) 2010-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_det.hpp",
"chars": 5355,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_diagmat.hpp",
"chars": 863,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_diagvec.hpp",
"chars": 669,
"preview": "// Copyright (C) 2008-2010 Conrad Sanderson\n// Copyright (C) 2008-2010 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_dot.hpp",
"chars": 6639,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// Copyright (C) 2012 Ry"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eig_gen.hpp",
"chars": 7726,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// Copyright (C) 2009 Ed"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eig_pair.hpp",
"chars": 6049,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eig_sym.hpp",
"chars": 2991,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// Copyright (C) 2011 St"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eigs_gen.hpp",
"chars": 3006,
"preview": "// Copyright (C) 2013-2014 Ryan Curtin\n// Copyright (C) 2013-2014 Conrad Sanderson\n// Copyright (C) 2013-2014 NICTA\n// \n"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eigs_sym.hpp",
"chars": 2786,
"preview": "// Copyright (C) 2013-2014 Ryan Curtin\n// Copyright (C) 2013-2014 Conrad Sanderson\n// Copyright (C) 2013-2014 NICTA\n// \n"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_elem.hpp",
"chars": 13005,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eps.hpp",
"chars": 1915,
"preview": "// Copyright (C) 2009-2010 Conrad Sanderson\n// Copyright (C) 2009-2010 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_expmat.hpp",
"chars": 559,
"preview": "// Copyright (C) 2014 Conrad Sanderson\n// Copyright (C) 2014 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_eye.hpp",
"chars": 1075,
"preview": "// Copyright (C) 2008-2012 Conrad Sanderson\n// Copyright (C) 2008-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_fft.hpp",
"chars": 2241,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_fft2.hpp",
"chars": 2519,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_find.hpp",
"chars": 4166,
"preview": "// Copyright (C) 2010-2014 Conrad Sanderson\n// Copyright (C) 2010-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_flip.hpp",
"chars": 765,
"preview": "// Copyright (C) 2010-2015 Conrad Sanderson\n// Copyright (C) 2010-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_hist.hpp",
"chars": 1119,
"preview": "// Copyright (C) 2012 Conrad Sanderson\n// Copyright (C) 2012 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_histc.hpp",
"chars": 701,
"preview": "// Copyright (C) 2015 Conrad Sanderson\n// Copyright (C) 2015 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_inplace_strans.hpp",
"chars": 2173,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 Alexandre Drouin \n// Copyright (C) 2013 NICTA (www.nicta.co"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_inplace_trans.hpp",
"chars": 1980,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_interp1.hpp",
"chars": 8255,
"preview": "// Copyright (C) 2015 Conrad Sanderson\n// Copyright (C) 2015 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_inv.hpp",
"chars": 3956,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_join.hpp",
"chars": 2931,
"preview": "// Copyright (C) 2010-2015 Conrad Sanderson\n// Copyright (C) 2010-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_kron.hpp",
"chars": 1933,
"preview": "// Copyright (C) 2009-2010 Conrad Sanderson\n// Copyright (C) 2009-2010 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_log_det.hpp",
"chars": 1855,
"preview": "// Copyright (C) 2010-2011 Conrad Sanderson\n// Copyright (C) 2010-2011 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_lu.hpp",
"chars": 1788,
"preview": "// Copyright (C) 2008-2011 Conrad Sanderson\n// Copyright (C) 2008-2011 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_max.hpp",
"chars": 3909,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_mean.hpp",
"chars": 3490,
"preview": "// Copyright (C) 2009-2012 Conrad Sanderson\n// Copyright (C) 2009-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_median.hpp",
"chars": 1556,
"preview": "// Copyright (C) 2009-2012 Conrad Sanderson\n// Copyright (C) 2009-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_min.hpp",
"chars": 3907,
"preview": "// Copyright (C) 2008-2012 Conrad Sanderson\n// Copyright (C) 2008-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_misc.hpp",
"chars": 6111,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_n_unique.hpp",
"chars": 2816,
"preview": "// Copyright (C) 2012 Ryan Curtin\n// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is subject to the "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_nonzeros.hpp",
"chars": 788,
"preview": "// Copyright (C) 2015 Conrad Sanderson\n// Copyright (C) 2015 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_norm.hpp",
"chars": 18021,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_norm_sparse.hpp",
"chars": 5905,
"preview": "// Copyright (C) 2012-2014 Conrad Sanderson\n// Copyright (C) 2012-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_normalise.hpp",
"chars": 1787,
"preview": "// Copyright (C) 2014 Conrad Sanderson\n// Copyright (C) 2014 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_numel.hpp",
"chars": 1233,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_ones.hpp",
"chars": 2342,
"preview": "// Copyright (C) 2008-2012 Conrad Sanderson\n// Copyright (C) 2008-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_pinv.hpp",
"chars": 1535,
"preview": "// Copyright (C) 2009-2013 Conrad Sanderson\n// Copyright (C) 2009-2013 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_princomp.hpp",
"chars": 3962,
"preview": "// Copyright (C) 2010-2012 Conrad Sanderson\n// Copyright (C) 2010-2012 NICTA (www.nicta.com.au)\n// Copyright (C) 2010 Di"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_prod.hpp",
"chars": 2530,
"preview": "// Copyright (C) 2009-2012 Conrad Sanderson\n// Copyright (C) 2009-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_qr.hpp",
"chars": 1564,
"preview": "// Copyright (C) 2009-2012 Conrad Sanderson\n// Copyright (C) 2009-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_qz.hpp",
"chars": 1121,
"preview": "// Copyright (C) 2015 Conrad Sanderson\n// Copyright (C) 2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2015 Keith O'Hara"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_randg.hpp",
"chars": 4609,
"preview": "// Copyright (C) 2015 Conrad Sanderson\n// Copyright (C) 2015 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_randi.hpp",
"chars": 3264,
"preview": "// Copyright (C) 2013 Conrad Sanderson\n// Copyright (C) 2013 NICTA (www.nicta.com.au)\n// \n// This Source Code Form is su"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_randn.hpp",
"chars": 2743,
"preview": "// Copyright (C) 2008-2012 Conrad Sanderson\n// Copyright (C) 2008-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_randu.hpp",
"chars": 2711,
"preview": "// Copyright (C) 2008-2013 Conrad Sanderson\n// Copyright (C) 2008-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_rank.hpp",
"chars": 1407,
"preview": "// Copyright (C) 2009-2015 Conrad Sanderson\n// Copyright (C) 2009-2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_repmat.hpp",
"chars": 855,
"preview": "// Copyright (C) 2009-2015 Conrad Sanderson\n// Copyright (C) 2009-2015 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_reshape.hpp",
"chars": 1698,
"preview": "// Copyright (C) 2008-2015 Conrad Sanderson\n// Copyright (C) 2008-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_resize.hpp",
"chars": 1176,
"preview": "// Copyright (C) 2011-2015 Conrad Sanderson\n// Copyright (C) 2011-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_shuffle.hpp",
"chars": 1687,
"preview": "// Copyright (C) 2009-2013 Conrad Sanderson\n// Copyright (C) 2009-2013 NICTA (www.nicta.com.au)\n// Copyright (C) 2009-20"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_size.hpp",
"chars": 2821,
"preview": "// Copyright (C) 2013-2014 Conrad Sanderson\n// Copyright (C) 2013-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_solve.hpp",
"chars": 3819,
"preview": "// Copyright (C) 2009-2013 Conrad Sanderson\n// Copyright (C) 2009-2013 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_sort.hpp",
"chars": 2415,
"preview": "// Copyright (C) 2008-2014 Conrad Sanderson\n// Copyright (C) 2008-2014 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_sort_index.hpp",
"chars": 2368,
"preview": "// Copyright (C) 2009-2015 Conrad Sanderson\n// Copyright (C) 2009-2015 NICTA (www.nicta.com.au)\n// \n// This Source Code "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_speye.hpp",
"chars": 1180,
"preview": "// Copyright (C) 2012 Conrad Sanderson\n// Copyright (C) 2012 Ryan Curtin\n// \n// This Source Code Form is subject to the "
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_spones.hpp",
"chars": 766,
"preview": "// Copyright (C) 2012-2013 Conrad Sanderson\n// \n// This Source Code Form is subject to the terms of the Mozilla Public\n/"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_sprandn.hpp",
"chars": 1800,
"preview": "// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is subject to the terms of the Mozilla Public\n// Lic"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_sprandu.hpp",
"chars": 1766,
"preview": "// Copyright (C) 2012 Conrad Sanderson\n// \n// This Source Code Form is subject to the terms of the Mozilla Public\n// Lic"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_spsolve.hpp",
"chars": 3852,
"preview": "// Copyright (C) 2015 Ryan Curtin\r\n// Copyright (C) 2015 Conrad Sanderson\r\n// \r\n// This Source Code Form is subject to t"
},
{
"path": "OptolithiumC/libs/armadillo/include/armadillo_bits/fn_stddev.hpp",
"chars": 1762,
"preview": "// Copyright (C) 2009-2012 Conrad Sanderson\n// Copyright (C) 2009-2012 NICTA (www.nicta.com.au)\n// \n// This Source Code "
}
]
// ... and 471 more files (download for full content)
About this extraction
This page contains the full source code of the xthebat/optolithium GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 671 files (7.1 MB), approximately 1.9M tokens, and a symbol index with 6773 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.