from ctypes import POINTER as PTR
from ctypes import c_uint, c_void_p
from h2libpy.lib.krylov import CFuncAddevalT, CFuncPrcdT
from h2libpy.lib.settings import real
from h2libpy.lib.util.helper import get_func
from h2libpy.lib.util.structs import (CStructAMatrix, CStructAVector,
CStructDH2Matrix, CStructH2Matrix,
CStructHMatrix, CStructSparseMatrix)
# ------------------------
solve_cg_avector = get_func('solve_cg_avector', c_uint, [
c_void_p, CFuncAddevalT,
PTR(CStructAVector),
PTR(CStructAVector), real, c_uint
])
solve_cg_amatrix_avector = get_func('solve_cg_amatrix_avector', c_uint, [
PTR(CStructAMatrix),
PTR(CStructAVector),
PTR(CStructAVector), real, c_uint
])
solve_cg_sparsematrix_avector = get_func('solve_cg_sparsematrix_avector',
c_uint, [
PTR(CStructSparseMatrix),
PTR(CStructAVector),
PTR(CStructAVector), real, c_uint
])
solve_cg_hmatrix_avector = get_func('solve_cg_hmatrix_avector', c_uint, [
PTR(CStructHMatrix),
PTR(CStructAVector),
from h2libpy.lib.settings import field, real
from h2libpy.lib.util.helper import get_func
from h2libpy.lib.util.structs import CStructAMatrix, CStructAVector
# ------------------------------------
CFuncAddevalT = CFUNCTYPE(None,
*(field, c_void_p, CStructAVector, CStructAVector))
CFuncPrcdT = CFUNCTYPE(None, *(c_void_p, CStructAVector))
CFuncMvmT = CFUNCTYPE(
None, *(field, c_bool, c_void_p, CStructAVector, CStructAVector))
# ------------------------------------
norm2_matrix = get_func('norm2_matrix', real,
[CFuncMvmT, c_void_p, c_uint, c_uint])
norm2diff_matrix = get_func(
'norm2diff_matrix', real,
[CFuncMvmT, c_void_p, CFuncMvmT, c_void_p, c_uint, c_uint])
norm2diff_pre_matrix = get_func(
'norm2diff_pre_matrix', real,
[CFuncMvmT, c_void_p, CFuncPrcdT, CFuncPrcdT, c_void_p, c_uint, c_uint])
norm2diff_id_pre_matrix = get_func(
'norm2diff_id_pre_matrix', real,
[CFuncMvmT, c_void_p, CFuncPrcdT, CFuncPrcdT, c_void_p, c_uint, c_uint])
init_cg = get_func('init_cg', None, [
CFuncAddevalT, c_void_p,
PTR(CStructAVector),
PTR(CStructAVector),
PTR(CStructAVector),
PTR(CStructAVector),
# ------------------------
CStructClusterBasis._fields_ = [('t', PTR(CStructCluster)), ('k', c_uint),
('ktree', c_uint), ('kbranch', c_uint),
('V', CStructAMatrix), ('E', CStructAMatrix),
('sons', c_uint),
('son', PTR(PTR(CStructClusterBasis))),
('Z', PTR(CStructAMatrix)), ('refs', c_uint),
('rlist', PTR(CStructUniform)),
('clist', PTR(CStructUniform))]
# ------------------------
init_clusterbasis = get_func(
'init_clusterbasis', PTR(CStructClusterBasis),
[PTR(CStructClusterBasis), PTR(CStructCluster)])
init_leaf_clusterbasis = get_func(
'init_leaf_clusterbasis', PTR(CStructClusterBasis),
[PTR(CStructClusterBasis), PTR(CStructCluster)])
init_sub_clusterbasis = get_func('init_sub_clusterbasis',
PTR(CStructClusterBasis), [
PTR(CStructClusterBasis),
PTR(CStructClusterBasis),
PTR(CStructCluster), c_uint
])
uninit_clusterbasis = get_func('uninit_clusterbasis', None,
[PTR(CStructClusterBasis)])
new_clusterbasis = get_func('new_clusterbasis', PTR(CStructClusterBasis),
[PTR(CStructCluster)])
new_leaf_clusterbasis = get_func('new_leaf_clusterbasis',
from ctypes import POINTER as PTR
from ctypes import c_bool, c_size_t, c_uint, c_void_p
from h2libpy.lib.settings import field, real
from h2libpy.lib.util.helper import get_func
from h2libpy.lib.util.structs import CStructAMatrix, CStructAVector
# ------------------------
CStructAMatrix._fields_ = [('a', PTR(field)), ('ld', c_uint), ('rows', c_uint),
('cols', c_uint), ('owner', c_void_p)]
# ------------------------
init_amatrix = get_func('init_amatrix', PTR(CStructAMatrix),
[PTR(CStructAMatrix), c_uint, c_uint])
init_sub_amatrix = get_func(
'init_sub_amatrix', PTR(CStructAMatrix),
[PTR(CStructAMatrix),
PTR(CStructAMatrix), c_uint, c_uint, c_uint, c_uint])
init_vec_amatrix = get_func(
'init_vec_amatrix', PTR(CStructAMatrix),
[PTR(CStructAMatrix),
PTR(CStructAVector), c_uint, c_uint])
init_pointer_amatrix = get_func(
'init_pointer_amatrix', PTR(CStructAMatrix),
[PTR(CStructAMatrix), PTR(field), c_uint, c_uint])
init_zero_amatrix = get_func('init_zero_amatrix', PTR(CStructAMatrix),
[PTR(CStructAMatrix), c_uint, c_uint])
init_identity_amatrix = get_func('init_identity_amatrix', PTR(CStructAMatrix),
[PTR(CStructAMatrix), c_uint, c_uint])
from h2libpy.lib.settings import field, real
from h2libpy.lib.util.helper import get_func
from h2libpy.lib.util.structs import (CStructAMatrix, CStructAVector,
CStructSparseMatrix,
CStructSparsePattern)
# ------------------------
CStructSparseMatrix._fields_ = [('rows', c_uint), ('cols', c_uint),
('nz', c_uint), ('row', PTR(c_uint)),
('col', PTR(c_uint)), ('coeff', PTR(field))]
# ------------------------
new_raw_sparsematrix = get_func('new_raw_sparsematrix',
PTR(CStructSparseMatrix),
[c_uint, c_uint, c_uint])
new_identity_sparsematrix = get_func('new_identity_sparsematrix',
PTR(CStructSparseMatrix),
[c_uint, c_uint])
new_zero_sparsematrix = get_func('new_zero_sparsematrix',
PTR(CStructSparseMatrix),
[PTR(CStructSparsePattern)])
del_sparsematrix = get_func('del_sparsematrix', None,
[PTR(CStructSparseMatrix)])
addentry_sparsematrix = get_func(
'addentry_sparsematrix', field,
[PTR(CStructSparseMatrix), c_uint, c_uint, field])
setentry_sparsematrix = get_func(
'setentry_sparsematrix', None,
[PTR(CStructSparseMatrix), c_uint, c_uint, field])
]
CStructH2MatrixList._fields_ = [
('G', PTR(CStructH2Matrix)),
('mname', c_uint),
('rname', c_uint),
('cname', c_uint),
('father', PTR(CStructH2MatrixList)),
('next', PTR(CStructH2MatrixList)),
]
# ------------------------
new_h2matrix = get_func('new_h2matrix', PTR(CStructH2Matrix), [PTR(CStructClusterBasis), PTR(CStructClusterBasis)])
new_uniform_h2matrix = get_func('new_uniform_h2matrix', PTR(CStructH2Matrix), [PTR(CStructClusterBasis), PTR(CStructClusterBasis)])
new_full_h2matrix = get_func('new_full_h2matrix', PTR(CStructH2Matrix), [PTR(CStructClusterBasis), PTR(CStructClusterBasis)])
new_super_h2matrix = get_func('new_super_h2matrix', PTR(CStructH2Matrix), [PTR(CStructClusterBasis), PTR(CStructClusterBasis), c_uint, c_uint])
new_zero_h2matrix = get_func('new_zero_h2matrix', PTR(CStructH2Matrix), [PTR(CStructClusterBasis), PTR(CStructClusterBasis)])
clonestructure_h2matrix = get_func('clonestructure_h2matrix', PTR(CStructH2Matrix), [PTR(CStructH2Matrix), PTR(CStructClusterBasis), PTR(CStructClusterBasis)])
clone_h2matrix = get_func('clone_h2matrix', PTR(CStructH2Matrix), [PTR(CStructH2Matrix), PTR(CStructClusterBasis), PTR(CStructClusterBasis)])
update_h2matrix = get_func('update_h2matrix', None, [PTR(CStructH2Matrix)])
del_h2matrix = get_func('del_h2matrix', None, [PTR(CStructH2Matrix)])
ref_h2matrix = get_func('ref_h2matrix', None, [PTR(PTR(CStructH2Matrix)), PTR(CStructH2Matrix)])
unref_h2matrix = get_func('unref_h2matrix', None, [PTR(CStructH2Matrix)])
getsize_h2matrix = get_func('getsize_h2matrix', c_size_t, [PTR(CStructH2Matrix)])
gettotalsize_h2matrix = get_func('gettotalsize_h2matrix', c_size_t, [PTR(CStructH2Matrix)])
getnearsize_h2matrix = get_func('getnearsize_h2matrix', c_size_t, [PTR(CStructH2Matrix)])
getfarsize_h2matrix = get_func('getfarsize_h2matrix', c_size_t, [PTR(CStructH2Matrix)])
clear_h2matrix = get_func('clear_h2matrix', None, [PTR(CStructH2Matrix)])
CStructCluster._fields_ = [
('size', c_uint),
('idx', PTR(c_uint)),
('sons', c_uint),
('dim', c_uint),
('bmin', PTR(real)),
('bmax', PTR(real)),
('desc', c_uint),
('type', c_uint),
]
# ------------------------
new_cluster = get_func('new_cluster', PTR(CStructCluster), [c_uint, PTR(c_uint), c_uint, c_uint])
del_cluster = get_func('del_cluster', None, [PTR(CStructCluster)])
update_cluster = get_func('update_cluster', None, [PTR(CStructCluster)])
build_adaptive_cluster = get_func('build_adaptive_cluster', PTR(CStructCluster), [PTR(CStructClusterGeometry), c_uint, PTR(c_uint), c_uint])
build_regular_cluster = get_func('build_regular_cluster', PTR(CStructCluster), [PTR(CStructClusterGeometry), c_uint, PTR(c_uint), c_uint, c_uint])
build_simsub_cluster = get_func('build_simsub_cluster', PTR(CStructCluster), [PTR(CStructClusterGeometry), c_uint, PTR(c_uint), c_uint])
build_pca_cluster = get_func('build_pca_cluster', PTR(CStructCluster), [PTR(CStructClusterGeometry), c_uint, PTR(c_uint), c_uint])
build_cluster = get_func('build_cluster', PTR(CStructCluster), [PTR(CStructClusterGeometry), c_uint, PTR(c_uint), c_uint, CEnumClusterMode])
getdepth_cluster = get_func('getdepth_cluster', c_uint, [PTR(CStructCluster)])
getmindepth_cluster = get_func('getmindepth_cluster', c_uint, [PTR(CStructCluster)])
extend_cluster = get_func('extend_cluster', None, [PTR(CStructCluster), c_uint])
cut_cluster = get_func('cut_cluster', None, [PTR(CStructCluster), c_uint])
balance_cluster = get_func('balance_cluster', None, [PTR(CStructCluster), c_uint])
coarsen_cluster = get_func('coarsen_cluster', None, [PTR(CStructCluster), c_uint])
setsons_cluster = get_func('setsons_cluster', None, [PTR(CStructCluster), c_uint])
getdiam_2_cluster = get_func('getdiam_2_cluster', real, [PTR(CStructCluster)])
('x_single', PTR(real)),
('y_single', PTR(real)),
('w_single', PTR(real)),
('base_single', real),
('n_single', c_uint),
# ('tri_x', PTR(real)),
# ('tri_y', PTR(real)),
# ('tri_z', PTR(real)),
('q', c_uint),
('q2', c_uint),
('nmax', c_uint)
]
# ------------------------
build_singquad2d = get_func('build_singquad2d', PTR(CStructSingQuad2d),
[PTR(CStructSurface3d), c_uint, c_uint])
del_singquad2d = get_func('del_singquad2d', None, [PTR(CStructSingQuad2d)])
weight_basisfunc_ll_singquad2d = get_func(
'weight_basisfunc_ll_singquad2d', None,
[PTR(real), PTR(real), PTR(real), c_uint])
weight_basisfunc_cl_singquad2d = get_func(
'weight_basisfunc_cl_singquad2d', None,
[PTR(real), PTR(real), PTR(real), c_uint])
weight_basisfunc_lc_singquad2d = get_func(
'weight_basisfunc_lc_singquad2d', None,
[PTR(real), PTR(real), PTR(real), c_uint])
weight_basisfunc_l_singquad2d = get_func(
'weight_basisfunc_l_singquad2d', None,
[PTR(real), PTR(real), PTR(real), c_uint])
fast_select_quadrature = get_func('fast_select_quadrature', c_uint,
[PTR(c_uint * 3), c_uint, c_uint])
from h2libpy.lib.util.structs import CStructAVector, CStructAMatrix
# ------------------------
CStructAVector._fields_ = [
('v', PTR(field)),
('dim', c_uint),
('owner', c_void_p)
]
# ------------------------
init_avector = get_func('init_avector', PTR(CStructAVector), [PTR(CStructAVector), c_uint])
init_sub_avector = get_func('init_sub_avector', PTR(CStructAVector), [PTR(CStructAVector), PTR(CStructAVector), c_uint, c_uint])
init_zero_avector = get_func('init_zero_avector', PTR(CStructAVector), [PTR(CStructAVector), c_uint])
init_column_avector = get_func('init_column_avector', PTR(CStructAVector), [PTR(CStructAVector), PTR(CStructAMatrix), c_uint])
init_pointer_avector = get_func('init_pointer_avector', PTR(CStructAVector), [PTR(CStructAVector), PTR(field), c_uint])
uninit_avector = get_func('uninit_avector', None, [PTR(CStructAVector)])
new_avector = get_func('new_avector', PTR(CStructAVector), [c_uint])
new_sub_avector = get_func('new_sub_avector', PTR(CStructAVector), [PTR(CStructAVector), c_uint, c_uint])
new_zero_avector = get_func('new_zero_avector', PTR(CStructAVector), [c_uint])
new_pointer_avector = get_func('new_pointer_avector', PTR(CStructAVector), [PTR(field), c_uint])
del_avector = get_func('del_avector', None, [PTR(CStructAVector)])
resize_avector = get_func('resize_avector', None, [PTR(CStructAVector), c_uint])
shrink_avector = get_func('shrink_avector', None, [PTR(CStructAVector), c_uint])
getactives_avector = get_func('getactives_avector', c_uint, [])
getsize_avector = get_func('getsize_avector', c_size_t, [PTR(CStructAVector)])
getsize_heap_avector = get_func('getsize_heap_avector', c_size_t, [PTR(CStructAVector)])
from ctypes import POINTER as PTR
from ctypes import c_uint
from h2libpy.lib.util.helper import get_func
from h2libpy.lib.util.structs import CStructPatEntry, CStructSparsePattern
# ------------------------
CStructSparsePattern._fields_ = [
('rows', c_uint),
('cols', c_uint),
('row', PTR(PTR(CStructPatEntry))),
]
CStructPatEntry._fields_ = [('row', c_uint), ('col', c_uint),
('next', PTR(CStructPatEntry))]
# ------------------------
new_sparsepattern = get_func('new_sparsepattern', PTR(CStructSparsePattern),
[c_uint, c_uint])
del_sparsepattern = get_func('del_sparsepattern', None,
[PTR(CStructSparsePattern)])
clear_sparsepattern = get_func('clear_sparsepattern', None,
[PTR(CStructSparsePattern)])
addnz_sparsepattern = get_func('addnz_sparsepattern', None,
[PTR(CStructSparsePattern), c_uint, c_uint])
print_sparsepattern = get_func('print_sparsepattern', None,
[PTR(CStructSparsePattern)])
# ------------------------
CStructClusterGeometry._fields_ = [
('dim', c_uint),
('nidx', c_uint),
('x', PTR(PTR(real))),
('smin', PTR(PTR(real))),
('smax', PTR(PTR(real))),
('w', PTR(real)),
('hmin', PTR(real)),
('hmax', PTR(real)),
('buf', PTR(real)),
]
# ------------------------
new_clustergeometry = get_func('new_clustergeometry',
PTR(CStructClusterGeometry), [c_uint, c_uint])
del_clustergeometry = get_func('del_clustergeometry', None,
[PTR(CStructClusterGeometry)])
update_point_bbox_clustergeometry = get_func(
'update_point_bbox_clustergeometry', None,
[PTR(CStructClusterGeometry), c_uint,
PTR(c_uint)])
update_support_bbox_cluster = get_func(
'update_support_bbox_cluster', None,
[PTR(CStructClusterGeometry),
PTR(CStructCluster)])
update_bbox_cluster = get_func('update_bbox_cluster', None,
[PTR(CStructCluster)])
CStructMacroSurface3d._fields_ = [
('vertices', c_uint),
('edges', c_uint),
('triangles', c_uint),
('x', PTR(real * 3)),
('e', PTR(c_uint * 2)),
('t', PTR(c_uint * 3)),
('s', PTR(c_uint * 3)),
('phi', CFuncPhi),
('phidata', c_void_p),
]
# ------------------------
new_macrosurface3d = get_func('new_macrosurface3d', PTR(CStructMacroSurface3d),
[c_uint, c_uint, c_uint])
del_macrosurface3d = get_func('del_macrosurface3d', None,
[PTR(CStructMacroSurface3d)])
new_sphere_macrosurface3d = get_func('new_sphere_macrosurface3d',
PTR(CStructMacroSurface3d), [])
new_parabolic_mirror_macrosurface3d = get_func(
'new_parabolic_mirror_macrosurface3d', PTR(CStructMacroSurface3d), [])
new_cuboid_macrosurface3d = get_func('new_cuboid_macrosurface3d',
PTR(CStructMacroSurface3d),
[real, real, real, real, real, real])
new_cube_macrosurface3d = get_func('new_cube_macrosurface3d',
PTR(CStructMacroSurface3d), [])
new_cylinder_macrosurface3d = get_func('new_cylinder_macrosurface3d',
PTR(CStructMacroSurface3d), [])
build_from_macrosurface3d_surface3d = get_func(
'build_from_macrosurface3d_surface3d', PTR(CStructSurface3d),
CStructRkMatrix)
# ------------------------
CStructRkMatrix._fields_ = [
('A', CStructAMatrix),
('B', CStructAMatrix),
('k', c_uint),
]
# ------------------------
init_rkmatrix = get_func('init_rkmatrix', PTR(CStructRkMatrix), [PTR(CStructRkMatrix), c_uint, c_uint, c_uint])
init_sub_rkmatrix = get_func('init_sub_rkmatrix', PTR(CStructRkMatrix), [PTR(CStructRkMatrix), PTR(CStructRkMatrix), c_uint, c_uint, c_uint, c_uint])
uninit_rkmatrix = get_func('uninit_rkmatrix', None, [PTR(CStructRkMatrix)])
new_rkmatrix = get_func('new_rkmatrix', PTR(CStructRkMatrix), [c_uint, c_uint, c_uint])
new_sub_rkmatrix = get_func('new_sub_rkmatrix', PTR(CStructRkMatrix), [PTR(CStructRkMatrix), c_uint, c_uint, c_uint, c_uint])
del_rkmatrix = get_func('del_rkmatrix', None, [PTR(CStructRkMatrix)])
setrank_rkmatrix = get_func('setrank_rkmatrix', None, [PTR(CStructRkMatrix), c_uint])
resize_rkmatrix = get_func('resize_rkmatrix', None, [PTR(CStructRkMatrix), c_uint, c_uint, c_uint])
getsize_rkmatrix = get_func('getsize_rkmatrix', c_size_t, [PTR(CStructRkMatrix)])
getsize_heap_rkmatrix = get_func('getsize_heap_rkmatrix', c_size_t, [PTR(CStructRkMatrix)])
clone_rkmatrix = get_func('clone_rkmatrix', PTR(CStructRkMatrix), [PTR(CStructRkMatrix)])
copy_rkmatrix = get_func('copy_rkmatrix', None, [c_bool, PTR(CStructRkMatrix), PTR(CStructRkMatrix)])
scale_rkmatrix = get_func('scale_rkmatrix', None, [field, PTR(CStructRkMatrix)])
random_rkmatrix = get_func('random_rkmatrix', None, [PTR(CStructRkMatrix), c_uint])
addeval_rkmatrix_avector = get_func('addeval_rkmatrix_avector', None, [field, PTR(CStructRkMatrix), PTR(CStructAVector), PTR(CStructAVector)])
addevaltrans_rkmatrix_avector = get_func('addevaltrans_rkmatrix_avector', None, [field, PTR(CStructRkMatrix), PTR(CStructAVector), PTR(CStructAVector)])
from ctypes import POINTER as PTR
from ctypes import c_bool, c_uint
from h2libpy.lib.settings import real
from h2libpy.lib.util.helper import get_func
from h2libpy.lib.util.structs import CStructRealAVector, CStructTruncMode
# ------------------------
CStructTruncMode._fields_ = [('frobenius', c_bool), ('absolute', c_bool),
('blocks', c_bool), ('zeta_level', real),
('zeta_age', real)]
# ------------------------
new_truncmode = get_func('new_truncmode', PTR(CStructTruncMode), [])
del_truncmode = get_func('del_truncmode', None, [PTR(CStructTruncMode)])
new_releucl_truncmode = get_func('new_releucl_truncmode',
PTR(CStructTruncMode), [])
new_relfrob_truncmode = get_func('new_relfrob_truncmode',
PTR(CStructTruncMode), [])
new_blockreleucl_truncmode = get_func('new_blockreleucl_truncmode',
PTR(CStructTruncMode), [])
new_blockrelfrob_truncmode = get_func('new_blockrelfrob_truncmode',
PTR(CStructTruncMode), [])
new_abseucl_truncmode = get_func('new_abseucl_truncmode',
PTR(CStructTruncMode), [])
findrank_truncmode = get_func(
'findrank_truncmode', c_uint,
[PTR(CStructTruncMode), real,
PTR(CStructRealAVector)])
('rc', PTR(CStructCluster)),
('cc', PTR(CStructCluster)),
('r', PTR(CStructRkMatrix)),
('f', PTR(CStructAMatrix)),
('son', PTR(PTR(CStructHMatrix))),
('rsons', c_uint),
('csons', c_uint),
('refs', c_uint),
('desc', c_uint),
]
# ------------------------
init_hmatrix = get_func(
'init_hmatrix', PTR(CStructHMatrix),
[PTR(CStructHMatrix),
PTR(CStructCluster),
PTR(CStructCluster)])
uninit_hmatrix = get_func('uninit_hmatrix', None, [PTR(CStructHMatrix)])
new_hmatrix = get_func(
'new_hmatrix', PTR(CStructHMatrix),
[PTR(CStructCluster), PTR(CStructCluster)])
new_rk_hmatrix = get_func(
'new_rk_hmatrix', PTR(CStructHMatrix),
[PTR(CStructCluster), PTR(CStructCluster), c_uint])
new_full_hmatrix = get_func(
'new_full_hmatrix', PTR(CStructHMatrix),
[PTR(CStructCluster), PTR(CStructCluster)])
new_super_hmatrix = get_func(
'new_super_hmatrix', PTR(CStructHMatrix),
[PTR(CStructCluster),
from ctypes import POINTER as PTR
from ctypes import c_size_t, c_uint, c_void_p
from h2libpy.lib.settings import real
from h2libpy.lib.util.helper import get_func
from h2libpy.lib.util.structs import CStructRealAVector
# ------------------------
CStructRealAVector._fields_ = [('v', PTR(real)), ('dim', c_uint),
('owner', c_void_p)]
# ------------------------
init_realavector = get_func('init_realavector', PTR(CStructRealAVector),
[PTR(CStructRealAVector), c_uint])
init_sub_realavector = get_func(
'init_sub_realavector', PTR(CStructRealAVector),
[PTR(CStructRealAVector),
PTR(CStructRealAVector), c_uint, c_uint])
init_pointer_realavector = get_func(
'init_pointer_realavector', PTR(CStructRealAVector),
[PTR(CStructRealAVector), PTR(real), c_uint])
uninit_realavector = get_func('uninit_realavector', None,
[PTR(CStructRealAVector)])
new_realavector = get_func('new_realavector', PTR(CStructRealAVector),
[c_uint])
new_sub_realavector = get_func('new_sub_realavector', PTR(CStructRealAVector),
[PTR(CStructRealAVector), c_uint, c_uint])
new_pointer_realavector = get_func('new_pointer_realavector',
PTR(CStructRealAVector),
('directions', c_uint),
('k', PTR(c_uint)),
('koff', PTR(c_uint)),
('ktree', c_uint),
('kbranch', c_uint),
('V', PTR(CStructAMatrix)),
('E', PTR(PTR(CStructAMatrix))),
('sons', c_uint),
('son', PTR(PTR(CStructDClusterBasis))),
('dirson', PTR(PTR(c_uint))),
]
# ------------------------
init_dclusterbasis = get_func(
'init_dclusterbasis', PTR(CStructDClusterBasis),
[PTR(CStructDClusterBasis),
PTR(CStructDCluster)])
uninit_dclusterbasis = get_func('uninit_dclusterbasis', None,
[PTR(CStructDClusterBasis)])
new_dclusterbasis = get_func('new_dclusterbasis', PTR(CStructDClusterBasis),
[PTR(CStructDCluster)])
del_dclusterbasis = get_func('del_dclusterbasis', None,
[PTR(CStructDClusterBasis)])
update_dclusterbasis = get_func('update_dclusterbasis', None,
[PTR(CStructDClusterBasis)])
setrank_dclusterbasis = get_func('setrank_dclusterbasis', None,
[PTR(CStructDClusterBasis), c_uint, c_uint])
initmatrices_dclusterbasis = get_func('initmatrices_dclusterbasis', None,
[PTR(CStructDClusterBasis)])
findranks_dclusterbasis = get_func('findranks_dclusterbasis', None, [
c_uint,
CStructDBlock._fields_ = [
('rc', PTR(CStructDCluster)),
('cc', PTR(CStructDCluster)),
('rd', c_uint),
('cd', c_uint),
('adm', c_bool),
('rsons', c_uint),
('csons', c_uint),
('son', PTR(PTR(CStructDBlock))),
('desc', c_uint),
]
# ------------------------
new_dblock = get_func('new_dblock', PTR(CStructDBlock), [
PTR(CStructDCluster),
PTR(CStructDCluster), c_uint, c_uint, c_uint, c_uint
])
update_dblock = get_func('update_dblock', None, [PTR(CStructDBlock)])
del_dblock = get_func('del_dblock', None, [PTR(CStructDBlock)])
getactives_dblock = get_func('getactives_dblock', c_uint, [])
getsize_dblock = get_func('getsize_dblock', c_size_t, [PTR(CStructDBlock)])
getdepth_dblock = get_func('getdepth_dblock', c_uint, [PTR(CStructDBlock)])
# cairodraw_dblock
build_dblock = get_func(
'build_dblock', PTR(CStructDBlock),
[PTR(CStructDCluster),
PTR(CStructDCluster), CFuncAdmissible, c_void_p])
parabolic_admissibility = get_func('parabolic_admissibility', c_bool, [
PTR(CStructDCluster),
PTR(CStructDCluster), c_uint,
PTR(c_uint),
('bmax', PTR(real)),
('directions', c_uint),
('dir', PTR(PTR(real))),
('dirson', PTR(PTR(c_uint))),
('desc', c_uint),
]
CStructLevelDir._fields_ = [('depth', c_uint), ('dim', c_uint),
('maxdiam', PTR(real)), ('splits', PTR(c_uint)),
('directions', PTR(c_uint)),
('dir', PTR(PTR(PTR(real)))),
('dirmem', PTR(real))]
# ------------------------
new_dcluster = get_func('new_dcluster', PTR(CStructDCluster),
[c_uint, PTR(c_uint), c_uint, c_uint])
update_dcluster = get_func('update_dcluster', None, [PTR(CStructDCluster)])
del_dcluster = get_func('del_dcluster', None, [PTR(CStructDCluster)])
new_leveldir = get_func('new_leveldir', PTR(CStructLevelDir), [c_uint, c_uint])
del_leveldir = get_func('del_leveldir', None, [PTR(CStructLevelDir)])
buildfromcluster_dcluster = get_func('buildfromcluster_dcluster',
PTR(CStructDCluster),
[PTR(CStructCluster)])
diam_dcluster = get_func('diam_dcluster', real, [PTR(CStructDCluster)])
dist_dcluster = get_func(
'dist_dcluster', real,
[PTR(CStructDCluster), PTR(CStructDCluster)])
middist_dcluster = get_func(
'middist_dcluster', real,
[PTR(CStructDCluster), PTR(CStructDCluster)])
finddirection_dcluster = get_func(
# ------------------------
CStructUniform._fields_ = [
('rb', PTR(CStructClusterBasis)),
('cb', PTR(CStructClusterBasis)),
('S', CStructAMatrix),
('rnext', PTR(CStructUniform)),
('rprev', PTR(CStructUniform)),
('cnext', PTR(CStructUniform)),
('cprev', PTR(CStructUniform)),
]
# ------------------------
new_uniform = get_func('new_uniform', PTR(CStructUniform),
[PTR(CStructClusterBasis),
PTR(CStructClusterBasis)])
del_uniform = get_func('new_uniform', None, [PTR(CStructUniform)])
ref_row_uniform = get_func(
'ref_row_uniform', None,
[PTR(CStructUniform), PTR(CStructClusterBasis)])
ref_col_uniform = get_func(
'ref_col_uniform', None,
[PTR(CStructUniform), PTR(CStructClusterBasis)])
unref_row_uniform = get_func('unref_row_uniform', None, [PTR(CStructUniform)])
unref_col_uniform = get_func('unref_col_uniform', None, [PTR(CStructUniform)])
getsize_uniform = get_func('getsize_uniform', c_size_t, [PTR(CStructUniform)])
clear_uniform = get_func('clear_uniform', None, [PTR(CStructUniform)])
copy_uniform = get_func(
'copy_uniform', None,
[c_bool, PTR(CStructUniform),
('nco', PTR(PTR(CStructDClusterOperator))),
('nro', PTR(PTR(CStructDClusterOperator))),
('noro', PTR(PTR(CStructDClusterOperator))),
('noco', PTR(PTR(CStructDClusterOperator))),
('ncb', PTR(PTR(CStructDClusterBasis))),
('nrb', PTR(PTR(CStructDClusterBasis))),
('nb', PTR(PTR(CStructDBlock))),
('bem', PTR(CStructBem3d)),
('rows', c_bool),
('cblock', PTR(PTR(CStructAdmisBlock))),
('rblock', PTR(PTR(CStructAdmisBlock))),
]
# ------------------------------------
new_vert_list = get_func('new_vert_list', PTR(CStructVertList),
[PTR(CStructVertList)])
del_vert_list = get_func('del_vert_list', None, [PTR(CStructVertList)])
new_tri_list = get_func('new_tri_list', PTR(CStructTriList),
[PTR(CStructTriList)])
del_tri_list = get_func('del_tri_list', None, [PTR(CStructTriList)])
new_bem3d = get_func(
'new_bem3d', PTR(CStructBem3d),
[PTR(CStructSurface3d), CEnumBasisFunctionBem3d, CEnumBasisFunctionBem3d])
del_bem3d = get_func('del_bem3d', None, [PTR(CStructBem3d)])
build_bem3d_const_clustergeometry = get_func(
'build_bem3d_const_clustergeometry', PTR(CStructClusterGeometry),
[PTR(CStructBem3d), PTR(PTR(c_uint))])
build_bem3d_linear_clustergeometry = get_func(
'build_bem3d_linear_clustergeometry', PTR(CStructClusterGeometry),
[PTR(CStructBem3d), PTR(PTR(c_uint))])
('triangles', c_uint),
('x', PTR(real * 3)),
('e', PTR(c_uint * 2)),
('t', PTR(c_uint * 3)),
('s', PTR(c_uint * 3)),
('n', PTR(real * 3)),
('g', PTR(real)),
('hmin', real),
('hmax', real)
]
# ------------------------
new_surface3d = get_func('new_surface3d', PTR(CStructSurface3d), [c_uint, c_uint, c_uint])
prepare_surface3d = get_func('prepare_surface3d', None, [PTR(CStructSurface3d)])
del_surface3d = get_func('del_surface3d', None, [PTR(CStructSurface3d)])
getproperties_surface3d = get_func('getproperties_surface3d', None, [PTR(CStructSurface3d), PTR(real), PTR(real), PTR(real), PTR(real)])
print_surface3d = get_func('print_surface3d', None, [PTR(CStructSurface3d)])
check_surface3d = get_func('check_surface3d', c_uint, [PTR(CStructSurface3d)])
isclosed_surface3d = get_func('isclosed_surface3d', c_bool, [PTR(CStructSurface3d)])
isoriented_surface3d = get_func('isoriented_surface3d', c_bool, [PTR(CStructSurface3d)])
scale_surface3d = get_func('scale_surface3d', None, [PTR(CStructSurface3d), PTR(real), PTR(real)])
translate_surface3d = get_func('translate_surface3d', None, [PTR(CStructSurface3d), PTR(real)])
merge_surface3d = get_func('merge_surface3d', PTR(CStructSurface3d), [PTR(CStructSurface3d), PTR(CStructSurface3d)])
write_surface3d = get_func('write_surface3d', None, [PTR(CStructSurface3d), c_char_p])
read_surface3d = get_func('read_surface3d', PTR(CStructSurface3d), [c_char_p])
write_nc_surface3d = get_func('write_nc_surface3d', None, [PTR(CStructSurface3d), c_char_p])
read_nc_surface3d = get_func('read_nc_surface3d', PTR(CStructSurface3d), [c_char_p])
read_netgen_surface3d = get_func('read_netgen_surface3d', PTR(CStructSurface3d), [c_char_p])
from ctypes import POINTER as PTR
from ctypes import c_uint, c_void_p
from h2libpy.lib.bem3d import CEnumBasisFunctionBem3d
from h2libpy.lib.settings import field, real
from h2libpy.lib.util.helper import get_func
from h2libpy.lib.util.structs import CStructBem3d, CStructSurface3d
# ------------------------
new_slp_laplace_bem3d = get_func('new_slp_laplace_bem3d', PTR(CStructBem3d), [
PTR(CStructSurface3d), c_uint, c_uint, CEnumBasisFunctionBem3d,
CEnumBasisFunctionBem3d
])
new_dlp_laplace_bem3d = get_func('new_dlp_laplace_bem3d', PTR(CStructBem3d), [
PTR(CStructSurface3d), c_uint, c_uint, CEnumBasisFunctionBem3d,
CEnumBasisFunctionBem3d, field
])
new_adlp_laplace_bem3d = get_func(
'new_adlp_laplace_bem3d', PTR(CStructBem3d), [
PTR(CStructSurface3d), c_uint, c_uint, CEnumBasisFunctionBem3d,
CEnumBasisFunctionBem3d, field
])
del_laplace_bem3d = get_func('del_laplace_bem3d', None, [PTR(CStructBem3d)])
eval_dirichlet_linear_laplacebem3d = get_func(
'eval_dirichlet_linear_laplacebem3d', field,
[PTR(real), PTR(real), c_void_p])
eval_neumann_linear_laplacebem3d = get_func(
'eval_neumann_linear_laplacebem3d', field,
[PTR(real), PTR(real), c_void_p])
eval_dirichlet_quadratic_laplacebem3d = get_func(
CStructDClusterOperator._fields_ = [
('t', PTR(CStructDCluster)),
('krow', PTR(c_uint)),
('kcol', PTR(c_uint)),
('dir', c_uint),
('C', PTR(CStructAMatrix)),
('sons', c_uint),
('son', PTR(PTR(CStructDClusterOperator))),
('refs', c_uint),
]
# ------------------------
init_dclusteroperator = get_func('init_dclusteroperator', PTR(CStructDClusterOperator), [PTR(CStructDClusterOperator), PTR(CStructDCluster)])
init_leaf_dclusteroperator = get_func('init_leaf_dclusteroperator', PTR(CStructDClusterOperator), [PTR(CStructDClusterOperator), PTR(CStructDCluster)])
uninit_dclusteroperator = get_func('uninit_dclusteroperator', None, [PTR(CStructDClusterOperator)])
new_dclusteroperator = get_func('new_dclusteroperator', PTR(CStructDClusterOperator), [PTR(CStructDCluster)])
ref_dclusteroperator = get_func('ref_dclusteroperator', None, [PTR(PTR(CStructDClusterOperator)), PTR(CStructDClusterOperator)])
unref_dclusteroperator = get_func('unref_dclusteroperator', None, [PTR(CStructDClusterOperator)])
new_leaf_dclusteroperator = get_func('new_leaf_dclusteroperator', PTR(CStructDClusterOperator), [PTR(CStructDCluster)])
del_dclusteroperator = get_func('del_dclusteroperator', None, [PTR(CStructDClusterOperator)])
getactives_dclusteroperator = get_func('getactives_dclusteroperator', c_uint, [])
resize_dclusteroperator = get_func('resize_dclusteroperator', None, [PTR(CStructDClusterOperator), c_uint, c_uint, c_uint])
build_from_dcluster_dclusteroperator = get_func('build_from_dcluster_dclusteroperator', PTR(CStructDClusterOperator), [PTR(CStructDCluster)])
build_from_dclusterbasis_dclusteroperator = get_func('build_from_dclusterbasis_dclusteroperator', PTR(CStructDClusterOperator), [PTR(CStructDClusterBasis)])
merge_dclusteropertator = get_func('merge_dclusteropertator', None, [PTR(CStructDClusterOperator), PTR(CStructDClusterOperator)])
print_tree_dclusteroperator = get_func('print_tree_dclusteroperator', None, [PTR(CStructDClusterOperator)])
enumerate_dclusteroperator = get_func('enumerate_dclusteroperator', PTR(PTR(CStructDClusterOperator)), [PTR(CStructDCluster), PTR(CStructDClusterOperator)])
('son', PTR(PTR(CStructBlock))), ('rsons', c_uint),
('csons', c_uint), ('desc', c_uint)]
CStructBlockEntry._fields_ = [
('b', PTR(CStructBlock)),
('bname', c_uint),
('rname', c_uint),
('cname', c_uint),
('father', PTR(CStructBlockEntry)),
('next', PTR(CStructBlockEntry)),
]
# ------------------------
admissible_2_cluster = get_func(
'admissible_2_cluster', c_bool,
[PTR(CStructCluster), PTR(CStructCluster), c_void_p])
admissible_max_cluster = get_func(
'admissible_max_cluster', c_bool,
[PTR(CStructCluster), PTR(CStructCluster), c_void_p])
admissible_sphere_cluster = get_func(
'admissible_sphere_cluster', c_bool,
[PTR(CStructCluster), PTR(CStructCluster), c_void_p])
admissible_2_min_cluster = get_func(
'admissible_2_min_cluster', c_bool,
[PTR(CStructCluster), PTR(CStructCluster), c_void_p])
new_block = get_func(
'new_block', PTR(CStructBlock),
[PTR(CStructCluster),
PTR(CStructCluster), c_bool, c_uint, c_uint])
del_block = get_func('del_block', None, [PTR(CStructBlock)])
CStructDH2Matrix._fields_ = [
('rb', PTR(CStructDClusterBasis)),
('cb', PTR(CStructDClusterBasis)),
('u', PTR(CStructDUniform)),
('f', PTR(CStructAMatrix)),
('son', PTR(PTR(CStructDH2Matrix))),
('rsons', c_uint),
('csons', c_uint),
('desc', c_uint),
]
# ------------------------
new_dh2matrix = get_func(
'new_dh2matrix', PTR(CStructDH2Matrix),
[PTR(CStructDClusterBasis),
PTR(CStructDClusterBasis)])
new_uniform_dh2matrix = get_func(
'new_uniform_dh2matrix', PTR(CStructDH2Matrix),
[PTR(CStructDClusterBasis), c_uint,
PTR(CStructDClusterBasis), c_uint])
new_full_dh2matrix = get_func(
'new_full_dh2matrix', PTR(CStructDH2Matrix),
[PTR(CStructDClusterBasis),
PTR(CStructDClusterBasis)])
new_super_dh2matrix = get_func(
'new_super_dh2matrix', PTR(CStructDH2Matrix),
[PTR(CStructDClusterBasis),
PTR(CStructDClusterBasis), c_uint, c_uint])
update_dh2matrix = get_func('update_dh2matrix', None, [PTR(CStructDH2Matrix)])
del_dh2matrix = get_func('del_dh2matrix', None, [PTR(CStructDH2Matrix)])
CStructDClusterOperator, CStructDUniform)
# ------------------------
CStructDUniform._fields_ = [
('rb', PTR(CStructDClusterBasis)),
('cb', PTR(CStructDClusterBasis)),
('rd', c_uint),
('cd', c_uint),
('S', CStructAMatrix),
]
# ------------------------
new_duniform = get_func(
'new_duniform', PTR(CStructDUniform),
[PTR(CStructDClusterBasis), c_uint,
PTR(CStructDClusterBasis), c_uint])
del_duniform = get_func('del_duniform', None, [PTR(CStructDUniform)])
getsize_duniform = get_func('getsize_duniform', c_size_t,
[PTR(CStructDUniform)])
clear_duniform = get_func('clear_duniform', None, [PTR(CStructDUniform)])
copy_duniform = get_func(
'copy_duniform', None,
[PTR(CStructDUniform), PTR(CStructDUniform)])
fastaddeval_duniform_avector = get_func(
'fastaddeval_duniform_avector', None,
[field,
PTR(CStructDUniform),
PTR(CStructAVector),
PTR(CStructAVector)])
fastaddevaltrans_duniform_avector = get_func(
CStructClusterOperator._fields_ = [
('t', PTR(CStructCluster)),
('krow', c_uint),
('kcol', c_uint),
('C', CStructAMatrix),
('sons', c_uint),
('son', PTR(PTR(CStructClusterOperator))),
('refs', c_uint),
]
# ------------------------
init_clusteroperator = get_func('init_clusteroperator', PTR(CStructClusterOperator), [PTR(CStructClusterOperator), PTR(CStructCluster)])
init_leaf_clusteroperator = get_func('init_leaf_clusteroperator', PTR(CStructClusterOperator), [PTR(CStructClusterOperator), PTR(CStructCluster)])
uninit_clusteroperator = get_func('uninit_clusteroperator', None, [PTR(CStructClusterOperator)])
new_clusteroperator = get_func('new_clusteroperator', PTR(CStructClusterOperator), [PTR(CStructCluster)])
new_leaf_clusteroperator = get_func('new_leaf_clusteroperator', PTR(CStructClusterOperator), [PTR(CStructCluster)])
del_clusteroperator = get_func('del_clusteroperator', None, [PTR(CStructClusterOperator)])
removesons_clusteroperator = get_func('removesons_clusteroperator', None, [PTR(CStructClusterOperator)])
ref_clusteroperator = get_func('ref_clusteroperator', None, [PTR(PTR(CStructClusterOperator)), PTR(CStructClusterOperator)])
unref_clusteroperator = get_func('unref_clusteroperator', None, [PTR(CStructClusterOperator)])
update_clusteroperator = get_func('update_clusteroperator', None, [PTR(CStructClusterOperator)])
resize_clusteroperator = get_func('resize_clusteroperator', None, [PTR(CStructClusterOperator), c_uint, c_uint])
identify_son_clusterweight_clusteroperator = get_func('identify_son_clusterweight_clusteroperator', PTR(CStructClusterOperator), [PTR(CStructClusterOperator), PTR(CStructCluster)])
build_from_cluster_clusteroperator = get_func('build_from_cluster_clusteroperator', PTR(CStructClusterOperator), [PTR(CStructCluster)])
build_from_clusterbasis_clusteroperator = get_func('build_from_clusterbasis_clusteroperator', PTR(CStructClusterOperator), [PTR(CStructClusterBasis)])
getactives_clusteroperator = get_func('getactives_clusteroperator', c_uint, [])
getsize_clusteroperator = get_func('getsize_clusteroperator', c_size_t, [PTR(CStructClusterOperator)])
