(r)

Go to the source code of this file.

Functions
fla_blocksize_t *	FLA_Blocksize_create (dim_t b_s, dim_t b_d, dim_t b_c, dim_t b_z)

fla_blocksize_t *	FLA_Blocksize_create_copy (fla_blocksize_t *bp)

void	FLA_Blocksize_set (fla_blocksize_t *bp, dim_t b_s, dim_t b_d, dim_t b_c, dim_t b_z)

void	FLA_Blocksize_scale (fla_blocksize_t *bp, double factor)

void	FLA_Blocksize_free (fla_blocksize_t *bp)

dim_t	FLA_Blocksize_extract (FLA_Datatype dt, fla_blocksize_t *bp)

fla_blocksize_t *	FLA_Query_blocksizes (FLA_Dimension dim)

dim_t	FLA_Query_blocksize (FLA_Datatype dt, FLA_Dimension dim)

dim_t	FLA_Determine_blocksize (FLA_Obj A_unproc, FLA_Quadrant to_dir, fla_blocksize_t *cntl_blocksizes)

dim_t	FLA_determine_matrix_size (FLA_Obj A_unproc, FLA_Quadrant to_dir)

unsigned int	FLA_Check_error_level (void)

unsigned int	FLA_Check_error_level_set (unsigned int level)

FLA_Error	FLA_Check_error_code_helper (int code, char *file, int line)

FLA_Error	FLA_Check_valid_side (FLA_Side side)

FLA_Error	FLA_Check_valid_uplo (FLA_Uplo uplo)

FLA_Error	FLA_Check_valid_trans (FLA_Trans trans)

FLA_Error	FLA_Check_valid_diag (FLA_Diag diag)

FLA_Error	FLA_Check_valid_conj (FLA_Conj conj)

FLA_Error	FLA_Check_valid_direct (FLA_Conj direct)

FLA_Error	FLA_Check_valid_storev (FLA_Conj storev)

FLA_Error	FLA_Check_valid_inverse (FLA_Inv inv)

FLA_Error	FLA_Check_valid_datatype (FLA_Datatype datatype)

FLA_Error	FLA_Check_valid_object_datatype (FLA_Obj A)

FLA_Error	FLA_Check_valid_evd_type (FLA_Evd_type evd_type)

FLA_Error	FLA_Check_valid_svd_type (FLA_Svd_type svd_type)

FLA_Error	FLA_Check_valid_svd_type_combination (FLA_Svd_type svd_type_u, FLA_Svd_type svd_type_v)

FLA_Error	FLA_Check_valid_svd_type_and_trans_combination (FLA_Svd_type svd_type_u, FLA_Trans transu, FLA_Svd_type svd_type_v, FLA_Trans transv)

FLA_Error	FLA_Check_floating_datatype (FLA_Datatype datatype)

FLA_Error	FLA_Check_int_datatype (FLA_Datatype datatype)

FLA_Error	FLA_Check_real_datatype (FLA_Datatype datatype)

FLA_Error	FLA_Check_complex_datatype (FLA_Datatype datatype)

FLA_Error	FLA_Check_floating_object (FLA_Obj A)

FLA_Error	FLA_Check_int_object (FLA_Obj A)

FLA_Error	FLA_Check_real_object (FLA_Obj A)

FLA_Error	FLA_Check_comparable_object (FLA_Obj A)

FLA_Error	FLA_Check_complex_object (FLA_Obj A)

FLA_Error	FLA_Check_consistent_datatype (FLA_Datatype datatype, FLA_Obj A)

FLA_Error	FLA_Check_consistent_object_datatype (FLA_Obj A, FLA_Obj B)

FLA_Error	FLA_Check_identical_object_precision (FLA_Obj A, FLA_Obj B)

FLA_Error	FLA_Check_square (FLA_Obj A)

FLA_Error	FLA_Check_if_scalar (FLA_Obj A)

FLA_Error	FLA_Check_if_vector (FLA_Obj A)

FLA_Error	FLA_Check_conformal_dims (FLA_Trans trans, FLA_Obj A, FLA_Obj B)

FLA_Error	FLA_Check_matrix_matrix_dims (FLA_Trans transa, FLA_Trans transb, FLA_Obj A, FLA_Obj B, FLA_Obj C)

FLA_Error	FLA_Check_matrix_vector_dims (FLA_Trans trans, FLA_Obj A, FLA_Obj x, FLA_Obj y)

FLA_Error	FLA_Check_equal_vector_dims (FLA_Obj x, FLA_Obj y)

FLA_Error	FLA_Check_conj1_trans_and_datatype (FLA_Trans trans, FLA_Obj A)

FLA_Error	FLA_Check_hess_indices (FLA_Obj A, int ilo, int ihi)

FLA_Error	FLA_Check_null_pointer (void *ptr)

FLA_Error	FLA_Check_object_dims (FLA_Trans trans, dim_t m, dim_t n, FLA_Obj A)

FLA_Error	FLA_Check_valid_pivot_type (FLA_Pivot_type ptype)

FLA_Error	FLA_Check_malloc_pointer (void *ptr)

FLA_Error	FLA_Check_base_buffer_mismatch (FLA_Obj A, FLA_Obj B)

FLA_Error	FLA_Check_adjacent_objects_2x2 (FLA_Obj A11, FLA_Obj A12, FLA_Obj A21, FLA_Obj A22)

FLA_Error	FLA_Check_adjacent_objects_2x1 (FLA_Obj AT, FLA_Obj AB)

FLA_Error	FLA_Check_adjacent_objects_1x2 (FLA_Obj AL, FLA_Obj AR)

FLA_Error	FLA_Check_blocksize_value (dim_t b)

FLA_Error	FLA_Check_blocksize_object (FLA_Datatype datatype, fla_blocksize_t *bp)

FLA_Error	FLA_Check_file_descriptor (int fd)

FLA_Error	FLA_Check_lseek_result (int requested_offset, int lseek_r_val)

FLA_Error	FLA_Check_close_result (int close_r_val)

FLA_Error	FLA_Check_unlink_result (int unlink_r_val)

FLA_Error	FLA_Check_read_result (int requested_size, int read_r_val)

FLA_Error	FLA_Check_write_result (int requested_size, int write_r_val)

FLA_Error	FLA_Check_valid_quadrant (FLA_Quadrant quad)

FLA_Error	FLA_Check_vector_dim_min (FLA_Obj x, dim_t min_dim)

FLA_Error	FLA_Check_pthread_create_result (int pthread_create_r_val)

FLA_Error	FLA_Check_pthread_join_result (int pthread_join_r_val)

FLA_Error	FLA_Check_valid_isgn_value (FLA_Obj isgn)

FLA_Error	FLA_Check_sylv_matrix_dims (FLA_Obj A, FLA_Obj B, FLA_Obj C)

FLA_Error	FLA_Check_chol_failure (FLA_Error r_val)

FLA_Error	FLA_Check_valid_elemtype (FLA_Elemtype elemtype)

FLA_Error	FLA_Check_posix_memalign_failure (int r_val)

FLA_Error	FLA_Check_submatrix_dims_and_offset (dim_t m, dim_t n, dim_t i, dim_t j, FLA_Obj A)

FLA_Error	FLA_Check_object_scalar_elemtype (FLA_Obj A)

FLA_Error	FLA_Check_object_matrix_elemtype (FLA_Obj A)

FLA_Error	FLA_Check_num_threads (unsigned int n_threads)

FLA_Error	FLA_Check_conj_and_datatype (FLA_Conj conj, FLA_Obj A)

FLA_Error	FLA_Check_valid_complex_trans (FLA_Trans trans)

FLA_Error	FLA_Check_valid_real_trans (FLA_Trans trans)

FLA_Error	FLA_Check_valid_blas_trans (FLA_Trans trans)

FLA_Error	FLA_Check_nonconstant_datatype (FLA_Datatype datatype)

FLA_Error	FLA_Check_nonconstant_object (FLA_Obj A)

FLA_Error	FLA_Check_identical_object_datatype (FLA_Obj A, FLA_Obj B)

FLA_Error	FLA_Check_divide_by_zero (FLA_Obj alpha)

FLA_Error	FLA_Check_identical_object_elemtype (FLA_Obj A, FLA_Obj B)

FLA_Error	FLA_Check_pivot_index_range (FLA_Obj p, dim_t k1, dim_t k2)

FLA_Error	FLA_Check_householder_panel_dims (FLA_Obj A, FLA_Obj T)

FLA_Error	FLA_Check_object_length_equals (FLA_Obj A, dim_t m)

FLA_Error	FLA_Check_object_width_equals (FLA_Obj A, dim_t n)

FLA_Error	FLA_Check_object_length_min (FLA_Obj A, dim_t m)

FLA_Error	FLA_Check_object_width_min (FLA_Obj A, dim_t n)

FLA_Error	FLA_Check_valid_error_level (unsigned int level)

FLA_Error	FLA_Check_attempted_repart_2x2 (FLA_Obj A_quad, dim_t b_m, dim_t b_n)

FLA_Error	FLA_Check_attempted_repart_2x1 (FLA_Obj A_side, dim_t b_m)

FLA_Error	FLA_Check_attempted_repart_1x2 (FLA_Obj A_side, dim_t b_n)

FLA_Error	FLA_Check_valid_leftright_side (FLA_Side side)

FLA_Error	FLA_Check_valid_topbottom_side (FLA_Side side)

FLA_Error	FLA_Check_matrix_strides (dim_t m, dim_t n, dim_t rs, dim_t cs)

FLA_Error	FLA_Check_vector_dim (FLA_Obj x, dim_t expected_length)

FLA_Error	FLA_Check_row_vector (FLA_Obj x)

FLA_Error	FLA_Check_col_vector (FLA_Obj x)

FLA_Error	FLA_Check_valid_machval (FLA_Machval val)

FLA_Error	FLA_Check_valid_diag_offset (FLA_Obj A, FLA_Diag_off offset)

FLA_Error	FLA_Check_col_storage (FLA_Obj A)

FLA_Error	FLA_Check_row_storage (FLA_Obj A)

char *	FLA_Error_string_for_code (int code)

void	FLA_Error_messages_init (void)

void	FLA_Print_message (char str, char file, int line)

void	FLA_Abort (void)

void	FLA_Init (void)

void	FLA_Finalize (void)

FLA_Bool	FLA_Initialized (void)

void	FLA_Init_safe (FLA_Error *init_result)

void	FLA_Finalize_safe (FLA_Error init_result)

void	FLA_Init_constants (void)

void	FLA_Finalize_constants (void)

void	FLA_Init_numerical_constants (void)

void	FLA_Finalize_numerical_constants (void)

void	FLA_Lock_init (FLA_Lock *fla_lock_ptr)

void	FLA_Lock_destroy (FLA_Lock *fla_lock_ptr)

void	FLA_Lock_acquire (FLA_Lock *fla_lock_ptr)

void	FLA_Lock_release (FLA_Lock *fla_lock_ptr)

void	FLA_Memory_leak_counter_init (void)

void	FLA_Memory_leak_counter_finalize (void)

FLA_Bool	FLA_Memory_leak_counter_status (void)

FLA_Bool	FLA_Memory_leak_counter_set (FLA_Bool new_status)

void *	FLA_malloc (size_t size)

void *	FLA_realloc (void *old_ptr, size_t size)

void	FLA_free (void *ptr)

FLA_Error	FLA_Obj_copy_view (FLA_Obj A, FLA_Obj *B)

void	FLA_Obj_extract_real_scalar (FLA_Obj alpha, double *alpha_value)

void	FLA_Obj_extract_complex_scalar (FLA_Obj alpha, dcomplex *alpha_value)

void	FLA_Obj_extract_real_part (FLA_Obj alpha, FLA_Obj beta)

void	FLA_Obj_extract_imag_part (FLA_Obj alpha, FLA_Obj beta)

void	FLA_Obj_set_real_part (FLA_Obj alpha, FLA_Obj beta)

void	FLA_Obj_set_imag_part (FLA_Obj alpha, FLA_Obj beta)

FLA_Error	FLA_Obj_show (char s1, FLA_Obj A, char format, char *s2)

FLA_Error	FLA_Obj_fshow (FILE file, char s1, FLA_Obj A, char format, char s2)

FLA_Error	FLA_Obj_copy_view_check (FLA_Obj A, FLA_Obj *B)

FLA_Error	FLA_Obj_extract_real_scalar_check (FLA_Obj alpha, double *alpha_value)

FLA_Error	FLA_Obj_extract_complex_scalar_check (FLA_Obj alpha, dcomplex *alpha_value)

FLA_Error	FLA_Obj_extract_real_part_check (FLA_Obj alpha, FLA_Obj beta)

FLA_Error	FLA_Obj_extract_imag_part_check (FLA_Obj alpha, FLA_Obj beta)

FLA_Error	FLA_Obj_set_real_part_check (FLA_Obj alpha, FLA_Obj beta)

FLA_Error	FLA_Obj_set_imag_part_check (FLA_Obj alpha, FLA_Obj beta)

FLA_Error	FLA_Obj_show_check (char s1, FLA_Obj obj, char format, char *s2)

FLA_Error	FLA_Obj_fshow_check (FILE file, char s1, FLA_Obj obj, char format, char s2)

FLA_Error	FLA_Copy_buffer_to_object (FLA_Trans trans, dim_t m, dim_t n, void *buffer, dim_t rs, dim_t cs, dim_t i, dim_t j, FLA_Obj obj)

FLA_Error	FLA_Copy_object_to_buffer (FLA_Trans trans, dim_t i, dim_t j, FLA_Obj obj, dim_t m, dim_t n, void *buffer, dim_t rs, dim_t cs)

FLA_Error	FLA_Copy_buffer_to_object_check (FLA_Trans trans, dim_t m, dim_t n, void *buffer, dim_t rs, dim_t cs, dim_t i, dim_t j, FLA_Obj obj)

FLA_Error	FLA_Copy_object_to_buffer_check (FLA_Trans trans, dim_t i, dim_t j, FLA_Obj obj, dim_t m, dim_t n, void *buffer, dim_t rs, dim_t cs)

FLA_Error	FLA_Axpy_buffer_to_object (FLA_Trans trans, FLA_Obj alpha, dim_t m, dim_t n, void *buffer, dim_t rs, dim_t cs, dim_t i, dim_t j, FLA_Obj C)

FLA_Error	FLA_Axpy_object_to_buffer (FLA_Trans trans, FLA_Obj alpha, dim_t i, dim_t j, FLA_Obj C, dim_t m, dim_t n, void *buffer, dim_t rs, dim_t cs)

FLA_Error	FLA_Axpy_buffer_to_object_check (FLA_Trans trans, FLA_Obj alpha, dim_t m, dim_t n, void *buffer, dim_t rs, dim_t cs, dim_t i, dim_t j, FLA_Obj C)

FLA_Error	FLA_Axpy_object_to_buffer_check (FLA_Trans trans, FLA_Obj alpha, dim_t i, dim_t j, FLA_Obj C, dim_t m, dim_t n, void *buffer, dim_t rs, dim_t cs)

void *	FLA_shmalloc (size_t size)

void	FLA_shfree (void *ptr)

FLA_Bool	FLA_is_owner (void)

FLA_Error	FLA_Obj_nullify (FLA_Obj *obj)

FLA_Error	FLA_Obj_create (FLA_Datatype datatype, dim_t m, dim_t n, dim_t rs, dim_t cs, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_ext (FLA_Datatype datatype, FLA_Elemtype elemtype, dim_t m, dim_t n, dim_t m_inner, dim_t n_inner, dim_t rs, dim_t cs, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_conf_to (FLA_Trans trans, FLA_Obj old, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_copy_of (FLA_Trans trans, FLA_Obj old, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_without_buffer (FLA_Datatype datatype, dim_t m, dim_t n, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_constant (double const_real, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_constant_ext (float const_s, double const_d, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_complex_constant (double const_real, double const_imag, FLA_Obj *obj)

FLA_Error	FLA_Obj_attach_buffer (void buffer, dim_t rs, dim_t cs, FLA_Obj obj)

FLA_Error	FLA_Obj_create_buffer (dim_t rs, dim_t cs, FLA_Obj *obj)

FLA_Error	FLA_Obj_free (FLA_Obj *obj)

FLA_Error	FLA_Obj_free_without_buffer (FLA_Obj *obj)

FLA_Error	FLA_Obj_free_buffer (FLA_Obj *obj)

dim_t	FLA_align_ldim (dim_t ldim, dim_t elem_size)

dim_t	FLA_compute_num_elem (dim_t elem_size, dim_t m, dim_t n, dim_t rs, dim_t cs)

void	FLA_adjust_strides (dim_t m, dim_t n, dim_t rs, dim_t cs)

FLA_Error	FLA_Obj_flip_base (FLA_Obj *obj)

FLA_Error	FLA_Obj_flip_view (FLA_Obj *obj)

FLA_Error	FLA_Obj_create_ext_check (FLA_Datatype datatype, FLA_Elemtype elemtype, dim_t m, dim_t n, dim_t m_inner, dim_t n_inner, dim_t rs, dim_t cs, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_conf_to_check (FLA_Trans trans, FLA_Obj obj_old, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_without_buffer_check (FLA_Datatype datatype, dim_t m, dim_t n, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_constant_check (double const_real, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_constant_ext_check (float const_s, double const_d, FLA_Obj *obj)

FLA_Error	FLA_Obj_create_complex_constant_check (double const_real, double const_imag, FLA_Obj *obj)

FLA_Error	FLA_Obj_attach_buffer_check (void buffer, dim_t rs, dim_t cs, FLA_Obj obj)

FLA_Error	FLA_Obj_create_buffer_check (dim_t rs, dim_t cs, FLA_Obj *obj)

FLA_Error	FLA_Obj_free_check (FLA_Obj *obj)

FLA_Error	FLA_Obj_free_without_buffer_check (FLA_Obj *obj)

FLA_Error	FLA_Obj_free_buffer_check (FLA_Obj *obj)

FLA_Error	FLA_Obj_create_buffer_task (dim_t rs, dim_t cs, FLA_Obj obj, void *cntl)

FLA_Error	FLA_Obj_free_buffer_task (FLA_Obj obj, void *cntl)

FLA_Datatype	FLA_Obj_datatype (FLA_Obj obj)

FLA_Datatype	FLA_Obj_datatype_proj_to_real (FLA_Obj A)

FLA_Datatype	FLA_Obj_datatype_proj_to_complex (FLA_Obj A)

FLA_Elemtype	FLA_Obj_elemtype (FLA_Obj obj)

dim_t	FLA_Obj_datatype_size (FLA_Datatype datatype)

dim_t	FLA_Obj_elem_size (FLA_Obj obj)

dim_t	FLA_Obj_length (FLA_Obj obj)

dim_t	FLA_Obj_width (FLA_Obj obj)

FLA_Uplo	FLA_Obj_structure (FLA_Obj obj)

dim_t	FLA_Obj_vector_dim (FLA_Obj obj)

dim_t	FLA_Obj_vector_inc (FLA_Obj obj)

dim_t	FLA_Obj_min_dim (FLA_Obj obj)

dim_t	FLA_Obj_max_dim (FLA_Obj obj)

dim_t	FLA_Obj_row_stride (FLA_Obj obj)

dim_t	FLA_Obj_col_stride (FLA_Obj obj)

dim_t	FLA_Obj_row_offset (FLA_Obj obj)

dim_t	FLA_Obj_col_offset (FLA_Obj obj)

dim_t	FLA_Obj_base_length (FLA_Obj obj)

dim_t	FLA_Obj_base_width (FLA_Obj obj)

dim_t	FLA_Obj_num_elem_alloc (FLA_Obj obj)

void *	FLA_Obj_base_buffer (FLA_Obj obj)

void *	FLA_Obj_buffer_at_view (FLA_Obj obj)

FLA_Bool	FLA_Obj_buffer_is_null (FLA_Obj obj)

FLA_Bool	FLA_Obj_is_int (FLA_Obj A)

FLA_Bool	FLA_Obj_is_floating_point (FLA_Obj A)

FLA_Bool	FLA_Obj_is_constant (FLA_Obj A)

FLA_Bool	FLA_Obj_is_real (FLA_Obj A)

FLA_Bool	FLA_Obj_is_complex (FLA_Obj A)

FLA_Bool	FLA_Obj_is_single_precision (FLA_Obj A)

FLA_Bool	FLA_Obj_is_double_precision (FLA_Obj A)

FLA_Bool	FLA_Obj_is_scalar (FLA_Obj A)

FLA_Bool	FLA_Obj_is_vector (FLA_Obj A)

FLA_Bool	FLA_Obj_has_zero_dim (FLA_Obj A)

FLA_Bool	FLA_Obj_is_row_major (FLA_Obj A)

FLA_Bool	FLA_Obj_is_col_major (FLA_Obj A)

FLA_Bool	FLA_Obj_is_conformal_to (FLA_Trans trans, FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_is (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_is_identical (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_is_overlapped (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_equals (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_gt (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_ge (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_lt (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_le (FLA_Obj A, FLA_Obj B)

void *	FLA_Submatrix_at (FLA_Datatype datatype, void *buffer, dim_t i, dim_t j, dim_t rs, dim_t cs)

FLA_Bool	FLA_Obj_has_nan (FLA_Obj A)

FLA_Error	FLA_Obj_datatype_check (FLA_Obj obj)

FLA_Error	FLA_Obj_datatype_proj_to_real_check (FLA_Obj obj)

FLA_Error	FLA_Obj_elemtype_check (FLA_Obj obj)

FLA_Error	FLA_Obj_datatype_size_check (FLA_Datatype datatype)

FLA_Error	FLA_Obj_elem_size_check (FLA_Obj obj)

FLA_Error	FLA_Obj_buffer_at_view_check (FLA_Obj obj)

FLA_Error	FLA_Obj_equals_check (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_gt_check (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_ge_check (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_lt_check (FLA_Obj A, FLA_Obj B)

FLA_Bool	FLA_Obj_le_check (FLA_Obj A, FLA_Obj B)

FLA_Error	FLA_Submatrix_at_check (FLA_Datatype datatype, void *buffer, dim_t i, dim_t j, dim_t rs, dim_t cs)

FLA_Error	FLA_Obj_has_nan_check (FLA_Obj A)

void	FLA_Param_map_flame_to_netlib_trans (FLA_Trans trans, void *blas_trans)

void	FLA_Param_map_flame_to_netlib_uplo (FLA_Uplo uplo, void *blas_uplo)

void	FLA_Param_map_flame_to_netlib_side (FLA_Uplo side, void *blas_side)

void	FLA_Param_map_flame_to_netlib_diag (FLA_Diag diag, void *blas_diag)

void	FLA_Param_map_flame_to_netlib_direct (FLA_Direct direct, void *lapack_direct)

void	FLA_Param_map_flame_to_netlib_storev (FLA_Store storev, void *lapack_storev)

void	FLA_Param_map_flame_to_netlib_evd_type (FLA_Evd_type evd_type, void *lapack_evd_type)

void	FLA_Param_map_flame_to_netlib_svd_type (FLA_Svd_type svd_type, void *lapack_svd_type)

void	FLA_Param_map_flame_to_netlib_machval (FLA_Machval machval, void *blas_machval)

void	FLA_Param_map_flame_to_blis_trans (FLA_Trans trans, trans1_t *blis_trans)

void	FLA_Param_map_flame_to_blis_conj (FLA_Conj conj, conj1_t *blis_conj)

void	FLA_Param_map_flame_to_blis_uplo (FLA_Uplo uplo, uplo1_t *blis_uplo)

void	FLA_Param_map_flame_to_blis_side (FLA_Uplo side, side1_t *blis_side)

void	FLA_Param_map_flame_to_blis_diag (FLA_Diag diag, diag1_t *blis_diag)

void	FLA_Param_map_blis_to_flame_trans (trans1_t trans, FLA_Trans *flame_trans)

void	FLA_Param_map_blis_to_flame_uplo (uplo1_t uplo, FLA_Uplo *flame_uplo)

void	FLA_Param_map_blis_to_flame_side (side1_t side, FLA_Side *flame_side)

void	FLA_Param_map_blis_to_flame_diag (diag1_t diag, FLA_Diag *flame_diag)

void	FLA_Param_map_char_to_flame_trans (char trans, FLA_Trans flame_trans)

void	FLA_Param_map_char_to_flame_uplo (char uplo, FLA_Uplo flame_uplo)

void	FLA_Param_map_char_to_flame_side (char side, FLA_Side flame_side)

void	FLA_Param_map_char_to_flame_diag (char diag, FLA_Diag flame_diag)

void	FLA_Param_map_char_to_flame_storev (char storev, FLA_Direct flame_storev)

void	FLA_Param_map_char_to_flame_direct (char direct, FLA_Direct flame_direct)

void	FLA_Param_map_char_to_flame_inv (char inv, FLA_Inv flame_inv)

void	FLA_Param_map_netlib_to_flame_trans (char trans, FLA_Trans flame_trans)

void	FLA_Param_map_netlib_to_flame_uplo (char uplo, FLA_Uplo flame_uplo)

void	FLA_Param_map_netlib_to_flame_side (char side, FLA_Side flame_side)

void	FLA_Param_map_netlib_to_flame_diag (char diag, FLA_Diag flame_diag)

void	FLA_Param_map_netlib_to_flame_inv (int itype, FLA_Inv flame_inv)

void	FLA_Param_map_netlib_to_flame_svd_type (char svd, FLA_Svd_type flame_svd)

FLA_Error	FLA_Part_2x2 (FLA_Obj A, FLA_Obj A11, FLA_Obj A12, FLA_Obj A21, FLA_Obj A22, dim_t mb, dim_t nb, FLA_Quadrant quadrant)

FLA_Error	FLA_Part_2x1 (FLA_Obj A, FLA_Obj A1, FLA_Obj A2, dim_t mb, FLA_Side side)

FLA_Error	FLA_Part_1x2 (FLA_Obj A, FLA_Obj A1, FLA_Obj A2, dim_t nb, FLA_Side side)

FLA_Error	FLA_Merge_2x2 (FLA_Obj A11, FLA_Obj A12, FLA_Obj A21, FLA_Obj A22, FLA_Obj *A)

FLA_Error	FLA_Merge_2x1 (FLA_Obj AT, FLA_Obj AB, FLA_Obj *A)

FLA_Error	FLA_Merge_1x2 (FLA_Obj AL, FLA_Obj AR, FLA_Obj *A)

FLA_Error	FLA_Repart_2x2_to_3x3 (FLA_Obj ATL, FLA_Obj ATR, FLA_Obj A00, FLA_Obj A01, FLA_Obj A02, FLA_Obj A10, FLA_Obj A11, FLA_Obj A12, FLA_Obj ABL, FLA_Obj ABR, FLA_Obj A20, FLA_Obj A21, FLA_Obj *A22, dim_t mb, dim_t nb, FLA_Quadrant quadrant)

FLA_Error	FLA_Repart_2x1_to_3x1 (FLA_Obj AT, FLA_Obj A0, FLA_Obj A1, FLA_Obj AB, FLA_Obj *A2, dim_t mb, FLA_Side side)

FLA_Error	FLA_Repart_1x2_to_1x3 (FLA_Obj AL, FLA_Obj AR, FLA_Obj A0, FLA_Obj A1, FLA_Obj *A2, dim_t nb, FLA_Side side)

FLA_Error	FLA_Cont_with_3x3_to_2x2 (FLA_Obj ATL, FLA_Obj ATR, FLA_Obj A00, FLA_Obj A01, FLA_Obj A02, FLA_Obj A10, FLA_Obj A11, FLA_Obj A12, FLA_Obj ABL, FLA_Obj ABR, FLA_Obj A20, FLA_Obj A21, FLA_Obj A22, FLA_Quadrant quadrant)

FLA_Error	FLA_Cont_with_3x1_to_2x1 (FLA_Obj AT, FLA_Obj A0, FLA_Obj A1, FLA_Obj AB, FLA_Obj A2, FLA_Side side)

FLA_Error	FLA_Cont_with_1x3_to_1x2 (FLA_Obj AL, FLA_Obj AR, FLA_Obj A0, FLA_Obj A1, FLA_Obj A2, FLA_Side side)

FLA_Error	FLA_Repart_3x3_to_5x5 (FLA_Obj ATL, FLA_Obj ATM, FLA_Obj ATR, FLA_Obj AML, FLA_Obj AMM, FLA_Obj AMR, FLA_Obj ABL, FLA_Obj ABM, FLA_Obj ABR, FLA_Obj A00, FLA_Obj A01, FLA_Obj A02, FLA_Obj A03, FLA_Obj A04, FLA_Obj A10, FLA_Obj A11, FLA_Obj A12, FLA_Obj A13, FLA_Obj A14, FLA_Obj A20, FLA_Obj A21, FLA_Obj A22, FLA_Obj A23, FLA_Obj A24, FLA_Obj A30, FLA_Obj A31, FLA_Obj A32, FLA_Obj A33, FLA_Obj A34, FLA_Obj A40, FLA_Obj A41, FLA_Obj A42, FLA_Obj A43, FLA_Obj *A44, dim_t b, FLA_Quadrant quadrant)

FLA_Error	FLA_Cont_with_5x5_to_3x3 (FLA_Obj ATL, FLA_Obj ATM, FLA_Obj ATR, FLA_Obj AML, FLA_Obj AMM, FLA_Obj AMR, FLA_Obj ABL, FLA_Obj ABM, FLA_Obj *ABR, FLA_Obj A00, FLA_Obj A01, FLA_Obj A02, FLA_Obj A03, FLA_Obj A04, FLA_Obj A10, FLA_Obj A11, FLA_Obj A12, FLA_Obj A13, FLA_Obj A14, FLA_Obj A20, FLA_Obj A21, FLA_Obj A22, FLA_Obj A23, FLA_Obj A24, FLA_Obj A30, FLA_Obj A31, FLA_Obj A32, FLA_Obj A33, FLA_Obj A34, FLA_Obj A40, FLA_Obj A41, FLA_Obj A42, FLA_Obj A43, FLA_Obj A44, FLA_Quadrant quadrant)

FLA_Error	FLA_Part_2x2_check (FLA_Obj A, FLA_Obj A11, FLA_Obj A12, FLA_Obj A21, FLA_Obj A22, dim_t mb, dim_t nb, FLA_Quadrant quadrant)

FLA_Error	FLA_Part_2x1_check (FLA_Obj A, FLA_Obj A1, FLA_Obj A2, dim_t mb, FLA_Side side)

FLA_Error	FLA_Part_1x2_check (FLA_Obj A, FLA_Obj A1, FLA_Obj A2, dim_t nb, FLA_Side side)

FLA_Error	FLA_Merge_2x2_check (FLA_Obj A11, FLA_Obj A12, FLA_Obj A21, FLA_Obj A22, FLA_Obj *A)

FLA_Error	FLA_Merge_2x1_check (FLA_Obj AT, FLA_Obj AB, FLA_Obj *A)

FLA_Error	FLA_Merge_1x2_check (FLA_Obj AL, FLA_Obj AR, FLA_Obj *A)

FLA_Error	FLA_Repart_2x2_to_3x3_check (FLA_Obj ATL, FLA_Obj ATR, FLA_Obj A00, FLA_Obj A01, FLA_Obj A02, FLA_Obj A10, FLA_Obj A11, FLA_Obj A12, FLA_Obj ABL, FLA_Obj ABR, FLA_Obj A20, FLA_Obj A21, FLA_Obj *A22, dim_t mb, dim_t nb, FLA_Quadrant quadrant)

FLA_Error	FLA_Repart_2x1_to_3x1_check (FLA_Obj AT, FLA_Obj A0, FLA_Obj A1, FLA_Obj AB, FLA_Obj *A2, dim_t mb, FLA_Side side)

FLA_Error	FLA_Repart_1x2_to_1x3_check (FLA_Obj AL, FLA_Obj AR, FLA_Obj A0, FLA_Obj A1, FLA_Obj *A2, dim_t nb, FLA_Side side)

FLA_Error	FLA_Cont_with_3x3_to_2x2_check (FLA_Obj ATL, FLA_Obj ATR, FLA_Obj A00, FLA_Obj A01, FLA_Obj A02, FLA_Obj A10, FLA_Obj A11, FLA_Obj A12, FLA_Obj ABL, FLA_Obj ABR, FLA_Obj A20, FLA_Obj A21, FLA_Obj A22, FLA_Quadrant quadrant)

FLA_Error	FLA_Cont_with_3x1_to_2x1_check (FLA_Obj AT, FLA_Obj A0, FLA_Obj A1, FLA_Obj AB, FLA_Obj A2, FLA_Side side)

FLA_Error	FLA_Cont_with_1x3_to_1x2_check (FLA_Obj AL, FLA_Obj AR, FLA_Obj A0, FLA_Obj A1, FLA_Obj A2, FLA_Side side)

Function Documentation

◆ FLA_Abort()

void FLA_Abort ( void )

{
    fprintf( stderr, "libflame: Aborting.\n");
    //raise( SIGABRT );
    abort();
}

Referenced by FLA_Bsvd_ext_opc_var1(), FLA_Bsvd_ext_opd_var1(), FLA_Bsvd_ext_opz_var1(), FLA_Bsvd_v_opc_var1(), FLA_Bsvd_v_opd_var1(), FLA_Bsvd_v_ops_var1(), FLA_Bsvd_v_opz_var1(), FLA_Check_error_code_helper(), FLA_Tevd_francis_n_opd_var1(), FLA_Tevd_francis_v_opd_var1(), FLA_Tevd_n_opz_var1(), FLA_Tevd_v_opd_var1(), FLA_Tevd_v_opd_var2(), FLA_Tevd_v_opz_var1(), FLA_Tevd_v_opz_var2(), FLASH_Apply_CAQ_UT_inc_create_workspace(), FLASH_Apply_pivots(), FLASH_Apply_Q_UT(), FLASH_Apply_Q_UT_create_workspace(), FLASH_Apply_Q_UT_inc_create_workspace(), FLASH_Apply_QUD_UT_inc_create_workspace(), FLASH_CAQR_UT_inc_create_hier_matrices(), FLASH_Eig_gest(), FLASH_FS_incpiv(), FLASH_LQ_UT(), FLASH_LQ_UT_create_hier_matrices(), FLASH_LU_incpiv(), FLASH_LU_incpiv_create_hier_matrices(), FLASH_LU_piv(), FLASH_QR_UT(), FLASH_QR_UT_create_hier_matrices(), FLASH_QR_UT_inc_create_hier_matrices(), and FLASH_UDdate_UT_inc_create_hier_matrices().

◆ FLA_adjust_strides()

void FLA_adjust_strides	(	dim_t	m,
		dim_t	n,
		dim_t *	rs,
		dim_t *	cs
	)

{
  // Check the strides, and modify them if needed.
  if ( *rs == 0 && *cs == 0 )
  {
    // Default values induce column-major storage, except when m == 1,
    // because we dont want both strides to be unit.
    if ( m == 1 && n > 1 )
    {
      *rs = n;
      *cs = 1;
    }
    else
    {
      *rs = 1;
      *cs = m;
    }
  }
  else if ( *rs == 1 && *cs == 1 )
  {
    // If both strides are unit, this is probably a "lazy" request for a
    // single vector (but could also be a request for a 1xn matrix in column-
    // major order or an mx1 matrix in row-major order). In libflame, we have
    // decided to "reserve" the case where rs == cs == 1 for scalars only, as
    // having unit strides can upset the BLAS error checking when attempting
    // to induce a row-major operation. Also, there is another special case
    // where rs == cs == 1 and one or both of m and n equal zero. This last
    // case is supported to allow creating "empty" objects.
 
    if ( m == 0 || n == 0 )
    {
      // Nothing needs to be done for the "empty" case where m and/or n
      // equal zero.
    }
    else if ( m == 1 && n == 1 )
    {
      // Nothing needs to be done for the scalar case where m == n == 1.
    }
    else if ( m > 1 && n == 1 )
    {
      // Set the column stride to indicate that this is a column vector stored
      // in column-major order. This is necessary because, in some cases, we
      // have to satisify the error checking in the underlying BLAS library,
      // which expects the leading dimension to be set to at least m, even if
      // it will never be used for indexing since it is a vector and thus only
      // has one column of data.
      *cs = m;
    }
    else if ( m == 1 && n > 1 )
    {
      // Set the row stride to indicate that this is a row vector stored
      // in row-major order.
      *rs = n;
    }
  }
}

Referenced by FLA_Obj_attach_buffer(), FLA_Obj_create_buffer(), and FLA_Obj_create_ext().

◆ FLA_align_ldim()

dim_t FLA_align_ldim	(	dim_t	ldim,
		dim_t	elem_size
	)

{
#ifdef FLA_ENABLE_MEMORY_ALIGNMENT
  #ifdef FLA_ENABLE_LDIM_ALIGNMENT
    // Increase ldim so that ( ldim * elem_size ) is a multiple of the desired
    // alignment.
    ldim = ( ( ldim * elem_size + FLA_MEMORY_ALIGNMENT_BOUNDARY - 1 ) / 
             FLA_MEMORY_ALIGNMENT_BOUNDARY ) *
           FLA_MEMORY_ALIGNMENT_BOUNDARY /
           elem_size;
  #endif
#endif
 
  return ldim;
}

Referenced by FLA_compute_num_elem().

◆ FLA_Axpy_buffer_to_object()

FLA_Error FLA_Axpy_buffer_to_object	(	FLA_Trans	trans,
		FLA_Obj	alpha,
		dim_t	m,
		dim_t	n,
		void *	buffer,
		dim_t	rs,
		dim_t	cs,
		dim_t	i,
		dim_t	j,
		FLA_Obj	C
	)

{
  FLA_Obj  X;
  FLA_Obj  YTL, YTR, 
           YBL, Yij;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Axpy_buffer_to_object_check( trans, alpha, m, n, X_buffer, rs, cs, i, j, Y );
 
  FLA_Part_2x2( Y,  &YTL, &YTR,
                    &YBL, &Yij,     i, j, FLA_TL );
 
  FLA_Obj_create_without_buffer( FLA_Obj_datatype( Y ), m, n, &X );
  FLA_Obj_attach_buffer( X_buffer, rs, cs, &X );
 
  FLA_Axpyt_external( trans, alpha, X, Yij );
 
  FLA_Obj_free_without_buffer( &X );
 
  return FLA_SUCCESS;
}

References FLA_Axpy_buffer_to_object_check(), FLA_Axpyt_external(), FLA_Check_error_level(), FLA_Obj_attach_buffer(), FLA_Obj_create_without_buffer(), FLA_Obj_datatype(), FLA_Obj_free_without_buffer(), FLA_Part_2x2(), and i.

◆ FLA_Axpy_buffer_to_object_check()

FLA_Error FLA_Axpy_buffer_to_object_check	(	FLA_Trans	trans,
		FLA_Obj	alpha,
		dim_t	m,
		dim_t	n,
		void *	buffer,
		dim_t	rs,
		dim_t	cs,
		dim_t	i,
		dim_t	j,
		FLA_Obj	C
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_real_trans( trans );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_floating_object( B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_consistent_object_datatype( B, alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A_buffer );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_object_dims( trans, m, n, B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_matrix_strides( m, n, rs, cs );
  FLA_Check_error_code( e_val );
 
  if ( trans == FLA_NO_TRANSPOSE )
  {
    e_val = FLA_Check_submatrix_dims_and_offset( m, n, i, j, B );
    FLA_Check_error_code( e_val );
  }
  else
  {
    e_val = FLA_Check_submatrix_dims_and_offset( n, m, i, j, B );
    FLA_Check_error_code( e_val );
  }
 
  e_val = FLA_Check_nonconstant_object( B );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_consistent_object_datatype(), FLA_Check_floating_object(), FLA_Check_if_scalar(), FLA_Check_matrix_strides(), FLA_Check_nonconstant_object(), FLA_Check_null_pointer(), FLA_Check_object_dims(), FLA_Check_submatrix_dims_and_offset(), FLA_Check_valid_real_trans(), and i.

Referenced by FLA_Axpy_buffer_to_object().

◆ FLA_Axpy_object_to_buffer()

FLA_Error FLA_Axpy_object_to_buffer	(	FLA_Trans	trans,
		FLA_Obj	alpha,
		dim_t	i,
		dim_t	j,
		FLA_Obj	C,
		dim_t	m,
		dim_t	n,
		void *	buffer,
		dim_t	rs,
		dim_t	cs
	)

{
  FLA_Obj  Y;
  FLA_Obj  XTL, XTR, 
           XBL, Xij;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Axpy_object_to_buffer_check( trans, alpha, i, j, X, m, n, Y_buffer, rs, cs );
 
  FLA_Part_2x2( X,  &XTL, &XTR,
                    &XBL, &Xij,     i, j, FLA_TL );
 
  FLA_Obj_create_without_buffer( FLA_Obj_datatype( X ), m, n, &Y );
  FLA_Obj_attach_buffer( Y_buffer, rs, cs, &Y );
 
  FLA_Axpyt_external( trans, alpha, Xij, Y );
 
  FLA_Obj_free_without_buffer( &Y );
 
  return FLA_SUCCESS;
}

References FLA_Axpy_object_to_buffer_check(), FLA_Axpyt_external(), FLA_Check_error_level(), FLA_Obj_attach_buffer(), FLA_Obj_create_without_buffer(), FLA_Obj_datatype(), FLA_Obj_free_without_buffer(), FLA_Part_2x2(), and i.

◆ FLA_Axpy_object_to_buffer_check()

FLA_Error FLA_Axpy_object_to_buffer_check	(	FLA_Trans	trans,
		FLA_Obj	alpha,
		dim_t	i,
		dim_t	j,
		FLA_Obj	C,
		dim_t	m,
		dim_t	n,
		void *	buffer,
		dim_t	rs,
		dim_t	cs
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_real_trans( trans );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_floating_object( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_consistent_object_datatype( A, alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( B_buffer );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_object_dims( trans, m, n, A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_matrix_strides( m, n, rs, cs );
  FLA_Check_error_code( e_val );
 
  if ( trans == FLA_NO_TRANSPOSE )
  {
    e_val = FLA_Check_submatrix_dims_and_offset( m, n, i, j, A );
    FLA_Check_error_code( e_val );
  }
  else
  {
    e_val = FLA_Check_submatrix_dims_and_offset( n, m, i, j, A );
    FLA_Check_error_code( e_val );
  }
 
  e_val = FLA_Check_nonconstant_object( A );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_consistent_object_datatype(), FLA_Check_floating_object(), FLA_Check_if_scalar(), FLA_Check_matrix_strides(), FLA_Check_nonconstant_object(), FLA_Check_null_pointer(), FLA_Check_object_dims(), FLA_Check_submatrix_dims_and_offset(), FLA_Check_valid_real_trans(), and i.

Referenced by FLA_Axpy_object_to_buffer().

◆ FLA_Blocksize_create()

fla_blocksize_t * FLA_Blocksize_create	(	dim_t	b_s,
		dim_t	b_d,
		dim_t	b_c,
		dim_t	b_z
	)

{
    fla_blocksize_t* bp;
    
    // Allocate memory for the blocksize structure.
    bp = ( fla_blocksize_t* ) FLA_malloc( sizeof(fla_blocksize_t) );
    
    // Assign the provided blocksize values into the corresponding fields.
    bp->s = b_s;
    bp->d = b_d;
    bp->c = b_c;
    bp->z = b_z;
    
    // Return a pointer to the structure.
    return bp;
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_malloc(), FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

◆ FLA_Blocksize_create_copy()

fla_blocksize_t * FLA_Blocksize_create_copy ( fla_blocksize_t * bp )

{
    fla_blocksize_t* bp_copy;
    FLA_Error        e_val;
    
    // Verify that the given blocksize pointer is valid.
    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    {
        e_val = FLA_Check_null_pointer( bp );
        FLA_Check_error_code( e_val );
    }
 
    // Allocate memory for the blocksize structure.
    bp_copy = ( fla_blocksize_t* ) FLA_malloc( sizeof(fla_blocksize_t) );
    
    // Assign the provided blocksize object's values into the corresponding
    // fields of the new object.
    bp_copy->s = bp->s;
    bp_copy->d = bp->d;
    bp_copy->c = bp->c;
    bp_copy->z = bp->z;
    
    // Return a pointer to the structure.
    return bp_copy;
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_Check_error_level(), FLA_Check_null_pointer(), FLA_malloc(), FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

Referenced by FLA_Chol_cntl_init(), FLA_LU_nopiv_cntl_init(), and FLA_LU_piv_cntl_init().

◆ FLA_Blocksize_extract()

dim_t FLA_Blocksize_extract	(	FLA_Datatype	dt,
		fla_blocksize_t *	bp
	)

{
    dim_t     b = 0;
    FLA_Error e_val;
 
    // Verify that the given blocksize pointer is valid.
    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    {
        e_val = FLA_Check_null_pointer( bp );
        FLA_Check_error_code( e_val );
    }
 
    if      ( dt == FLA_FLOAT )
        b = bp->s;
    else if ( dt == FLA_DOUBLE )
        b = bp->d;
    else if ( dt == FLA_COMPLEX )
        b = bp->c;
    else if ( dt == FLA_DOUBLE_COMPLEX )
        b = bp->z;
    
    // Return the blocksize corresponding with the datatype.
    return b;
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_Check_error_level(), FLA_Check_null_pointer(), FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

Referenced by FLA_Check_blocksize_object(), FLA_Determine_blocksize(), FLA_Trinv(), and FLA_Ttmm().

◆ FLA_Blocksize_free()

void FLA_Blocksize_free ( fla_blocksize_t * bp )

{
    FLA_free( bp );
}

References FLA_free().

◆ FLA_Blocksize_scale()

void FLA_Blocksize_scale	(	fla_blocksize_t *	bp,
		double	factor
	)

{
    FLA_Error e_val;
    
    // Verify that the given blocksize pointer is valid.
    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    {
        e_val = FLA_Check_null_pointer( bp );
        FLA_Check_error_code( e_val );
    }
    
    // Assign the provided blocksize values into the corresponding fields.
    bp->s = ( dim_t )( ( double ) bp->s * factor );
    bp->d = ( dim_t )( ( double ) bp->d * factor );
    bp->c = ( dim_t )( ( double ) bp->c * factor );
    bp->z = ( dim_t )( ( double ) bp->z * factor );
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_Check_error_level(), FLA_Check_null_pointer(), FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

Referenced by FLA_Apply_CAQ2_UT_cntl_init(), FLA_Apply_Q2_UT_cntl_init(), FLA_Apply_Q_UT_cntl_init(), FLA_Apply_QUD_UT_cntl_init(), FLA_Bidiag_UT_cntl_init(), FLA_CAQR2_UT_cntl_init(), FLA_Chol_cntl_init(), FLA_Hess_UT_cntl_init(), FLA_LQ_UT_cntl_init(), FLA_LU_nopiv_cntl_init(), FLA_LU_piv_cntl_init(), FLA_QR2_UT_cntl_init(), FLA_QR_UT_cntl_init(), FLA_Tridiag_UT_cntl_init(), and FLA_UDdate_UT_cntl_init().

◆ FLA_Blocksize_set()

void FLA_Blocksize_set	(	fla_blocksize_t *	bp,
		dim_t	b_s,
		dim_t	b_d,
		dim_t	b_c,
		dim_t	b_z
	)

{
    // Assign the provided blocksize values into the corresponding fields.
    if ( b_s != 0 ) bp->s = b_s;
    if ( b_d != 0 ) bp->d = b_d;
    if ( b_c != 0 ) bp->c = b_c;
    if ( b_z != 0 ) bp->z = b_z;
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

Referenced by FLASH_Apply_Q_UT().

◆ FLA_Check_adjacent_objects_1x2()

FLA_Error FLA_Check_adjacent_objects_1x2	(	FLA_Obj	AL,
		FLA_Obj	AR
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_length( AL ) != FLA_Obj_length( AR ) )
    e_val = FLA_ADJACENT_OBJECT_DIM_MISMATCH;
 
  if ( AR.offn != AL.offn + FLA_Obj_width( AL ) )
    e_val = FLA_OBJECTS_NOT_HORIZONTALLY_ADJ;
 
  if ( AL.offm != AR.offm )
    e_val = FLA_OBJECTS_NOT_HORIZONTALLY_ALIGNED;
 
  return e_val;
}

References FLA_Obj_length(), FLA_Obj_width(), FLA_Obj_view::offm, and FLA_Obj_view::offn.

Referenced by FLA_Merge_1x2_check().

◆ FLA_Check_adjacent_objects_2x1()

FLA_Error FLA_Check_adjacent_objects_2x1	(	FLA_Obj	AT,
		FLA_Obj	AB
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_width( AT ) != FLA_Obj_width( AB ) )
    e_val = FLA_ADJACENT_OBJECT_DIM_MISMATCH;
 
  if ( AB.offm != AT.offm + FLA_Obj_length( AT ) )
    e_val = FLA_OBJECTS_NOT_VERTICALLY_ADJ;
 
  if ( AB.offn != AT.offn )
    e_val = FLA_OBJECTS_NOT_VERTICALLY_ALIGNED;
 
  return e_val;
}

References FLA_Obj_length(), FLA_Obj_width(), FLA_Obj_view::offm, and FLA_Obj_view::offn.

Referenced by FLA_Merge_2x1_check().

◆ FLA_Check_adjacent_objects_2x2()

FLA_Error FLA_Check_adjacent_objects_2x2	(	FLA_Obj	A11,
		FLA_Obj	A12,
		FLA_Obj	A21,
		FLA_Obj	A22
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_length( ATL ) != FLA_Obj_length( ATR ) || 
       FLA_Obj_length( ABL ) != FLA_Obj_length( ABR ) ||
       FLA_Obj_width( ATL )  != FLA_Obj_width( ABL )  ||
       FLA_Obj_width( ATR )  != FLA_Obj_width( ABR ) )
    e_val = FLA_ADJACENT_OBJECT_DIM_MISMATCH;
 
  if ( ATL.offm != ABL.offm + FLA_Obj_length( ABL ) ||
       ATR.offm != ABR.offm + FLA_Obj_length( ABL ) )
    e_val = FLA_OBJECTS_NOT_VERTICALLY_ADJ;
 
  if ( ATL.offn != ABL.offn ||
       ATR.offn != ABR.offn )
    e_val = FLA_OBJECTS_NOT_VERTICALLY_ALIGNED;
 
  if ( ATL.offn != ATR.offn + FLA_Obj_width( ATR ) ||
       ABL.offn != ABR.offn + FLA_Obj_width( ATR ) )
    e_val = FLA_OBJECTS_NOT_HORIZONTALLY_ADJ;
 
  if ( ATL.offm != ATR.offm ||
       ABL.offm != ABR.offm )
    e_val = FLA_OBJECTS_NOT_HORIZONTALLY_ALIGNED;
 
  return e_val;
}

References FLA_Obj_length(), FLA_Obj_width(), FLA_Obj_view::offm, and FLA_Obj_view::offn.

Referenced by FLA_Merge_2x2_check().

◆ FLA_Check_attempted_repart_1x2()

FLA_Error FLA_Check_attempted_repart_1x2	(	FLA_Obj	A_side,
		dim_t	b_n
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( b_n > FLA_Obj_width( A_side ) )
    e_val = FLA_ATTEMPTED_OVER_REPART_1X2;
 
  return e_val;
}

References FLA_Obj_width().

Referenced by FLA_Repart_1x2_to_1x3_check().

◆ FLA_Check_attempted_repart_2x1()

FLA_Error FLA_Check_attempted_repart_2x1	(	FLA_Obj	A_side,
		dim_t	b_m
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( b_m > FLA_Obj_length( A_side ) )
    e_val = FLA_ATTEMPTED_OVER_REPART_2X1;
 
  return e_val;
}

References FLA_Obj_length().

Referenced by FLA_Repart_2x1_to_3x1_check().

◆ FLA_Check_attempted_repart_2x2()

FLA_Error FLA_Check_attempted_repart_2x2	(	FLA_Obj	A_quad,
		dim_t	b_m,
		dim_t	b_n
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( b_m > FLA_Obj_length( A_quad ) )
    e_val = FLA_ATTEMPTED_OVER_REPART_2X2;
 
  if ( b_n > FLA_Obj_width( A_quad ) )
    e_val = FLA_ATTEMPTED_OVER_REPART_2X2;
 
  return e_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

Referenced by FLA_Repart_2x2_to_3x3_check().

◆ FLA_Check_base_buffer_mismatch()

FLA_Error FLA_Check_base_buffer_mismatch	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( A.base->buffer != B.base->buffer )
    e_val = FLA_OBJECT_BASE_BUFFER_MISMATCH;
 
  return e_val;
}

References FLA_Obj_view::base, and FLA_Obj_struct::buffer.

Referenced by FLA_Merge_1x2_check(), FLA_Merge_2x1_check(), and FLA_Merge_2x2_check().

◆ FLA_Check_blocksize_object()

FLA_Error FLA_Check_blocksize_object	(	FLA_Datatype	datatype,
		fla_blocksize_t *	bp
	)

{
  FLA_Error e_val = FLA_SUCCESS;
  dim_t     b;
 
  b = FLA_Blocksize_extract( datatype, bp );
  if ( b <= 0 )
    e_val = FLA_INVALID_BLOCKSIZE_OBJ;
 
  return e_val;
}

References FLA_Blocksize_extract().

◆ FLA_Check_blocksize_value()

FLA_Error FLA_Check_blocksize_value ( dim_t b )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( b <= 0 )
    e_val = FLA_INVALID_BLOCKSIZE_VALUE;
 
  return e_val;
}

Referenced by FLA_Determine_blocksize().

◆ FLA_Check_chol_failure()

FLA_Error FLA_Check_chol_failure ( FLA_Error r_val )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( r_val > 0 )
    e_val = FLA_CHOL_FAILED_MATRIX_NOT_SPD;
 
  return e_val;
}

Referenced by FLA_SPDinv_internal().

◆ FLA_Check_close_result()

FLA_Error FLA_Check_close_result ( int close_r_val )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( close_r_val == -1 )
    e_val = FLA_CLOSE_RETURNED_ERROR;
 
  return e_val;
}

◆ FLA_Check_col_storage()

FLA_Error FLA_Check_col_storage ( FLA_Obj A )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_row_stride( A ) != 1 )
    e_val = FLA_EXPECTED_COL_STORAGE;
 
  return e_val;
}

References FLA_Obj_row_stride().

Referenced by FLA_Bidiag_check(), FLA_Hess_check(), FLA_Hevd_check(), FLA_Hevdd_check(), FLA_Hevdr_check(), FLA_LQ_check(), FLA_QR_check(), FLA_Svd_check(), FLA_Svd_ext_check(), and FLA_Tridiag_check().

◆ FLA_Check_col_vector()

FLA_Error FLA_Check_col_vector ( FLA_Obj x )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_width( x ) != 1 )
    e_val = FLA_EXPECTED_COL_VECTOR;
 
  return e_val;
}

References FLA_Obj_width().

Referenced by FLA_Accum_T_UT_check(), FLA_Bidiag_check(), FLA_LQ_check(), FLA_LU_piv_check(), FLA_LU_piv_solve_check(), FLA_QR_check(), FLA_Shift_pivots_to_check(), and FLA_Tridiag_check().

◆ FLA_Check_comparable_object()

FLA_Error FLA_Check_comparable_object ( FLA_Obj A )

{
  FLA_Error    e_val = FLA_SUCCESS;
  FLA_Datatype datatype;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( FLA_Check_int_datatype( datatype ) != FLA_SUCCESS &&
       FLA_Check_real_datatype( datatype ) != FLA_SUCCESS )
    e_val = FLA_OBJECT_NOT_COMPARABLE;
  
  return e_val;
}

References FLA_Check_int_datatype(), FLA_Check_real_datatype(), and FLA_Obj_datatype().

Referenced by FLA_Obj_ge_check(), FLA_Obj_gt_check(), FLA_Obj_le_check(), and FLA_Obj_lt_check().

◆ FLA_Check_complex_datatype()

FLA_Error FLA_Check_complex_datatype ( FLA_Datatype datatype )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( datatype != FLA_CONSTANT &&
       datatype != FLA_COMPLEX &&
       datatype != FLA_DOUBLE_COMPLEX )
    e_val = FLA_INVALID_COMPLEX_DATATYPE;
 
  return e_val;
}

Referenced by FLA_Check_complex_object().

◆ FLA_Check_complex_object()

FLA_Error FLA_Check_complex_object ( FLA_Obj A )

{
  FLA_Error    e_val = FLA_SUCCESS;
  FLA_Datatype datatype;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( FLA_Check_complex_datatype( datatype ) != FLA_SUCCESS )
    e_val = FLA_OBJECT_NOT_COMPLEX;
 
  return e_val;
}

References FLA_Check_complex_datatype(), and FLA_Obj_datatype().

Referenced by FLA_Apply_G_check(), FLA_Bsvd_check(), and FLA_Obj_extract_complex_scalar_check().

◆ FLA_Check_conformal_dims()

FLA_Error FLA_Check_conformal_dims	(	FLA_Trans	trans,
		FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( trans == FLA_NO_TRANSPOSE || trans == FLA_CONJ_NO_TRANSPOSE )
  {
    if ( FLA_Obj_length( A ) != FLA_Obj_length( B ) )
      e_val = FLA_NONCONFORMAL_DIMENSIONS;
 
    if ( FLA_Obj_width( A ) != FLA_Obj_width( B ) )
      e_val = FLA_NONCONFORMAL_DIMENSIONS;
  }
  else
  {
    if ( FLA_Obj_width( A ) != FLA_Obj_length( B ) )
      e_val = FLA_NONCONFORMAL_DIMENSIONS;
 
    if ( FLA_Obj_length( A ) != FLA_Obj_width( B ) )
      e_val = FLA_NONCONFORMAL_DIMENSIONS;
  }
 
  return e_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

◆ FLA_Check_conj1_trans_and_datatype()

FLA_Error FLA_Check_conj1_trans_and_datatype	(	FLA_Trans	trans,
		FLA_Obj	A
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( trans == FLA_CONJ_TRANSPOSE || trans == FLA_CONJ_NO_TRANSPOSE ){
    if ( FLA_Obj_is_complex( A ) == FALSE )
      e_val = FLA_INVALID_TRANS_GIVEN_DATATYPE;
  }
 
  return e_val;
}

References FLA_Obj_is_complex().

◆ FLA_Check_conj_and_datatype()

FLA_Error FLA_Check_conj_and_datatype	(	FLA_Conj	conj,
		FLA_Obj	A
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( conj == FLA_CONJUGATE ){
    if ( FLA_Obj_is_complex( A ) == FALSE )
      e_val = FLA_INVALID_CONJ_GIVEN_DATATYPE;
  }
 
  return e_val;
}

References FLA_Obj_is_complex().

◆ FLA_Check_consistent_datatype()

FLA_Error FLA_Check_consistent_datatype	(	FLA_Datatype	datatype,
		FLA_Obj	A
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_datatype( A ) != FLA_CONSTANT &&
                    datatype != FLA_CONSTANT )
    if ( FLA_Obj_datatype( A ) != datatype )
      e_val = FLA_INCONSISTENT_DATATYPES;
 
  return e_val;
}

References FLA_Obj_datatype().

◆ FLA_Check_consistent_object_datatype()

FLA_Error FLA_Check_consistent_object_datatype	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_datatype( A ) != FLA_CONSTANT &&
       FLA_Obj_datatype( B ) != FLA_CONSTANT )
    if ( FLA_Obj_datatype( A ) != FLA_Obj_datatype( B ) )
      e_val = FLA_INCONSISTENT_DATATYPES;
 
  return e_val;
}

References FLA_Obj_datatype().

Referenced by FLA_Accum_T_UT_check(), FLA_Axpy_buffer_to_object_check(), FLA_Axpy_check(), FLA_Axpy_object_to_buffer_check(), FLA_Axpyrt_check(), FLA_Axpys_check(), FLA_Axpyt_check(), FLA_Bidiag_UT_recover_tau_check(), FLA_Dot2cs_check(), FLA_Dot2s_check(), FLA_Dotcs_check(), FLA_Dots_check(), FLA_Fill_with_linear_dist_check(), FLA_Fill_with_random_dist_check(), FLA_Gemm_check(), FLA_Gemv_check(), FLA_Gemvc_check(), FLA_Ger_check(), FLA_Gerc_check(), FLA_Hemm_check(), FLA_Hemv_check(), FLA_Hemvc_check(), FLA_Her2_check(), FLA_Her2c_check(), FLA_Her2k_check(), FLA_Hess_UT_recover_tau_check(), FLA_Inv_scal_check(), FLA_Inv_scalc_check(), FLA_LQ_UT_recover_tau_check(), FLA_Obj_equals_check(), FLA_Obj_ge_check(), FLA_Obj_gt_check(), FLA_Obj_le_check(), FLA_Obj_lt_check(), FLA_QR_UT_recover_tau_check(), FLA_Scal_check(), FLA_Scalc_check(), FLA_Scale_diag_check(), FLA_Scalr_check(), FLA_Set_check(), FLA_Set_diag_check(), FLA_Setr_check(), FLA_Shift_diag_check(), FLA_Symm_check(), FLA_Symv_check(), FLA_Syr2_check(), FLA_Syr2k_check(), FLA_Syr_check(), FLA_Syrk_check(), FLA_Tridiag_UT_recover_tau_check(), FLA_Trmm_check(), FLA_Trmmsx_check(), FLA_Trmvsx_check(), FLA_Trsm_check(), FLA_Trsmsx_check(), FLA_Trsvsx_check(), FLASH_Axpy_buffer_to_hier(), and FLASH_Axpy_hier_to_buffer().

◆ FLA_Check_divide_by_zero()

FLA_Error FLA_Check_divide_by_zero ( FLA_Obj alpha )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_equals( alpha, FLA_ZERO ) )
    e_val = FLA_DIVIDE_BY_ZERO;
 
  return e_val;
}

References FLA_Obj_equals(), and FLA_ZERO.

Referenced by FLA_Inv_scal_check(), and FLA_Inv_scalc_check().

◆ FLA_Check_equal_vector_dims()

FLA_Error FLA_Check_equal_vector_dims	(	FLA_Obj	x,
		FLA_Obj	y
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_vector_dim( x ) != FLA_Obj_vector_dim( y ) )
    e_val = FLA_UNEQUAL_VECTOR_DIMS;
 
  return e_val;
}

References FLA_Obj_vector_dim().

Referenced by FLA_Apply_G_mx2_check(), FLA_Axpy_check(), FLA_Copy_check(), FLA_Dot2cs_check(), FLA_Dot2s_check(), FLA_Dot_check(), FLA_Dotc_check(), FLA_Dotcs_check(), FLA_Dots_check(), and FLA_Swap_check().

◆ FLA_Check_error_code_helper()

FLA_Error FLA_Check_error_code_helper	(	int	code,
		char *	file,
		int	line
	)

{
  if ( code == FLA_SUCCESS )
    return code;
 
  //if ( /* fatal error checking enabled */ )
  if ( TRUE )
  {
    if ( FLA_ERROR_CODE_MAX <= code && code <= FLA_ERROR_CODE_MIN )
    {
      FLA_Print_message( FLA_Error_string_for_code( code ),
                         file, line );
      FLA_Abort();
    }
    else
    {
      FLA_Print_message( FLA_Error_string_for_code( FLA_UNDEFINED_ERROR_CODE ),
                         file, line );
      FLA_Abort();
    }
  }
 
  return code;
}

References FLA_Abort(), FLA_Error_string_for_code(), and FLA_Print_message().

◆ FLA_Check_error_level()

unsigned int FLA_Check_error_level ( void )

{
  return fla_error_checking_level;
}

◆ FLA_Check_error_level_set()

unsigned int FLA_Check_error_level_set ( unsigned int level )

{
  FLA_Error    e_val;
  unsigned int old_level;
 
  e_val = FLA_Check_valid_error_level( new_level );
  FLA_Check_error_code( e_val );
 
  old_level = fla_error_checking_level;
 
  fla_error_checking_level = new_level;
 
  return old_level;
}

References FLA_Check_valid_error_level().

◆ FLA_Check_file_descriptor()

FLA_Error FLA_Check_file_descriptor ( int fd )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( fd == -1 )
    e_val = FLA_OPEN_RETURNED_ERROR;
 
  return e_val;
}

◆ FLA_Check_floating_datatype()

FLA_Error FLA_Check_floating_datatype ( FLA_Datatype datatype )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( datatype != FLA_CONSTANT &&
       datatype != FLA_FLOAT && 
       datatype != FLA_DOUBLE && 
       datatype != FLA_COMPLEX && 
       datatype != FLA_DOUBLE_COMPLEX )
    e_val = FLA_INVALID_FLOATING_DATATYPE;
  
  return e_val;
}

Referenced by FLA_Check_floating_object().

◆ FLA_Check_floating_object()

FLA_Error FLA_Check_floating_object ( FLA_Obj A )

{
  FLA_Error    e_val = FLA_SUCCESS;
  FLA_Datatype datatype;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( FLA_Check_floating_datatype( datatype ) != FLA_SUCCESS )
    e_val = FLA_OBJECT_NOT_FLOATING_POINT;
 
  return e_val;
}

References FLA_Check_floating_datatype(), and FLA_Obj_datatype().

◆ FLA_Check_hess_indices()

FLA_Error FLA_Check_hess_indices	(	FLA_Obj	A,
		int	ilo,
		int	ihi
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_width( A ) == 0 && ilo != 0 && ihi != -1 )
    e_val = FLA_INVALID_HESSENBERG_INDICES;
 
  if ( ilo < 0 || FLA_Obj_width( A ) - 1 < ilo )
    e_val = FLA_INVALID_HESSENBERG_INDICES;
 
  if ( ihi < 0 || FLA_Obj_width( A ) - 1 < ihi )
    e_val = FLA_INVALID_HESSENBERG_INDICES;
 
  if ( ihi < ilo )
    e_val = FLA_INVALID_HESSENBERG_INDICES;
 
  return e_val;
}

References FLA_Obj_width().

Referenced by FLA_Hess_check().

◆ FLA_Check_householder_panel_dims()

FLA_Error FLA_Check_householder_panel_dims	(	FLA_Obj	A,
		FLA_Obj	T
	)

{
  FLA_Error e_val = FLA_SUCCESS;
  dim_t     nb_alg;
 
  nb_alg = FLA_Query_blocksize( FLA_Obj_datatype( A ), FLA_DIMENSION_MIN );
 
  if ( FLA_Obj_length( T ) < nb_alg )
    e_val = FLA_HOUSEH_PANEL_MATRIX_TOO_SMALL;
 
  if ( FLA_Obj_width( T ) < FLA_Obj_min_dim( A ) )
    e_val = FLA_HOUSEH_PANEL_MATRIX_TOO_SMALL;
 
  return e_val;
}

References FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_min_dim(), FLA_Obj_width(), and FLA_Query_blocksize().

◆ FLA_Check_identical_object_datatype()

FLA_Error FLA_Check_identical_object_datatype	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_datatype( A ) != FLA_Obj_datatype( B ) )
    e_val = FLA_OBJECT_DATATYPES_NOT_EQUAL;
 
  return e_val;
}

References FLA_Obj_datatype().

Referenced by FLA_Apply_CAQ_UT_inc_check(), FLA_Apply_G_1x2_check(), FLA_Apply_G_mx2_check(), FLA_Apply_GTG_check(), FLA_Apply_H2_UT_check(), FLA_Apply_HUD_UT_check(), FLA_Apply_Q2_UT_check(), FLA_Apply_Q_check(), FLA_Apply_Q_UT_check(), FLA_Apply_Q_UT_inc_check(), FLA_Apply_QUD_UT_check(), FLA_Apply_QUD_UT_inc_check(), FLA_Axpy_check(), FLA_Axpyrt_check(), FLA_Axpys_check(), FLA_Axpyt_check(), FLA_Bidiag_check(), FLA_Bidiag_form_U_check(), FLA_Bidiag_form_V_check(), FLA_Bidiag_UT_check(), FLA_Bidiag_UT_extract_diagonals_check(), FLA_Bidiag_UT_form_U_check(), FLA_Bidiag_UT_form_V_check(), FLA_Bidiag_UT_realify_check(), FLA_Bidiag_UT_realify_diagonals_check(), FLA_Bsvd_check(), FLA_Bsvd_ext_check(), FLA_CAQR_UT_inc_check(), FLA_CAQR_UT_inc_solve_check(), FLA_Chol_solve_check(), FLA_Dot2cs_check(), FLA_Dot2s_check(), FLA_Dot_check(), FLA_Dotc_check(), FLA_Dotcs_check(), FLA_Dots_check(), FLA_FS_incpiv_check(), FLA_Gemm_check(), FLA_Gemv_check(), FLA_Gemvc_check(), FLA_Ger_check(), FLA_Gerc_check(), FLA_Givens1_check(), FLA_Givens2_check(), FLA_Hemm_check(), FLA_Hemv_check(), FLA_Hemvc_check(), FLA_Her2_check(), FLA_Her2c_check(), FLA_Her2k_check(), FLA_Her_check(), FLA_Herc_check(), FLA_Herk_check(), FLA_Hess_check(), FLA_Hess_UT_check(), FLA_Hevdr_check(), FLA_Househ2_UT_check(), FLA_Househ2s_UT_check(), FLA_Househ3UD_UT_check(), FLA_Introduce_bulge_check(), FLA_Inv_scal_elemwise_check(), FLA_LQ_check(), FLA_LQ_UT_check(), FLA_LQ_UT_form_Q_check(), FLA_LQ_UT_solve_check(), FLA_LU_incpiv_check(), FLA_LU_incpiv_solve_check(), FLA_LU_nopiv_solve_check(), FLA_LU_piv_solve_check(), FLA_Lyap_check(), FLA_Max_elemwise_diff_check(), FLA_QR2_UT_check(), FLA_QR_check(), FLA_QR_form_Q_check(), FLA_QR_UT_check(), FLA_QR_UT_form_Q_check(), FLA_QR_UT_inc_check(), FLA_QR_UT_inc_solve_check(), FLA_QR_UT_piv_check(), FLA_QR_UT_solve_check(), FLA_Scal_elemwise_check(), FLA_Sort_svd_check(), FLA_Svd_check(), FLA_Svd_ext_check(), FLA_Svdd_check(), FLA_Swap_check(), FLA_Swapt_check(), FLA_Sylv_check(), FLA_Symm_check(), FLA_Symv_check(), FLA_Syr2_check(), FLA_Syr2k_check(), FLA_Syr_check(), FLA_Syrk_check(), FLA_Tridiag_apply_Q_check(), FLA_Tridiag_check(), FLA_Tridiag_form_Q_check(), FLA_Tridiag_UT_check(), FLA_Tridiag_UT_extract_diagonals_check(), FLA_Tridiag_UT_form_Q_check(), FLA_Tridiag_UT_realify_check(), FLA_Tridiag_UT_realify_subdiagonal_check(), FLA_Trmm_check(), FLA_Trmmsx_check(), FLA_Trmv_check(), FLA_Trmvsx_check(), FLA_Trsm_check(), FLA_Trsmsx_check(), FLA_Trsv_check(), FLA_Trsvsx_check(), FLA_UDdate_UT_check(), FLA_UDdate_UT_inc_check(), FLA_UDdate_UT_inc_solve_check(), FLA_UDdate_UT_inc_update_rhs_check(), FLA_UDdate_UT_solve_check(), FLA_UDdate_UT_update_rhs_check(), and FLA_Wilkshift_tridiag_check().

◆ FLA_Check_identical_object_elemtype()

FLA_Error FLA_Check_identical_object_elemtype	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_elemtype( A ) != FLA_Obj_elemtype( B ) )
    e_val = FLA_OBJECT_ELEMTYPES_NOT_EQUAL;
 
  return e_val;
}

References FLA_Obj_elemtype().

◆ FLA_Check_identical_object_precision()

FLA_Error FLA_Check_identical_object_precision	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error    e_val = FLA_SUCCESS;
  FLA_Datatype datatype_A;
  FLA_Datatype datatype_B;
  dim_t        precision_A;
  dim_t        precision_B;
 
  datatype_A = FLA_Obj_datatype( A );
  datatype_B = FLA_Obj_datatype( B );
 
  if ( datatype_A == FLA_CONSTANT ||
       datatype_B == FLA_CONSTANT )
  {
    return FLA_SUCCESS;
  }
 
  if ( FLA_Check_floating_object( A ) != FLA_SUCCESS ||
       FLA_Check_floating_object( B ) != FLA_SUCCESS )
  {
    return FLA_OBJECT_NOT_FLOATING_POINT;
  }
 
  datatype_A = FLA_Obj_datatype( A );
  datatype_B = FLA_Obj_datatype( B );
 
  precision_A = FLA_Obj_datatype_size( datatype_A );
  precision_B = FLA_Obj_datatype_size( datatype_B );
 
  if ( FLA_Obj_is_complex( A ) )
    precision_A = precision_A / 2;
 
  if ( FLA_Obj_is_complex( B ) )
    precision_B = precision_B / 2;
 
  if ( precision_A != precision_B )
    e_val = FLA_INCONSISTENT_OBJECT_PRECISION;
 
  return e_val;
}

References FLA_Check_floating_object(), FLA_Obj_datatype(), FLA_Obj_datatype_size(), and FLA_Obj_is_complex().

Referenced by FLA_Apply_diag_matrix_check(), FLA_Apply_G_check(), FLA_Apply_G_mx2_check(), FLA_Asum_check(), FLA_Bidiag_UT_extract_real_diagonals_check(), FLA_Bidiag_UT_scale_diagonals_check(), FLA_Bsvd_check(), FLA_Fill_with_cluster_dist_check(), FLA_Fill_with_geometric_dist_check(), FLA_Fill_with_inverse_dist_check(), FLA_Fill_with_linear_dist_check(), FLA_Fill_with_logarithmic_dist_check(), FLA_Fill_with_random_dist_check(), FLA_Her2k_check(), FLA_Her_check(), FLA_Herc_check(), FLA_Herk_check(), FLA_Hevd_check(), FLA_Hevd_compute_scaling_check(), FLA_Hevdd_check(), FLA_Hevdr_check(), FLA_Inv_scal_check(), FLA_Inv_scalc_check(), FLA_Lyap_check(), FLA_Max_abs_value_check(), FLA_Max_abs_value_herm_check(), FLA_Norm1_check(), FLA_Norm_frob_check(), FLA_Norm_inf_check(), FLA_Nrm2_check(), FLA_Obj_extract_imag_part_check(), FLA_Obj_extract_real_part_check(), FLA_Obj_set_imag_part_check(), FLA_Obj_set_real_part_check(), FLA_QR_UT_piv_check(), FLA_QR_UT_piv_colnorm_check(), FLA_Scal_check(), FLA_Scalc_check(), FLA_Scale_diag_check(), FLA_Scalr_check(), FLA_Shift_diag_check(), FLA_Sort_evd_check(), FLA_Sort_svd_check(), FLA_Svd_check(), FLA_Svd_compute_scaling_check(), FLA_Svd_ext_check(), FLA_Svdd_check(), FLA_Sylv_check(), FLA_Tridiag_UT_extract_real_diagonals_check(), and FLA_Tridiag_UT_scale_diagonals_check().

◆ FLA_Check_if_scalar()

FLA_Error FLA_Check_if_scalar ( FLA_Obj A )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_length( A ) != 1 || FLA_Obj_width( A ) != 1 )
    e_val = FLA_OBJECT_NOT_SCALAR;
 
  return e_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

Referenced by FLA_Absolute_square_check(), FLA_Absolute_value_check(), FLA_Amax_check(), FLA_Apply_G_1x2_check(), FLA_Apply_G_mx2_check(), FLA_Apply_GTG_check(), FLA_Apply_H2_UT_check(), FLA_Apply_HUD_UT_check(), FLA_Asum_check(), FLA_Axpy_buffer_to_object_check(), FLA_Axpy_object_to_buffer_check(), FLA_Axpyrt_check(), FLA_Axpys_check(), FLA_Axpyt_check(), FLA_Bidiag_UT_scale_diagonals_check(), FLA_Dot2cs_check(), FLA_Dot2s_check(), FLA_Dotcs_check(), FLA_Dots_check(), FLA_Fill_with_cluster_dist_check(), FLA_Fill_with_geometric_dist_check(), FLA_Fill_with_inverse_dist_check(), FLA_Fill_with_linear_dist_check(), FLA_Fill_with_logarithmic_dist_check(), FLA_Fill_with_random_dist_check(), FLA_Gemm_check(), FLA_Gemv_check(), FLA_Gemvc_check(), FLA_Ger_check(), FLA_Gerc_check(), FLA_Givens1_check(), FLA_Givens2_check(), FLA_Hemm_check(), FLA_Hemv_check(), FLA_Hemvc_check(), FLA_Her2_check(), FLA_Her2c_check(), FLA_Her2k_check(), FLA_Her_check(), FLA_Herc_check(), FLA_Herk_check(), FLA_Hevd_compute_scaling_check(), FLA_Househ2_UT_check(), FLA_Househ2s_UT_check(), FLA_Househ3UD_UT_check(), FLA_Introduce_bulge_check(), FLA_Inv_scal_check(), FLA_Inv_scalc_check(), FLA_Lyap_check(), FLA_Max_abs_value_check(), FLA_Max_abs_value_herm_check(), FLA_Mult_add_check(), FLA_Norm1_check(), FLA_Norm_frob_check(), FLA_Norm_inf_check(), FLA_Nrm2_check(), FLA_Obj_extract_complex_scalar_check(), FLA_Obj_extract_real_scalar_check(), FLA_Obj_ge_check(), FLA_Obj_gt_check(), FLA_Obj_le_check(), FLA_Obj_lt_check(), FLA_Obj_set_imag_part_check(), FLA_Obj_set_real_part_check(), FLA_Pow_check(), FLA_QR_UT_piv_colnorm_check(), FLA_Scal_check(), FLA_Scalc_check(), FLA_Scale_diag_check(), FLA_Scalr_check(), FLA_Set_check(), FLA_Set_diag_check(), FLA_Shift_diag_check(), FLA_Sqrt_check(), FLA_Svd_compute_scaling_check(), FLA_Sylv_check(), FLA_Symm_check(), FLA_Symv_check(), FLA_Syr2_check(), FLA_Syr2k_check(), FLA_Syr_check(), FLA_Syrk_check(), FLA_Tridiag_UT_scale_diagonals_check(), FLA_Trmm_check(), FLA_Trmmsx_check(), FLA_Trmvsx_check(), FLA_Trsm_check(), FLA_Trsmsx_check(), FLA_Trsvsx_check(), FLA_Wilkshift_tridiag_check(), FLASH_Axpy_buffer_to_hier(), and FLASH_Axpy_hier_to_buffer().

◆ FLA_Check_if_vector()

FLA_Error FLA_Check_if_vector ( FLA_Obj A )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_length( A ) != 1 && FLA_Obj_width( A ) != 1 )
    e_val = FLA_OBJECT_NOT_VECTOR;
 
  return e_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

Referenced by FLA_Amax_check(), FLA_Apply_G_mx2_check(), FLA_Apply_H2_UT_check(), FLA_Apply_HUD_UT_check(), FLA_Apply_pivots_check(), FLA_Asum_check(), FLA_Bidiag_form_U_check(), FLA_Bidiag_form_V_check(), FLA_Bidiag_UT_extract_diagonals_check(), FLA_Bidiag_UT_extract_real_diagonals_check(), FLA_Bidiag_UT_realify_check(), FLA_Bidiag_UT_realify_diagonals_check(), FLA_Bidiag_UT_recover_tau_check(), FLA_Dot2cs_check(), FLA_Dot2s_check(), FLA_Dot_check(), FLA_Dotc_check(), FLA_Dotcs_check(), FLA_Dots_check(), FLA_Fill_with_cluster_dist_check(), FLA_Fill_with_geometric_dist_check(), FLA_Fill_with_inverse_dist_check(), FLA_Fill_with_linear_dist_check(), FLA_Fill_with_logarithmic_dist_check(), FLA_Fill_with_random_dist_check(), FLA_Form_perm_matrix_check(), FLA_Gemv_check(), FLA_Gemvc_check(), FLA_Ger_check(), FLA_Gerc_check(), FLA_Hemv_check(), FLA_Hemvc_check(), FLA_Her2_check(), FLA_Her2c_check(), FLA_Her_check(), FLA_Herc_check(), FLA_Hess_UT_recover_tau_check(), FLA_Househ2s_UT_check(), FLA_Invert_check(), FLA_LQ_UT_recover_tau_check(), FLA_Nrm2_check(), FLA_QR_form_Q_check(), FLA_QR_UT_recover_tau_check(), FLA_Symv_check(), FLA_Syr2_check(), FLA_Syr_check(), FLA_Tridiag_form_Q_check(), FLA_Tridiag_UT_extract_diagonals_check(), FLA_Tridiag_UT_extract_real_diagonals_check(), FLA_Tridiag_UT_realify_check(), FLA_Tridiag_UT_realify_subdiagonal_check(), FLA_Tridiag_UT_recover_tau_check(), FLA_Trmv_check(), FLA_Trmvsx_check(), FLA_Trsv_check(), and FLA_Trsvsx_check().

◆ FLA_Check_int_datatype()

FLA_Error FLA_Check_int_datatype ( FLA_Datatype datatype )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( datatype != FLA_CONSTANT &&
       datatype != FLA_INT )
    e_val = FLA_INVALID_INTEGER_DATATYPE;
 
  return e_val;
}

Referenced by FLA_Check_comparable_object(), and FLA_Check_int_object().

◆ FLA_Check_int_object()

FLA_Error FLA_Check_int_object ( FLA_Obj A )

{
  FLA_Error    e_val = FLA_SUCCESS;
  FLA_Datatype datatype;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( FLA_Check_int_datatype( datatype ) != FLA_SUCCESS )
    e_val = FLA_OBJECT_NOT_INTEGER;
 
  return e_val;
}

References FLA_Check_int_datatype(), and FLA_Obj_datatype().

Referenced by FLA_Amax_check(), FLA_Apply_pivots_check(), FLA_Fill_with_cluster_dist_check(), FLA_Form_perm_matrix_check(), FLA_FS_incpiv_check(), FLA_LU_incpiv_check(), FLA_LU_incpiv_solve_check(), FLA_LU_piv_check(), FLA_LU_piv_solve_check(), FLA_Lyap_check(), FLA_QR_UT_piv_check(), FLA_Shift_pivots_to_check(), and FLA_Sylv_check().

◆ FLA_Check_lseek_result()

FLA_Error FLA_Check_lseek_result	(	int	requested_offset,
		int	lseek_r_val
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( lseek_r_val != requested_offset )
    e_val = FLA_LSEEK_RETURNED_ERROR;
 
  return e_val;
}

◆ FLA_Check_malloc_pointer()

FLA_Error FLA_Check_malloc_pointer ( void * ptr )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( ptr == NULL )
    e_val = FLA_MALLOC_RETURNED_NULL_POINTER;
 
  return e_val;
}

Referenced by FLA_malloc(), and FLA_realloc().

◆ FLA_Check_matrix_matrix_dims()

FLA_Error FLA_Check_matrix_matrix_dims	(	FLA_Trans	transa,
		FLA_Trans	transb,
		FLA_Obj	A,
		FLA_Obj	B,
		FLA_Obj	C
	)

{
  FLA_Error e_val = FLA_SUCCESS;
  dim_t     k_A, k_B;
  dim_t     m_A, m_C;
  dim_t     n_B, n_C;
 
  m_A = ( transa == FLA_NO_TRANSPOSE || 
          transa == FLA_CONJ_NO_TRANSPOSE ? FLA_Obj_length( A ) :
                                            FLA_Obj_width( A )  );
  k_A = ( transa == FLA_NO_TRANSPOSE ||
          transa == FLA_CONJ_NO_TRANSPOSE ? FLA_Obj_width( A )  :
                                            FLA_Obj_length( A ) );
 
  k_B = ( transb == FLA_NO_TRANSPOSE ||
          transb == FLA_CONJ_NO_TRANSPOSE ? FLA_Obj_length( B ) :
                                            FLA_Obj_width( B )  );
  n_B = ( transb == FLA_NO_TRANSPOSE ||
          transb == FLA_CONJ_NO_TRANSPOSE ? FLA_Obj_width( B )  :
                                            FLA_Obj_length( B ) );
 
  m_C = FLA_Obj_length( C );
  n_C = FLA_Obj_width( C );
 
  if ( m_A != m_C )
    e_val = FLA_NONCONFORMAL_DIMENSIONS;
 
  if ( k_A != k_B )
    e_val = FLA_NONCONFORMAL_DIMENSIONS;
 
  if ( n_B != n_C )
    e_val = FLA_NONCONFORMAL_DIMENSIONS;
 
  return e_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

◆ FLA_Check_matrix_strides()

FLA_Error FLA_Check_matrix_strides	(	dim_t	m,
		dim_t	n,
		dim_t	rs,
		dim_t	cs
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  // Note: The default case (whereby we interpret rs == cs == 0 as a request
  // for column-major order) is handled prior to calling this function, so we
  // never see zero strides here.
 
  // Disallow either of the strides to be zero.
  if ( ( rs == 0 || cs == 0 ) )
    return FLA_INVALID_STRIDE_COMBINATION;
 
  // Check stride consistency in cases of general stride.
  if ( rs != 1 && cs != 1 )
  {
    // We apply different tests depending on which way the strides "tilt".
    if      ( rs == cs )
    {
      // If rs == cs, then we must be dealing with an m-by-1 or a 1-by-n matrix
      // and thus at least one of the dimensions, m or n, must be unit (even if
      // the other is zero).
      if ( m != 1 && n != 1 )
        return FLA_INVALID_STRIDE_COMBINATION;
    }
    else if ( rs < cs )
    {
      // For column-major tilt, cs must be equal or larger than m * rs.
      if ( m * rs > cs )
        return FLA_INVALID_STRIDE_COMBINATION;
    }
    else if ( cs < rs )
    {
      // For row-major tilt, rs must be equal or larger than n * cs.
      if ( n * cs > rs )
        return FLA_INVALID_STRIDE_COMBINATION;
    }
  }
 
  if ( rs == 1 && cs == 1 )
  {
    // Only allow rs == cs == 1 for scalars and "empty" objects.
    if ( !( m == 1 && n == 1 ) &&
         !( m == 0 )           && 
         !( n == 0 )           )
      return FLA_INVALID_STRIDE_COMBINATION;
  }
  else // perform additional stride/dimension checks on non-scalars.
  {
    if ( rs == 1 )
    {
      // For column-major storage, don't allow the column stride to be less than
      // the m dimension.
      if ( cs < m )
        e_val = FLA_INVALID_COL_STRIDE;
    }
    else if ( cs == 1 )
    {
      // For row-major storage, don't allow the row stride to be less than
      // the n dimension.
      if ( rs < n )
        e_val = FLA_INVALID_ROW_STRIDE;
    }
  }
 
  return e_val;
}

Referenced by FLA_Axpy_buffer_to_object_check(), FLA_Axpy_object_to_buffer_check(), FLA_Copy_buffer_to_object_check(), FLA_Copy_object_to_buffer_check(), FLA_Obj_attach_buffer_check(), FLA_Obj_create_buffer_check(), FLA_Obj_create_ext_check(), FLASH_Axpy_buffer_to_hier(), FLASH_Axpy_hier_to_buffer(), FLASH_Copy_buffer_to_hier(), FLASH_Copy_hier_to_buffer(), and FLASH_Obj_attach_buffer_check().

◆ FLA_Check_matrix_vector_dims()

FLA_Error FLA_Check_matrix_vector_dims	(	FLA_Trans	trans,
		FLA_Obj	A,
		FLA_Obj	x,
		FLA_Obj	y
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( trans == FLA_NO_TRANSPOSE || trans == FLA_CONJ_NO_TRANSPOSE )
  {
    if ( FLA_Obj_width( A ) != FLA_Obj_vector_dim( x ) )
      e_val = FLA_NONCONFORMAL_DIMENSIONS;
 
    if ( FLA_Obj_length( A ) != FLA_Obj_vector_dim( y ) )
      e_val = FLA_NONCONFORMAL_DIMENSIONS;
  }
  else
  {
    if ( FLA_Obj_length( A ) != FLA_Obj_vector_dim( x ) )
      e_val = FLA_NONCONFORMAL_DIMENSIONS;
 
    if ( FLA_Obj_width( A ) != FLA_Obj_vector_dim( y ) )
      e_val = FLA_NONCONFORMAL_DIMENSIONS;
  }
 
  return e_val;
}

References FLA_Obj_length(), FLA_Obj_vector_dim(), and FLA_Obj_width().

Referenced by FLA_Apply_HUD_UT_check(), FLA_Form_perm_matrix_check(), FLA_Gemv_check(), FLA_Gemv_internal_check(), FLA_Gemvc_check(), FLA_Ger_check(), FLA_Gerc_check(), FLA_Hemv_check(), FLA_Hemvc_check(), FLA_Her2_check(), FLA_Her2c_check(), FLA_Her_check(), FLA_Herc_check(), FLA_Symv_check(), FLA_Syr2_check(), FLA_Syr_check(), FLA_Trmv_check(), FLA_Trmvsx_check(), FLA_Trsv_check(), FLA_Trsv_internal_check(), and FLA_Trsvsx_check().

◆ FLA_Check_nonconstant_datatype()

FLA_Error FLA_Check_nonconstant_datatype ( FLA_Datatype datatype )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( datatype != FLA_INT &&
       datatype != FLA_FLOAT && 
       datatype != FLA_DOUBLE && 
       datatype != FLA_COMPLEX && 
       datatype != FLA_DOUBLE_COMPLEX )
    e_val = FLA_INVALID_NONCONSTANT_DATATYPE;
  
  return e_val;
}

Referenced by FLA_Check_nonconstant_object().

◆ FLA_Check_nonconstant_object()

FLA_Error FLA_Check_nonconstant_object ( FLA_Obj A )

{
  FLA_Error    e_val = FLA_SUCCESS;
  FLA_Datatype datatype;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( FLA_Check_nonconstant_datatype( datatype ) != FLA_SUCCESS )
    e_val = FLA_OBJECT_NOT_NONCONSTANT;
 
  return e_val;
}

References FLA_Check_nonconstant_datatype(), and FLA_Obj_datatype().

◆ FLA_Check_null_pointer()

FLA_Error FLA_Check_null_pointer ( void * ptr )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( ptr == NULL )
    e_val = FLA_NULL_POINTER;
 
  return e_val;
}

◆ FLA_Check_num_threads()

FLA_Error FLA_Check_num_threads ( unsigned int n_threads )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( n_threads < 1 )
    e_val = FLA_ENCOUNTERED_NON_POSITIVE_NTHREADS;
 
  return e_val;
}

Referenced by FLASH_Queue_set_num_threads().

◆ FLA_Check_object_dims()

FLA_Error FLA_Check_object_dims	(	FLA_Trans	trans,
		dim_t	m,
		dim_t	n,
		FLA_Obj	A
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( trans == FLA_NO_TRANSPOSE || trans == FLA_CONJ_NO_TRANSPOSE )
  {
    if ( FLA_Obj_length( A ) != m )
      e_val = FLA_SPECIFIED_OBJ_DIM_MISMATCH;
 
    if ( FLA_Obj_width( A ) != n )
      e_val = FLA_SPECIFIED_OBJ_DIM_MISMATCH;
  }
  else
  {
    if ( FLA_Obj_length( A ) != n )
      e_val = FLA_SPECIFIED_OBJ_DIM_MISMATCH;
 
    if ( FLA_Obj_width( A ) != m )
      e_val = FLA_SPECIFIED_OBJ_DIM_MISMATCH;
  }
 
  return e_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

Referenced by FLA_Axpy_buffer_to_object_check(), FLA_Axpy_object_to_buffer_check(), FLA_Copy_buffer_to_object_check(), and FLA_Copy_object_to_buffer_check().

◆ FLA_Check_object_length_equals()

FLA_Error FLA_Check_object_length_equals	(	FLA_Obj	A,
		dim_t	m
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_length( A ) != m )
    e_val = FLA_INVALID_OBJECT_LENGTH;
 
  return e_val;
}

References FLA_Obj_length().

◆ FLA_Check_object_length_min()

FLA_Error FLA_Check_object_length_min	(	FLA_Obj	A,
		dim_t	m
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_length( A ) < m )
    e_val = FLA_INVALID_OBJECT_LENGTH;
 
  return e_val;
}

References FLA_Obj_length().

Referenced by FLA_CAQR_UT_inc_check(), FLA_CAQR_UT_inc_solve_check(), FLA_QR_UT_inc_solve_check(), and FLA_QR_UT_solve_check().

◆ FLA_Check_object_matrix_elemtype()

FLA_Error FLA_Check_object_matrix_elemtype ( FLA_Obj A )

{
  FLA_Error     e_val = FLA_SUCCESS;
  FLA_Elemtype  elemtype;
 
  elemtype = FLA_Obj_elemtype( A );
 
  if ( elemtype != FLA_MATRIX )
    e_val = FLA_OBJECT_NOT_MATRIX_ELEMTYPE;
 
  return e_val;
}

References FLA_Obj_elemtype().

◆ FLA_Check_object_scalar_elemtype()

FLA_Error FLA_Check_object_scalar_elemtype ( FLA_Obj A )

{
  FLA_Error     e_val = FLA_SUCCESS;
  FLA_Elemtype  elemtype;
 
  elemtype = FLA_Obj_elemtype( A );
 
  if ( elemtype != FLA_SCALAR )
    e_val = FLA_OBJECT_NOT_SCALAR_ELEMTYPE;
 
  return e_val;
}

References FLA_Obj_elemtype().

Referenced by FLA_LU_find_zero_on_diagonal_check(), FLA_Obj_fshow_check(), and FLA_Obj_show_check().

◆ FLA_Check_object_width_equals()

FLA_Error FLA_Check_object_width_equals	(	FLA_Obj	A,
		dim_t	n
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_width( A ) != n )
    e_val = FLA_INVALID_OBJECT_WIDTH;
 
  return e_val;
}

References FLA_Obj_width().

◆ FLA_Check_object_width_min()

FLA_Error FLA_Check_object_width_min	(	FLA_Obj	A,
		dim_t	n
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_width( A ) < n )
    e_val = FLA_INVALID_OBJECT_WIDTH;
 
  return e_val;
}

References FLA_Obj_width().

Referenced by FLA_LQ_UT_internal_check(), and FLA_QR_UT_internal_check().

◆ FLA_Check_pivot_index_range()

FLA_Error FLA_Check_pivot_index_range	(	FLA_Obj	p,
		dim_t	k1,
		dim_t	k2
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_has_zero_dim( p ) )
    return e_val;
 
  // FGVZ: Note that we don't need to test if k1 < 0 since the type is an
  // unsigned integer. Same goes for k2 < 0. If we ever wanted to allow
  // the caller to specify the index range k1:k2 == -1:0, which would
  // result in no action. If this "no-op" behavior is needed, then k1 and
  // k2 should be type re-declared as ints.
  //if ( k1 < 0 || FLA_Obj_length( p ) - 1 < k1 )
  if ( FLA_Obj_length( p ) - 1 < k1 )
    e_val = FLA_INVALID_PIVOT_INDEX_RANGE;
 
  //if ( k2 < 0 || FLA_Obj_length( p ) - 1 < k2 )
  if ( FLA_Obj_length( p ) - 1 < k2 )
    e_val = FLA_INVALID_PIVOT_INDEX_RANGE;
 
  if ( k2 < k1 )
    e_val = FLA_INVALID_PIVOT_INDEX_RANGE;
 
  return e_val;
}

References FLA_Obj_has_zero_dim(), and FLA_Obj_length().

◆ FLA_Check_posix_memalign_failure()

FLA_Error FLA_Check_posix_memalign_failure ( int r_val )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( r_val != 0 )
    e_val = FLA_POSIX_MEMALIGN_FAILED;
 
  return e_val;
}

Referenced by FLA_malloc().

◆ FLA_Check_pthread_create_result()

FLA_Error FLA_Check_pthread_create_result ( int pthread_create_r_val )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( pthread_create_r_val != 0 )
    e_val = FLA_PTHREAD_CREATE_RETURNED_ERROR;
 
  return e_val;
}

Referenced by FLASH_Queue_exec_parallel().

◆ FLA_Check_pthread_join_result()

FLA_Error FLA_Check_pthread_join_result ( int pthread_join_r_val )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( pthread_join_r_val != 0 )
    e_val = FLA_PTHREAD_JOIN_RETURNED_ERROR;
 
  return e_val;
}

Referenced by FLASH_Queue_exec_parallel().

◆ FLA_Check_read_result()

FLA_Error FLA_Check_read_result	(	int	requested_size,
		int	read_r_val
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( read_r_val == -1 )
    e_val = FLA_READ_RETURNED_ERROR;
 
  return e_val;
}

◆ FLA_Check_real_datatype()

FLA_Error FLA_Check_real_datatype ( FLA_Datatype datatype )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( datatype != FLA_CONSTANT &&
       datatype != FLA_FLOAT &&
       datatype != FLA_DOUBLE )
    e_val = FLA_INVALID_REAL_DATATYPE;
 
  return e_val;
}

Referenced by FLA_Check_comparable_object(), and FLA_Check_real_object().

◆ FLA_Check_real_object()

FLA_Error FLA_Check_real_object ( FLA_Obj A )

{
  FLA_Error    e_val = FLA_SUCCESS;
  FLA_Datatype datatype;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( FLA_Check_real_datatype( datatype ) != FLA_SUCCESS )
    e_val = FLA_OBJECT_NOT_REAL;
 
  return e_val;
}

References FLA_Check_real_datatype(), and FLA_Obj_datatype().

Referenced by FLA_Apply_G_1x2_check(), FLA_Apply_G_mx2_check(), FLA_Apply_GTG_check(), FLA_Bidiag_UT_extract_real_diagonals_check(), FLA_Bidiag_UT_scale_diagonals_check(), FLA_Bsvd_check(), FLA_Bsvd_create_workspace(), FLA_Fill_with_cluster_dist_check(), FLA_Fill_with_geometric_dist_check(), FLA_Fill_with_inverse_dist_check(), FLA_Fill_with_linear_dist_check(), FLA_Fill_with_logarithmic_dist_check(), FLA_Fill_with_random_dist_check(), FLA_Givens1_check(), FLA_Givens2_check(), FLA_Her2k_check(), FLA_Her_check(), FLA_Herc_check(), FLA_Herk_check(), FLA_Hevd_check(), FLA_Hevd_compute_scaling_check(), FLA_Hevdd_check(), FLA_Hevdr_check(), FLA_Introduce_bulge_check(), FLA_Mach_params_check(), FLA_Max_abs_value_herm_check(), FLA_Norm_frob_check(), FLA_Norm_inf_check(), FLA_Nrm2_check(), FLA_Obj_extract_imag_part_check(), FLA_Obj_extract_real_part_check(), FLA_Obj_extract_real_scalar_check(), FLA_Obj_set_imag_part_check(), FLA_Obj_set_real_part_check(), FLA_Sort_evd_check(), FLA_Sort_svd_check(), FLA_Svd_check(), FLA_Svd_compute_scaling_check(), FLA_Svd_ext_check(), FLA_Svdd_check(), FLA_Tridiag_UT_scale_diagonals_check(), and FLA_Wilkshift_tridiag_check().

◆ FLA_Check_row_storage()

FLA_Error FLA_Check_row_storage ( FLA_Obj A )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_col_stride( A ) != 1 )
    e_val = FLA_EXPECTED_ROW_STORAGE;
 
  return e_val;
}

References FLA_Obj_col_stride().

◆ FLA_Check_row_vector()

FLA_Error FLA_Check_row_vector ( FLA_Obj x )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_length( x ) != 1 )
    e_val = FLA_EXPECTED_ROW_VECTOR;
 
  return e_val;
}

References FLA_Obj_length().

◆ FLA_Check_square()

FLA_Error FLA_Check_square ( FLA_Obj A )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_length( A ) != FLA_Obj_width( A ) )
    e_val = FLA_OBJECT_NOT_SQUARE;
 
  return e_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

◆ FLA_Check_submatrix_dims_and_offset()

FLA_Error FLA_Check_submatrix_dims_and_offset	(	dim_t	m,
		dim_t	n,
		dim_t	i,
		dim_t	j,
		FLA_Obj	A
	)

{
  FLA_Error e_val = FLA_SUCCESS;
  dim_t     m_A, n_A;
 
  if ( FLA_Obj_elemtype( A ) == FLA_MATRIX )
  {
    m_A = FLASH_Obj_scalar_length( A );
    n_A = FLASH_Obj_scalar_width( A );
  }
  else
  {
    m_A = FLA_Obj_length( A );
    n_A = FLA_Obj_width( A );
  }
 
  if      ( i     > m_A || j     > n_A )
    e_val = FLA_INVALID_SUBMATRIX_OFFSET;
  else if ( i + m > m_A || j + n > n_A )
    e_val = FLA_INVALID_SUBMATRIX_DIMS;
 
  return e_val;
}

References FLA_Obj_elemtype(), FLA_Obj_length(), FLA_Obj_width(), FLASH_Obj_scalar_length(), FLASH_Obj_scalar_width(), and i.

Referenced by FLA_Axpy_buffer_to_object_check(), FLA_Axpy_object_to_buffer_check(), FLA_Copy_buffer_to_object_check(), FLA_Copy_object_to_buffer_check(), FLASH_Axpy_buffer_to_hier(), FLASH_Axpy_hier_to_buffer(), FLASH_Copy_buffer_to_hier(), and FLASH_Copy_hier_to_buffer().

◆ FLA_Check_sylv_matrix_dims()

FLA_Error FLA_Check_sylv_matrix_dims	(	FLA_Obj	A,
		FLA_Obj	B,
		FLA_Obj	C
	)

{
  FLA_Error e_val = FLA_SUCCESS;
  dim_t     m_A, m_C;
  dim_t     n_B, n_C;
 
  m_A = FLA_Obj_length( A );
 
  n_B = FLA_Obj_width( B );
 
  m_C = FLA_Obj_length( C );
  n_C = FLA_Obj_width( C );
 
  if ( m_A != m_C )
    e_val = FLA_NONCONFORMAL_DIMENSIONS;
 
  if ( n_B != n_C )
    e_val = FLA_NONCONFORMAL_DIMENSIONS;
 
  return e_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

Referenced by FLA_Sylv_check(), and FLA_Sylv_internal_check().

◆ FLA_Check_unlink_result()

FLA_Error FLA_Check_unlink_result ( int unlink_r_val )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( unlink_r_val == -1 )
    e_val = FLA_UNLINK_RETURNED_ERROR;
 
  return e_val;
}

◆ FLA_Check_valid_blas_trans()

FLA_Error FLA_Check_valid_blas_trans ( FLA_Trans trans )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( trans != FLA_NO_TRANSPOSE &&
       trans != FLA_TRANSPOSE &&
       trans != FLA_CONJ_TRANSPOSE )
    e_val = FLA_INVALID_BLAS_TRANS;
 
  return e_val;
}

Referenced by FLA_Lyap_check(), and FLA_Sylv_check().

◆ FLA_Check_valid_complex_trans()

FLA_Error FLA_Check_valid_complex_trans ( FLA_Trans trans )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( trans != FLA_NO_TRANSPOSE &&
       trans != FLA_CONJ_TRANSPOSE )
    e_val = FLA_INVALID_COMPLEX_TRANS;
 
  return e_val;
}

Referenced by FLA_Apply_Q_check(), FLA_Her2k_check(), FLA_Herk_check(), and FLA_Tridiag_apply_Q_check().

◆ FLA_Check_valid_conj()

FLA_Error FLA_Check_valid_conj ( FLA_Conj conj )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( conj != FLA_NO_CONJUGATE &&
       conj != FLA_CONJUGATE )
    e_val = FLA_INVALID_CONJ;
 
  return e_val;
}

Referenced by FLA_Apply_diag_matrix_check(), FLA_Dot2cs_check(), FLA_Dotc_check(), FLA_Dotcs_check(), FLA_Gemvc_check(), FLA_Gerc_check(), FLA_Hemvc_check(), FLA_Her2c_check(), FLA_Herc_check(), FLA_Inv_scalc_check(), FLA_Invert_check(), FLA_Scalc_check(), FLA_Scale_diag_check(), and FLA_Shift_diag_check().

◆ FLA_Check_valid_datatype()

FLA_Error FLA_Check_valid_datatype ( FLA_Datatype datatype )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( datatype != FLA_INT &&
       datatype != FLA_FLOAT && 
       datatype != FLA_DOUBLE && 
       datatype != FLA_COMPLEX && 
       datatype != FLA_DOUBLE_COMPLEX && 
       datatype != FLA_CONSTANT )
    e_val = FLA_INVALID_DATATYPE;
 
  return e_val;
}

Referenced by FLA_Check_valid_object_datatype(), FLA_Obj_create_ext_check(), FLA_Obj_create_without_buffer_check(), FLA_Obj_datatype_size_check(), FLA_Obj_elem_size_check(), FLA_Submatrix_at_check(), FLASH_Obj_create_helper_check(), and FLASH_Obj_create_hierarchy_check().

◆ FLA_Check_valid_diag()

FLA_Error FLA_Check_valid_diag ( FLA_Diag diag )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( diag != FLA_NONUNIT_DIAG && 
       diag != FLA_UNIT_DIAG &&
       diag != FLA_ZERO_DIAG )
    e_val = FLA_INVALID_DIAG;
 
  return e_val;
}

Referenced by FLA_Random_tri_matrix_check(), FLA_Triangularize_check(), FLA_Trinv_check(), FLA_Trmm_check(), FLA_Trmmsx_check(), FLA_Trmv_check(), FLA_Trmvsx_check(), FLA_Trsm_check(), FLA_Trsmsx_check(), FLA_Trsv_check(), and FLA_Trsvsx_check().

◆ FLA_Check_valid_diag_offset()

FLA_Error FLA_Check_valid_diag_offset	(	FLA_Obj	A,
		FLA_Diag_off	offset
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_min_dim( A ) <= abs( offset ) )
    e_val = FLA_INVALID_DIAG_OFFSET;
 
  return e_val;
}

References FLA_Obj_min_dim().

◆ FLA_Check_valid_direct()

FLA_Error FLA_Check_valid_direct ( FLA_Conj direct )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( direct != FLA_FORWARD &&
       direct != FLA_BACKWARD )
    e_val = FLA_INVALID_DIRECT;
 
  return e_val;
}

Referenced by FLA_Accum_T_UT_check(), FLA_Apply_CAQ_UT_inc_check(), FLA_Apply_G_check(), FLA_Apply_Q2_UT_check(), FLA_Apply_Q_UT_check(), FLA_Apply_Q_UT_inc_check(), FLA_Apply_QUD_UT_check(), FLA_Apply_QUD_UT_inc_check(), FLA_Sort_check(), FLA_Sort_evd_check(), and FLA_Sort_svd_check().

◆ FLA_Check_valid_elemtype()

FLA_Error FLA_Check_valid_elemtype ( FLA_Elemtype elemtype )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( elemtype != FLA_SCALAR &&
       elemtype != FLA_MATRIX )
    e_val = FLA_INVALID_ELEMTYPE;
 
  return e_val;
}

Referenced by FLA_Obj_create_ext_check(), and FLA_Obj_elem_size_check().

◆ FLA_Check_valid_error_level()

FLA_Error FLA_Check_valid_error_level ( unsigned int level )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( level != FLA_NO_ERROR_CHECKING &&
       level != FLA_MIN_ERROR_CHECKING &&
       level != FLA_FULL_ERROR_CHECKING )
    e_val = FLA_INVALID_ERROR_CHECKING_LEVEL;
 
  return e_val;
}

Referenced by FLA_Check_error_level_set().

◆ FLA_Check_valid_evd_type()

FLA_Error FLA_Check_valid_evd_type ( FLA_Evd_type evd_type )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( evd_type != FLA_EVD_WITHOUT_VECTORS && 
       evd_type != FLA_EVD_WITH_VECTORS )
    e_val = FLA_INVALID_EVD_TYPE;
 
  return e_val;
}

Referenced by FLA_Hevd_check(), FLA_Hevdd_check(), and FLA_Hevdr_check().

◆ FLA_Check_valid_inverse()

FLA_Error FLA_Check_valid_inverse ( FLA_Inv inv )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( inv != FLA_NO_INVERSE &&
       inv != FLA_INVERSE )
    e_val = FLA_INVALID_INVERSE;
 
  return e_val;
}

Referenced by FLA_Eig_gest_check().

◆ FLA_Check_valid_isgn_value()

FLA_Error FLA_Check_valid_isgn_value ( FLA_Obj isgn )

{
  FLA_Error e_val = FLA_SUCCESS;
  
  if ( !FLA_Obj_is( isgn, FLA_ONE ) && 
       !FLA_Obj_is( isgn, FLA_MINUS_ONE ) )
    e_val = FLA_INVALID_ISGN_VALUE;
 
  return e_val;
}

References FLA_MINUS_ONE, FLA_Obj_is(), and FLA_ONE.

Referenced by FLA_Lyap_check(), and FLA_Sylv_check().

◆ FLA_Check_valid_leftright_side()

FLA_Error FLA_Check_valid_leftright_side ( FLA_Side side )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( side != FLA_LEFT && 
       side != FLA_RIGHT )
    e_val = FLA_INVALID_SIDE;
 
  return e_val;
}

Referenced by FLA_Apply_CAQ_UT_inc_check(), FLA_Apply_diag_matrix_check(), FLA_Apply_G_check(), FLA_Apply_H2_UT_check(), FLA_Apply_HUD_UT_check(), FLA_Apply_pivots_check(), FLA_Apply_Q2_UT_check(), FLA_Apply_Q_check(), FLA_Apply_Q_UT_check(), FLA_Apply_Q_UT_inc_check(), FLA_Apply_QUD_UT_check(), FLA_Apply_QUD_UT_inc_check(), FLA_Cont_with_1x3_to_1x2_check(), FLA_Givens1_check(), FLA_Hemm_check(), FLA_Househ2_UT_check(), FLA_Househ2s_UT_check(), FLA_Part_1x2_check(), FLA_Repart_1x2_to_1x3_check(), FLA_Symm_check(), FLA_Tridiag_apply_Q_check(), FLA_Trmm_check(), FLA_Trmmsx_check(), FLA_Trsm_check(), and FLA_Trsmsx_check().

◆ FLA_Check_valid_machval()

FLA_Error FLA_Check_valid_machval ( FLA_Machval val )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( val != FLA_MACH_EPS      &&
       val != FLA_MACH_SFMIN    &&
       val != FLA_MACH_BASE     &&
       val != FLA_MACH_PREC     &&
       val != FLA_MACH_NDIGMANT &&
       val != FLA_MACH_RND      &&
       val != FLA_MACH_EMIN     &&
       val != FLA_MACH_RMIN     &&
       val != FLA_MACH_EMAX     &&
       val != FLA_MACH_RMAX     &&
       val != FLA_MACH_EPS2 )
    e_val = FLA_INVALID_MACHVAL;
 
  return e_val;
}

Referenced by FLA_Mach_params_check().

◆ FLA_Check_valid_object_datatype()

FLA_Error FLA_Check_valid_object_datatype ( FLA_Obj A )

{
  FLA_Error    e_val;
  FLA_Datatype datatype;
 
  datatype = FLA_Obj_datatype( A );
 
  e_val = FLA_Check_valid_datatype( datatype );
 
  return e_val;
}

References FLA_Check_valid_datatype(), and FLA_Obj_datatype().

Referenced by FLA_Cont_with_1x3_to_1x2_check(), FLA_Cont_with_3x1_to_2x1_check(), FLA_Cont_with_3x3_to_2x2_check(), FLA_Copy_check(), FLA_Copyr_check(), FLA_Copyrt_check(), FLA_Copyt_check(), FLA_Merge_1x2_check(), FLA_Merge_2x1_check(), FLA_Merge_2x2_check(), FLA_Obj_create_conf_to_check(), FLA_Obj_equals_check(), FLA_Obj_fshow_check(), FLA_Obj_show_check(), FLA_Part_1x2_check(), FLA_Part_2x1_check(), FLA_Part_2x2_check(), FLA_Repart_1x2_to_1x3_check(), FLA_Repart_2x1_to_3x1_check(), FLA_Repart_2x2_to_3x3_check(), FLA_Set_check(), FLA_Set_diag_check(), and FLA_Set_to_identity_check().

◆ FLA_Check_valid_pivot_type()

FLA_Error FLA_Check_valid_pivot_type ( FLA_Pivot_type ptype )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( ptype != FLA_NATIVE_PIVOTS && ptype != FLA_LAPACK_PIVOTS )
    e_val = FLA_INVALID_PIVOT_TYPE;
 
  return e_val;
}

Referenced by FLA_Shift_pivots_to_check().

◆ FLA_Check_valid_quadrant()

FLA_Error FLA_Check_valid_quadrant ( FLA_Quadrant quad )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( quad != FLA_TL && 
       quad != FLA_TR && 
       quad != FLA_BL &&
       quad != FLA_BR )
    e_val = FLA_INVALID_QUADRANT;
 
  return e_val;
}

Referenced by FLA_Cont_with_3x3_to_2x2_check(), FLA_Part_2x2_check(), and FLA_Repart_2x2_to_3x3_check().

◆ FLA_Check_valid_real_trans()

FLA_Error FLA_Check_valid_real_trans ( FLA_Trans trans )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( trans != FLA_NO_TRANSPOSE &&
       trans != FLA_TRANSPOSE )
    e_val = FLA_INVALID_REAL_TRANS;
 
  return e_val;
}

Referenced by FLA_Apply_Q_check(), FLA_Axpy_buffer_to_object_check(), FLA_Axpy_object_to_buffer_check(), FLA_Copy_buffer_to_object_check(), FLA_Copy_object_to_buffer_check(), FLA_Syr2k_check(), FLA_Syrk_check(), FLA_Tridiag_apply_Q_check(), FLASH_Obj_create_conf_to_check(), FLASH_Obj_create_flat_conf_to_hier_check(), FLASH_Obj_create_hier_conf_to_flat_check(), and FLASH_Obj_create_hier_conf_to_flat_ext_check().

◆ FLA_Check_valid_side()

FLA_Error FLA_Check_valid_side ( FLA_Side side )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( side != FLA_LEFT && 
       side != FLA_RIGHT && 
       side != FLA_TOP &&
       side != FLA_BOTTOM )
    e_val = FLA_INVALID_SIDE;
 
  return e_val;
}

◆ FLA_Check_valid_storev()

FLA_Error FLA_Check_valid_storev ( FLA_Conj storev )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( storev != FLA_COLUMNWISE &&
       storev != FLA_ROWWISE )
    e_val = FLA_INVALID_STOREV;
 
  return e_val;
}

Referenced by FLA_Accum_T_UT_check(), FLA_Apply_CAQ_UT_inc_check(), FLA_Apply_Q2_UT_check(), FLA_Apply_Q_check(), FLA_Apply_Q_UT_check(), FLA_Apply_Q_UT_inc_check(), FLA_Apply_QUD_UT_check(), and FLA_Apply_QUD_UT_inc_check().

◆ FLA_Check_valid_svd_type()

FLA_Error FLA_Check_valid_svd_type ( FLA_Svd_type svd_type )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( svd_type != FLA_SVD_VECTORS_ALL && 
       svd_type != FLA_SVD_VECTORS_MIN_COPY &&
       svd_type != FLA_SVD_VECTORS_MIN_OVERWRITE &&
       svd_type != FLA_SVD_VECTORS_NONE )
    e_val = FLA_INVALID_SVD_TYPE;
 
  return e_val;
}

Referenced by FLA_Bsvd_check(), FLA_Svd_check(), FLA_Svd_ext_check(), and FLA_Svdd_check().

◆ FLA_Check_valid_svd_type_and_trans_combination()

FLA_Error FLA_Check_valid_svd_type_and_trans_combination	(	FLA_Svd_type	svd_type_u,
		FLA_Trans	transu,
		FLA_Svd_type	svd_type_v,
		FLA_Trans	transv
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( svd_type_u == FLA_SVD_VECTORS_MIN_OVERWRITE )
    if ( transu == FLA_TRANSPOSE || 
         transu == FLA_CONJ_TRANSPOSE )
      e_val = FLA_INVALID_SVD_TYPE_AND_TRANS_COMBINATION;
  if ( svd_type_v == FLA_SVD_VECTORS_MIN_OVERWRITE )
    if ( transv == FLA_NO_TRANSPOSE || 
         transv == FLA_CONJ_NO_TRANSPOSE )
      e_val = FLA_INVALID_SVD_TYPE_AND_TRANS_COMBINATION;
  
  return e_val;
}

Referenced by FLA_Svd_ext_check().

◆ FLA_Check_valid_svd_type_combination()

FLA_Error FLA_Check_valid_svd_type_combination	(	FLA_Svd_type	svd_type_u,
		FLA_Svd_type	svd_type_v
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( svd_type_u == FLA_SVD_VECTORS_MIN_OVERWRITE &&
       svd_type_v == FLA_SVD_VECTORS_MIN_OVERWRITE )
    e_val = FLA_INVALID_SVD_TYPE_COMBINATION;
  
  return e_val;
}

Referenced by FLA_Svd_ext_check().

◆ FLA_Check_valid_topbottom_side()

FLA_Error FLA_Check_valid_topbottom_side ( FLA_Side side )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( side != FLA_TOP && 
       side != FLA_BOTTOM )
    e_val = FLA_INVALID_SIDE;
 
  return e_val;
}

Referenced by FLA_Cont_with_3x1_to_2x1_check(), FLA_Part_2x1_check(), and FLA_Repart_2x1_to_3x1_check().

◆ FLA_Check_valid_trans()

FLA_Error FLA_Check_valid_trans ( FLA_Trans trans )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( trans != FLA_NO_TRANSPOSE &&
       trans != FLA_TRANSPOSE &&
       trans != FLA_CONJ_TRANSPOSE &&
       trans != FLA_CONJ_NO_TRANSPOSE )
    e_val = FLA_INVALID_TRANS;
 
  return e_val;
}

Referenced by FLA_Apply_CAQ_UT_inc_check(), FLA_Apply_pivots_check(), FLA_Apply_Q2_UT_check(), FLA_Apply_Q_check(), FLA_Apply_Q_UT_check(), FLA_Apply_Q_UT_inc_check(), FLA_Apply_QUD_UT_check(), FLA_Apply_QUD_UT_inc_check(), FLA_Axpyrt_check(), FLA_Axpyt_check(), FLA_Copyrt_check(), FLA_Copyt_check(), FLA_Gemm_check(), FLA_Gemv_check(), FLA_Gemvc_check(), FLA_Inv_scal_elemwise_check(), FLA_Obj_create_conf_to_check(), FLA_Scal_elemwise_check(), FLA_Svd_ext_check(), FLA_Swapt_check(), FLA_Tridiag_apply_Q_check(), FLA_Trmm_check(), FLA_Trmmsx_check(), FLA_Trmv_check(), FLA_Trmvsx_check(), FLA_Trsm_check(), FLA_Trsmsx_check(), FLA_Trsv_check(), and FLA_Trsvsx_check().

◆ FLA_Check_valid_uplo()

FLA_Error FLA_Check_valid_uplo ( FLA_Uplo uplo )

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( uplo != FLA_LOWER_TRIANGULAR && 
       uplo != FLA_UPPER_TRIANGULAR )
    e_val = FLA_INVALID_UPLO;
 
  return e_val;
}

◆ FLA_Check_vector_dim()

FLA_Error FLA_Check_vector_dim	(	FLA_Obj	x,
		dim_t	expected_length
	)

◆ FLA_Check_vector_dim_min()

FLA_Error FLA_Check_vector_dim_min	(	FLA_Obj	x,
		dim_t	min_dim
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( FLA_Obj_vector_dim( x ) < min_dim )
    e_val = FLA_VECTOR_DIM_BELOW_MIN;
 
  return e_val;
}

References FLA_Obj_vector_dim().

Referenced by FLA_Bidiag_form_U_check(), FLA_Bidiag_form_V_check(), FLA_Hess_check(), FLA_LU_piv_check(), FLA_LU_piv_solve_check(), FLA_Tridiag_apply_Q_check(), FLA_Tridiag_check(), and FLA_Tridiag_form_Q_check().

◆ FLA_Check_write_result()

FLA_Error FLA_Check_write_result	(	int	requested_size,
		int	write_r_val
	)

{
  FLA_Error e_val = FLA_SUCCESS;
 
  if ( write_r_val != requested_size )
    e_val = FLA_WRITE_RETURNED_ERROR;
 
  return e_val;
}

◆ FLA_compute_num_elem()

dim_t FLA_compute_num_elem	(	dim_t	elem_size,
		dim_t	m,
		dim_t	n,
		dim_t *	rs,
		dim_t *	cs
	)

{
  dim_t n_elem;
 
  // Determine the amount of space we need to allocate based on the values of
  // the row and column strides.
  if ( m == 0 || n == 0 )
  {
    // For empty objects, set the length of the buffer to 0. Row and column
    // strides should remain unchanged (because alignment is not needed).
    n_elem = 0;
  }
  else if ( *rs == 1 )
  {
    // For column-major storage, use cs for computing the length of the buffer
    // to allocate.
 
    // Align the leading dimension to some user-defined address multiple,
    // if requested at configure-time.
    *cs = FLA_align_ldim( *cs, elem_size );
 
    // Compute the length of the buffer needed for the object we're creating.
    n_elem = ( size_t ) *cs *
             ( size_t ) n;
  }
  else if ( *cs == 1 )
  {
    // For row-major storage, use rs for computing the length of the buffer
    // to allocate.
 
    // Align the leading dimension to some user-defined address multiple,
    // if requested at configure-time.
    *rs = FLA_align_ldim( *rs, elem_size );
 
    // Compute the length of the buffer needed for the object we're creating.
    n_elem = ( size_t ) m *
             ( size_t ) *rs;
  }
  else
  {
    // For general storage, use rs and cs to compute the length of the buffer
    // to allocate.
 
    // Compute the size of the buffer needed for the object we're creating.
    if ( *rs < *cs )
    {
      *cs = FLA_align_ldim( *cs, elem_size );
 
      n_elem = ( size_t ) *cs *
               ( size_t ) n;
    }
    else if ( *rs > *cs )
    {
      *rs = FLA_align_ldim( *rs, elem_size );
 
      n_elem = ( size_t ) m *
               ( size_t ) *rs;
    }
    else // if ( rs == cs )
    {
      //rs = FLA_align_ldim( rs, FLA_Obj_elem_size( *obj ) );
      *cs = FLA_align_ldim( *cs, elem_size );
 
      // Note that if rs == cs, then we must be creating either a 1-by-n matrix
      // or a m-by-1 matrix. This constraint is enforced in
      // FLA_Check_matrix_strides(). Thus, we can compute the buffer length:
      // m * n * (rs|cs).
      n_elem = ( size_t ) m *
               ( size_t ) n *
               ( size_t ) *cs;
    }
  }
 
  return n_elem;
}

References FLA_align_ldim().

Referenced by FLA_Obj_create_buffer(), and FLA_Obj_create_ext().

◆ FLA_Cont_with_1x3_to_1x2()

FLA_Error FLA_Cont_with_1x3_to_1x2	(	FLA_Obj *	AL,
		FLA_Obj *	AR,
		FLA_Obj	A0,
		FLA_Obj	A1,
		FLA_Obj	A2,
		FLA_Side	side
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Cont_with_1x3_to_1x2_check( AL, AR,        A0, A1, A2,
                                    side );
 
  if ( side == FLA_LEFT )
  {
    AL->m    = A0.m;
    AL->n    = A0.n + A1.n;
    AL->offm = A0.offm;
    AL->offn = A0.offn;
    AL->base = A0.base;
 
    AR->m    = A2.m;
    AR->n    = A2.n;
    AR->offm = A2.offm;
    AR->offn = A2.offn;
    AR->base = A2.base;
  }
  else
  {
    AL->m    = A0.m;
    AL->n    = A0.n;
    AL->offm = A0.offm;
    AL->offn = A0.offn;
    AL->base = A0.base;
 
    AR->m    = A1.m;
    AR->n    = A1.n + A2.n;
    AR->offm = A1.offm;
    AR->offn = A1.offn;
    AR->base = A1.base;
  }
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Cont_with_1x3_to_1x2_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Cont_with_1x3_to_1x2_check()

FLA_Error FLA_Cont_with_1x3_to_1x2_check	(	FLA_Obj *	AL,
		FLA_Obj *	AR,
		FLA_Obj	A0,
		FLA_Obj	A1,
		FLA_Obj	A2,
		FLA_Side	side
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( AL );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( AR );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A0 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A1 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A2 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_leftright_side( side );
  FLA_Check_error_code( e_val );
 
  // Needed: check for adjacency, similar to those in FLA_Merge_*().
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), FLA_Check_valid_leftright_side(), and FLA_Check_valid_object_datatype().

Referenced by FLA_Cont_with_1x3_to_1x2().

◆ FLA_Cont_with_3x1_to_2x1()

FLA_Error FLA_Cont_with_3x1_to_2x1	(	FLA_Obj *	AT,
		FLA_Obj	A0,
		FLA_Obj	A1,
		FLA_Obj *	AB,
		FLA_Obj	A2,
		FLA_Side	side
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Cont_with_3x1_to_2x1_check( AT,     A0, 
                                            A1, 
                                    AB,     A2,     side );
 
  if ( side == FLA_TOP )
  {
    AT->m    = A0.m + A1.m;
    AT->n    = A0.n;
    AT->offm = A0.offm;
    AT->offn = A0.offn;
    AT->base = A0.base;
 
    AB->m    = A2.m;
    AB->n    = A2.n;
    AB->offm = A2.offm;
    AB->offn = A2.offn;
    AB->base = A2.base;
  }
  else
  {
    AT->m    = A0.m;
    AT->n    = A0.n;
    AT->offm = A0.offm;
    AT->offn = A0.offn;
    AT->base = A0.base;
 
    AB->m    = A1.m + A2.m;
    AB->n    = A1.n;
    AB->offm = A1.offm;
    AB->offn = A1.offn;
    AB->base = A1.base;
  }
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Cont_with_3x1_to_2x1_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Cont_with_3x1_to_2x1_check()

FLA_Error FLA_Cont_with_3x1_to_2x1_check	(	FLA_Obj *	AT,
		FLA_Obj	A0,
		FLA_Obj	A1,
		FLA_Obj *	AB,
		FLA_Obj	A2,
		FLA_Side	side
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( AT );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( AB );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A0 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A1 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A2 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_topbottom_side( side );
  FLA_Check_error_code( e_val );
 
  // Needed: check for adjacency, similar to those in FLA_Merge_*().
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), FLA_Check_valid_object_datatype(), and FLA_Check_valid_topbottom_side().

Referenced by FLA_Cont_with_3x1_to_2x1().

◆ FLA_Cont_with_3x3_to_2x2()

FLA_Error FLA_Cont_with_3x3_to_2x2	(	FLA_Obj *	ATL,
		FLA_Obj *	ATR,
		FLA_Obj	A00,
		FLA_Obj	A01,
		FLA_Obj	A02,
		FLA_Obj	A10,
		FLA_Obj	A11,
		FLA_Obj	A12,
		FLA_Obj *	ABL,
		FLA_Obj *	ABR,
		FLA_Obj	A20,
		FLA_Obj	A21,
		FLA_Obj	A22,
		FLA_Quadrant	quadrant
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Cont_with_3x3_to_2x2_check( ATL, ATR,       A00, A01, A02,
                                                    A10, A11, A12,
                                    ABL, ABR,       A20, A21, A22,
                                    quadrant );
 
  if ( quadrant == FLA_TL )
  {
    ATL->m    = A00.m + A10.m;
    ATL->n    = A00.n + A01.n;
    ATL->offm = A00.offm;
    ATL->offn = A00.offn;
    ATL->base = A00.base;
 
    ATR->m    = A02.m + A12.m;
    ATR->n    = A02.n;
    ATR->offm = A02.offm;
    ATR->offn = A02.offn;
    ATR->base = A02.base;
 
    ABL->m    = A20.m;
    ABL->n    = A20.n + A21.n;
    ABL->offm = A20.offm;
    ABL->offn = A20.offn;
    ABL->base = A20.base;
 
    ABR->m    = A22.m;
    ABR->n    = A22.n;
    ABR->offm = A22.offm;
    ABR->offn = A22.offn;
    ABR->base = A22.base;
  }
  else if ( quadrant == FLA_TR )
  {
    ATL->m    = A00.m + A10.m;
    ATL->n    = A00.n;
    ATL->offm = A00.offm;
    ATL->offn = A00.offn;
    ATL->base = A00.base;
 
    ATR->m    = A01.m + A11.m;
    ATR->n    = A01.n + A02.n;
    ATR->offm = A01.offm;
    ATR->offn = A01.offn;
    ATR->base = A01.base;
 
    ABL->m    = A20.m;
    ABL->n    = A20.n;
    ABL->offm = A20.offm;
    ABL->offn = A20.offn;
    ABL->base = A20.base;
 
    ABR->m    = A21.m;
    ABR->n    = A21.n + A22.n;
    ABR->offm = A21.offm;
    ABR->offn = A21.offn;
    ABR->base = A21.base;
  }
  else if ( quadrant == FLA_BR )
  {
    ATL->m    = A00.m;
    ATL->n    = A00.n;
    ATL->offm = A00.offm;
    ATL->offn = A00.offn;
    ATL->base = A00.base;
 
    ATR->m    = A01.m;
    ATR->n    = A01.n + A02.n;
    ATR->offm = A01.offm;
    ATR->offn = A01.offn;
    ATR->base = A01.base;
 
    ABL->m    = A10.m + A20.m;
    ABL->n    = A10.n;
    ABL->offm = A10.offm;
    ABL->offn = A10.offn;
    ABL->base = A10.base;
 
    ABR->m    = A11.m + A21.m;
    ABR->n    = A11.n + A12.n;
    ABR->offm = A11.offm;
    ABR->offn = A11.offn;
    ABR->base = A11.base;
  }
  else if ( quadrant == FLA_BL )
  {
    ATL->m    = A00.m;
    ATL->n    = A00.n + A01.n;
    ATL->offm = A00.offm;
    ATL->offn = A00.offn;
    ATL->base = A00.base;
 
    ATR->m    = A02.m;
    ATR->n    = A02.n;
    ATR->offm = A02.offm;
    ATR->offn = A02.offn;
    ATR->base = A02.base;
 
    ABL->m    = A10.m + A20.m;
    ABL->n    = A10.n + A11.n;
    ABL->offm = A10.offm;
    ABL->offn = A10.offn;
    ABL->base = A10.base;
 
    ABR->m    = A12.m + A22.m;
    ABR->n    = A12.n ;
    ABR->offm = A12.offm;
    ABR->offn = A12.offn;
    ABR->base = A12.base;
  }
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Cont_with_3x3_to_2x2_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Cont_with_3x3_to_2x2_check()

FLA_Error FLA_Cont_with_3x3_to_2x2_check	(	FLA_Obj *	ATL,
		FLA_Obj *	ATR,
		FLA_Obj	A00,
		FLA_Obj	A01,
		FLA_Obj	A02,
		FLA_Obj	A10,
		FLA_Obj	A11,
		FLA_Obj	A12,
		FLA_Obj *	ABL,
		FLA_Obj *	ABR,
		FLA_Obj	A20,
		FLA_Obj	A21,
		FLA_Obj	A22,
		FLA_Quadrant	quadrant
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( ATL );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( ABL );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( ATR );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( ABR );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A00 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A10 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A20 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A01 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A11 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A21 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A02 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A12 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A22 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_quadrant( quadrant );
  FLA_Check_error_code( e_val );
 
  // Needed: check for adjacency, similar to those in FLA_Merge_*().
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), FLA_Check_valid_object_datatype(), and FLA_Check_valid_quadrant().

Referenced by FLA_Cont_with_3x3_to_2x2().

◆ FLA_Cont_with_5x5_to_3x3()

FLA_Error FLA_Cont_with_5x5_to_3x3	(	FLA_Obj *	ATL,
		FLA_Obj *	ATM,
		FLA_Obj *	ATR,
		FLA_Obj *	AML,
		FLA_Obj *	AMM,
		FLA_Obj *	AMR,
		FLA_Obj *	ABL,
		FLA_Obj *	ABM,
		FLA_Obj *	ABR,
		FLA_Obj	A00,
		FLA_Obj	A01,
		FLA_Obj	A02,
		FLA_Obj	A03,
		FLA_Obj	A04,
		FLA_Obj	A10,
		FLA_Obj	A11,
		FLA_Obj	A12,
		FLA_Obj	A13,
		FLA_Obj	A14,
		FLA_Obj	A20,
		FLA_Obj	A21,
		FLA_Obj	A22,
		FLA_Obj	A23,
		FLA_Obj	A24,
		FLA_Obj	A30,
		FLA_Obj	A31,
		FLA_Obj	A32,
		FLA_Obj	A33,
		FLA_Obj	A34,
		FLA_Obj	A40,
		FLA_Obj	A41,
		FLA_Obj	A42,
		FLA_Obj	A43,
		FLA_Obj	A44,
		FLA_Quadrant	quadrant
	)

◆ FLA_Copy_buffer_to_object()

FLA_Error FLA_Copy_buffer_to_object	(	FLA_Trans	trans,
		dim_t	m,
		dim_t	n,
		void *	buffer,
		dim_t	rs,
		dim_t	cs,
		dim_t	i,
		dim_t	j,
		FLA_Obj	obj
	)

{
  FLA_Obj  A;
  FLA_Obj  BTL, BTR, 
           BBL, Bij;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Copy_buffer_to_object_check( trans, m, n, A_buffer, rs, cs, i, j, B );
 
  FLA_Part_2x2( B,  &BTL, &BTR,
                    &BBL, &Bij,     i, j, FLA_TL );
 
  FLA_Obj_create_without_buffer( FLA_Obj_datatype( B ), m, n, &A );
  FLA_Obj_attach_buffer( A_buffer, rs, cs, &A );
 
  FLA_Copyt_external( trans, A, Bij );
 
  FLA_Obj_free_without_buffer( &A );
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_Copy_buffer_to_object_check(), FLA_Copyt_external(), FLA_Obj_attach_buffer(), FLA_Obj_create_without_buffer(), FLA_Obj_datatype(), FLA_Obj_free_without_buffer(), FLA_Part_2x2(), and i.

◆ FLA_Copy_buffer_to_object_check()

FLA_Error FLA_Copy_buffer_to_object_check	(	FLA_Trans	trans,
		dim_t	m,
		dim_t	n,
		void *	buffer,
		dim_t	rs,
		dim_t	cs,
		dim_t	i,
		dim_t	j,
		FLA_Obj	obj
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_real_trans( trans );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_floating_object( B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A_buffer );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_object_dims( trans, m, n, B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_matrix_strides( m, n, rs, cs );
  FLA_Check_error_code( e_val );
 
  if ( trans == FLA_NO_TRANSPOSE )
  {
    e_val = FLA_Check_submatrix_dims_and_offset( m, n, i, j, B );
    FLA_Check_error_code( e_val );
  }
  else
  {
    e_val = FLA_Check_submatrix_dims_and_offset( n, m, i, j, B );
    FLA_Check_error_code( e_val );
  }
 
  e_val = FLA_Check_nonconstant_object( B );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_floating_object(), FLA_Check_matrix_strides(), FLA_Check_nonconstant_object(), FLA_Check_null_pointer(), FLA_Check_object_dims(), FLA_Check_submatrix_dims_and_offset(), FLA_Check_valid_real_trans(), and i.

Referenced by FLA_Copy_buffer_to_object().

◆ FLA_Copy_object_to_buffer()

FLA_Error FLA_Copy_object_to_buffer	(	FLA_Trans	trans,
		dim_t	i,
		dim_t	j,
		FLA_Obj	obj,
		dim_t	m,
		dim_t	n,
		void *	buffer,
		dim_t	rs,
		dim_t	cs
	)

{
  FLA_Obj  B;
  FLA_Obj  ATL, ATR, 
           ABL, Aij;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Copy_object_to_buffer_check( trans, i, j, A, m, n, B_buffer, rs, cs );
 
  FLA_Part_2x2( A,  &ATL, &ATR,
                    &ABL, &Aij,     i, j, FLA_TL );
 
  FLA_Obj_create_without_buffer( FLA_Obj_datatype( A ), m, n, &B );
  FLA_Obj_attach_buffer( B_buffer, rs, cs, &B );
 
  FLA_Copyt_external( trans, Aij, B );
 
  FLA_Obj_free_without_buffer( &B );
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_Copy_object_to_buffer_check(), FLA_Copyt_external(), FLA_Obj_attach_buffer(), FLA_Obj_create_without_buffer(), FLA_Obj_datatype(), FLA_Obj_free_without_buffer(), FLA_Part_2x2(), and i.

◆ FLA_Copy_object_to_buffer_check()

FLA_Error FLA_Copy_object_to_buffer_check	(	FLA_Trans	trans,
		dim_t	i,
		dim_t	j,
		FLA_Obj	obj,
		dim_t	m,
		dim_t	n,
		void *	buffer,
		dim_t	rs,
		dim_t	cs
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_real_trans( trans );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_floating_object( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( B_buffer );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_object_dims( trans, m, n, A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_matrix_strides( m, n, rs, cs );
  FLA_Check_error_code( e_val );
 
  if ( trans == FLA_NO_TRANSPOSE )
  {
    e_val = FLA_Check_submatrix_dims_and_offset( m, n, i, j, A );
    FLA_Check_error_code( e_val );
  }
  else
  {
    e_val = FLA_Check_submatrix_dims_and_offset( n, m, i, j, A );
    FLA_Check_error_code( e_val );
  }
 
  e_val = FLA_Check_nonconstant_object( A );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_floating_object(), FLA_Check_matrix_strides(), FLA_Check_nonconstant_object(), FLA_Check_null_pointer(), FLA_Check_object_dims(), FLA_Check_submatrix_dims_and_offset(), FLA_Check_valid_real_trans(), and i.

Referenced by FLA_Copy_object_to_buffer().

◆ FLA_Determine_blocksize()

dim_t FLA_Determine_blocksize	(	FLA_Obj	A_unproc,
		FLA_Quadrant	to_dir,
		fla_blocksize_t *	cntl_blocksizes
	)

{
    FLA_Error    e_val;
    FLA_Datatype datatype;
    dim_t        A_unproc_size;
    dim_t        typed_blocksize;
    dim_t        b;
 
    // Determine the size of the remaining portion of the matrix.
    A_unproc_size = FLA_determine_matrix_size( A_unproc, to_dir );
    
    // Determine the datatype of the matrix.
    datatype = FLA_Obj_datatype( A_unproc );
    
    // Determine the raw blocksize value from the blocksize structure.
    typed_blocksize = FLA_Blocksize_extract( datatype, bp );
 
    // Check blocksize for zero value.
    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    {
        e_val = FLA_Check_blocksize_value( typed_blocksize );
        FLA_Check_error_code( e_val );
    }
 
    // If the unprocessed partition is smaller than our blocksize allows,
    // we have to use it's length/width instead.
    b = min( A_unproc_size, typed_blocksize );
    
    // Return the computed blocksize.
    return b;
}

References FLA_Blocksize_extract(), FLA_Check_blocksize_value(), FLA_Check_error_level(), FLA_determine_matrix_size(), and FLA_Obj_datatype().

◆ FLA_determine_matrix_size()

dim_t FLA_determine_matrix_size	(	FLA_Obj	A_unproc,
		FLA_Quadrant	to_dir
	)

{
    dim_t r_val = 0;
 
    // Determine the size of the matrix dimension along which we are moving.
    switch( to_dir )
    {
        case FLA_TOP:
        case FLA_BOTTOM:
        {
            r_val = FLA_Obj_length( A_unproc );
            break;
        }
        case FLA_LEFT:
        case FLA_RIGHT:
        {
            r_val = FLA_Obj_width( A_unproc );
            break;
        }
        case FLA_TL:
        case FLA_TR:
        case FLA_BL:
        case FLA_BR:
        {
            // We need to use min_dim() here because the matrix might be
            // rectangular.
            r_val = FLA_Obj_min_dim( A_unproc );
            break;
        }
    }
    
    return r_val;
}

References FLA_Obj_length(), FLA_Obj_min_dim(), and FLA_Obj_width().

Referenced by FLA_Determine_blocksize().

◆ FLA_Error_messages_init()

void FLA_Error_messages_init ( void )

{
    sprintf( FLA_Error_string_for_code(FLA_INVALID_SIDE),
             "Invalid side parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_UPLO),
             "Invalid uplo parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_TRANS),
             "Invalid trans parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_TRANS_GIVEN_DATATYPE),
             "Invalid trans value (FLA_CONJ_TRANSPOSE|FLA_CONJ_NO_TRANSPOSE) for given non-complex object datatype" );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_CONJ),
             "Invalid conjugate parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_DIRECT),
             "Invalid direction parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_STOREV),
             "Invalid storev parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_DATATYPE),
             "Invalid datatype value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_INTEGER_DATATYPE),
             "Invalid integer datatype value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_REAL_DATATYPE),
             "Invalid real datatype value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_COMPLEX_DATATYPE),
             "Invalid complex datatype value." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_INTEGER),
             "Expected integer object." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_REAL),
             "Expected real object." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_COMPLEX),
             "Expected complex object." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_SQUARE),
             "Expected square matrix object." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_SCALAR),
             "Expected scalar object." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_VECTOR),
             "Expected vector object." );
    sprintf( FLA_Error_string_for_code(FLA_INCONSISTENT_DATATYPES),
             "Detected inconsistent object datatypes." );
    sprintf( FLA_Error_string_for_code(FLA_NONCONFORMAL_DIMENSIONS),
             "Detected inconsistent object dimensions." );
    sprintf( FLA_Error_string_for_code(FLA_UNEQUAL_VECTOR_DIMS),
             "Detected vectors of unequal dimensions." );
    sprintf( FLA_Error_string_for_code(FLA_NULL_POINTER),
             "Encountered NULL pointer." );
    sprintf( FLA_Error_string_for_code(FLA_SPECIFIED_OBJ_DIM_MISMATCH),
             "Specified dimensions do not match object dimensions." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_PIVOT_TYPE),
             "Invalid pivot index type specified." );
    sprintf( FLA_Error_string_for_code(FLA_MALLOC_RETURNED_NULL_POINTER),
             "malloc() returned NULL pointer." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_BASE_BUFFER_MISMATCH),
             "Detected a buffer address mismatch between adjacent objects." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECTS_NOT_VERTICALLY_ADJ),
             "Object partitions not vertically adjacent." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECTS_NOT_HORIZONTALLY_ADJ),
             "Object partitions not horizontally adjacent." );
    sprintf( FLA_Error_string_for_code(FLA_ADJACENT_OBJECT_DIM_MISMATCH),
             "Object partitions have mismatched dimensions." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECTS_NOT_VERTICALLY_ALIGNED),
             "Object partitions not vertically aligned." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECTS_NOT_HORIZONTALLY_ALIGNED),
             "Object partitions not horizontally aligned." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_FLOATING_DATATYPE),
             "Expected single or double-precision real or complex datatype value." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_FLOATING_POINT),
             "Expected single or double-precision real or complex object." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_BLOCKSIZE_VALUE),
             "Detected blocksize value less than or equal to zero." );
    sprintf( FLA_Error_string_for_code(FLA_OPEN_RETURNED_ERROR),
             "open() returned bad file descriptor." );
    sprintf( FLA_Error_string_for_code(FLA_LSEEK_RETURNED_ERROR),
             "lseek() returned error." );
    sprintf( FLA_Error_string_for_code(FLA_CLOSE_RETURNED_ERROR),
             "close() returned error." );
    sprintf( FLA_Error_string_for_code(FLA_UNLINK_RETURNED_ERROR),
             "unlink() returned error." );
    sprintf( FLA_Error_string_for_code(FLA_READ_RETURNED_ERROR),
             "read() returned error." );
    sprintf( FLA_Error_string_for_code(FLA_WRITE_RETURNED_ERROR),
             "write() returned error." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_QUADRANT),
             "Invalid quadrant parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_NOT_YET_IMPLEMENTED),
             "Function or conditional branch/case not yet implemented." );
    sprintf( FLA_Error_string_for_code(FLA_EXPECTED_NONNEGATIVE_VALUE),
             "Expected non-negative value." );
    sprintf( FLA_Error_string_for_code(FLA_SUPERMATRIX_NOT_ENABLED),
             "SuperMatrix support must be enabled for this code to execute." );
    sprintf( FLA_Error_string_for_code(FLA_UNDEFINED_ERROR_CODE),
             "Undefined error code passed to FLA_Check_error_code()." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_DIAG),
             "Invalid diag parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INCONSISTENT_OBJECT_PRECISION),
             "Inconsistent precisions between objects." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_BLOCKSIZE_OBJ),
             "Encountered blocksize object containing value less than or equal to zero." );
    sprintf( FLA_Error_string_for_code(FLA_VECTOR_DIM_BELOW_MIN),
             "Detected vector dimension below pre-determined minimum." );
    sprintf( FLA_Error_string_for_code(FLA_PTHREAD_CREATE_RETURNED_ERROR),
             "pthread_create() returned error." );
    sprintf( FLA_Error_string_for_code(FLA_PTHREAD_JOIN_RETURNED_ERROR),
             "pthread_join() returned error." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_ISGN_VALUE),
             "Invalid value for isgn parameter (ie: |isgn| != 1)." );
    sprintf( FLA_Error_string_for_code(FLA_CHOL_FAILED_MATRIX_NOT_SPD),
             "FLA_Chol() failed due to negative diagonal element; matrix not SPD." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_ELEMTYPE),
             "Invalid object element type value." );
    sprintf( FLA_Error_string_for_code(FLA_POSIX_MEMALIGN_FAILED),
             "posix_memalign() returned error." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_SUBMATRIX_DIMS),
             "Invalid submatrix dimensions relative to parent matrix." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_SUBMATRIX_OFFSET),
             "Invalid submatrix offset relative to dimensions of submatrix and parent." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_SCALAR_ELEMTYPE),
             "Object element type is not FLA_SCALAR as expected." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_MATRIX_ELEMTYPE),
             "Object element type is not FLA_MATRIX as expected." );
    sprintf( FLA_Error_string_for_code(FLA_ENCOUNTERED_NON_POSITIVE_NTHREADS),
             "Encountered non-positive (zero) value for number of threads." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_CONJ_GIVEN_DATATYPE),
             "Invalid conj value (FLA_CONJUGATE) for given non-complex object datatype" );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_COMPLEX_TRANS),
             "Invalid complex trans parameter value" );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_REAL_TRANS),
             "Invalid real trans parameter value" );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_BLAS_TRANS),
             "Invalid BLAS-style trans parameter value" );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_NONCONSTANT_DATATYPE),
             "Invalid non-constant datatype value." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_NONCONSTANT),
             "Expected non-constant object." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_DATATYPES_NOT_EQUAL),
             "Detected unequal object datatypes." );
    sprintf( FLA_Error_string_for_code(FLA_DIVIDE_BY_ZERO),
             "Encountered request to invert zero scalar object." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_ELEMTYPES_NOT_EQUAL),
             "Detected unequal object elemtypes." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_PIVOT_INDEX_RANGE),
             "Invalid pivot index range." );
    sprintf( FLA_Error_string_for_code(FLA_HOUSEH_PANEL_MATRIX_TOO_SMALL),
             "Block-panel Householder matrix is too small." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_OBJECT_LENGTH),
             "Expected different object length." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_OBJECT_WIDTH),
             "Expected different object width." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_ERROR_CHECKING_LEVEL),
             "Invalid error checking level." );
    sprintf( FLA_Error_string_for_code(FLA_ATTEMPTED_OVER_REPART_2X2),
             "Detected attempt to (2x2) repartition more matrix into A11 than exists in source quadrant." );
    sprintf( FLA_Error_string_for_code(FLA_ATTEMPTED_OVER_REPART_2X1),
             "Detected attempt to (2x1) repartition more matrix into A1 than exists in source partition." );
    sprintf( FLA_Error_string_for_code(FLA_ATTEMPTED_OVER_REPART_1X2),
             "Detected attempt to (1x2) repartition more matrix into A1 than exists in source partition." );
    sprintf( FLA_Error_string_for_code(FLA_EXTERNAL_LAPACK_NOT_IMPLEMENTED),
             "External LAPACK wrapper was invoked despite not being enabled at configure-time." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_ROW_STRIDE),
             "Invalid matrix row stride." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_COL_STRIDE),
             "Invalid matrix column stride." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_STRIDE_COMBINATION),
             "Invalid combination of matrix row and column strides." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_VECTOR_DIM),
             "Detected vector of unexpected length/width." );
    sprintf( FLA_Error_string_for_code(FLA_EXPECTED_ROW_VECTOR),
             "Expected object to be a row vector." );
    sprintf( FLA_Error_string_for_code(FLA_EXPECTED_COL_VECTOR),
             "Expected object to be a column vector." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_INVERSE),
             "Invalid inverse parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_MALLOC_GPU_RETURNED_NULL_POINTER),
             "Attempt to allocate memory on GPU failed." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_EVD_TYPE),
             "Invalid eigenvalue/vector type parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_SVD_TYPE),
             "Invalid singular vector type parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_MACHVAL),
             "Invalid machine parameter value." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_DIAG_OFFSET),
             "Invalid diagonal offset." );
    sprintf( FLA_Error_string_for_code(FLA_EXPECTED_COL_STORAGE),
             "Expected object to be stored by columns." );
    sprintf( FLA_Error_string_for_code(FLA_EXPECTED_ROW_STORAGE),
             "Expected object to be stored by rows." );
    sprintf( FLA_Error_string_for_code(FLA_LAPAC2FLAME_INVALID_RETURN),
             "Invalid return value from lapack2flame interface." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_SVD_TYPE_COMBINATION),
             "Invalid svd type parameter combination (both parameters are FLA_SVD_VECTORS_OVERWRITE)." );
    sprintf( FLA_Error_string_for_code(FLA_INVALID_SVD_TYPE_AND_TRANS_COMBINATION),
             "Invalid svd type parameters (FLA_SVD_VECTORS_OVERWRITE) and trans parameters combination." );
    sprintf( FLA_Error_string_for_code(FLA_OBJECT_NOT_COMPARABLE),
             "Expected real or int object." );
}

References FLA_Error_string_for_code().

Referenced by FLA_Init().

◆ FLA_Error_string_for_code()

char * FLA_Error_string_for_code ( int code )

{
    return fla_error_string[-code];
}

References fla_error_string.

Referenced by FLA_Check_error_code_helper(), and FLA_Error_messages_init().

◆ FLA_Finalize()

void FLA_Finalize ( void )

{
  if ( FLA_initialized == FALSE ) return;
 
  FLA_initialized = FALSE;
 
  FLA_Finalize_constants();
 
  FLA_Cntl_finalize();
 
#ifdef FLA_ENABLE_SUPERMATRIX
  FLASH_Queue_finalize();
#endif
 
  FLA_Memory_leak_counter_finalize();
}

References FLA_Cntl_finalize(), FLA_Finalize_constants(), FLA_Memory_leak_counter_finalize(), and FLASH_Queue_finalize().

Referenced by FLA_Finalize_safe().

◆ FLA_Finalize_constants()

void FLA_Finalize_constants ( void )

{
  FLA_Obj_free( &FLA_THREE );
  FLA_Obj_free( &FLA_TWO );
  FLA_Obj_free( &FLA_ONE );
  FLA_Obj_free( &FLA_ONE_HALF );
  FLA_Obj_free( &FLA_ZERO );
  FLA_Obj_free( &FLA_MINUS_ONE_HALF );
  FLA_Obj_free( &FLA_MINUS_ONE );
  FLA_Obj_free( &FLA_MINUS_TWO );
  FLA_Obj_free( &FLA_MINUS_THREE );
 
  FLA_Obj_free( &FLA_EPSILON );
  FLA_Obj_free( &FLA_SAFE_MIN );
  FLA_Obj_free( &FLA_SAFE_MIN_SQUARE );
  FLA_Obj_free( &FLA_SAFE_INV_MIN );
  FLA_Obj_free( &FLA_SAFE_INV_MIN_SQUARE );
  FLA_Obj_free( &FLA_UNDERFLOW_THRES );
  FLA_Obj_free( &FLA_OVERFLOW_THRES );  
  FLA_Obj_free( &FLA_UNDERFLOW_SQUARE_THRES );
  FLA_Obj_free( &FLA_OVERFLOW_SQUARE_THRES );
}

References FLA_EPSILON, FLA_MINUS_ONE, FLA_MINUS_ONE_HALF, FLA_MINUS_THREE, FLA_MINUS_TWO, FLA_Obj_free(), FLA_ONE, FLA_ONE_HALF, FLA_OVERFLOW_SQUARE_THRES, FLA_OVERFLOW_THRES, FLA_SAFE_INV_MIN, FLA_SAFE_INV_MIN_SQUARE, FLA_SAFE_MIN, FLA_SAFE_MIN_SQUARE, FLA_THREE, FLA_TWO, FLA_UNDERFLOW_SQUARE_THRES, FLA_UNDERFLOW_THRES, and FLA_ZERO.

Referenced by FLA_Finalize().

◆ FLA_Finalize_numerical_constants()

void FLA_Finalize_numerical_constants ( void )

◆ FLA_Finalize_safe()

void FLA_Finalize_safe ( FLA_Error init_result )

{
  if ( init_result == FLA_SUCCESS )
    FLA_Finalize();
}

References FLA_Finalize().

◆ FLA_free()

void FLA_free ( void * ptr )

{
  // We don't want to decrement the counter if the buffer is NULL.
  // This is because it's likely that the buffer was never allocated
  // a valid pointer to begin with, which means FLA_malloc() was never
  // called and thus the counter was never incremented. Or, it means
  // memory was allocated but the address has since been lost, which
  // means that we can't free it anyway.
  if ( ptr != NULL )
  {
    // Free the memory addressed by ptr.
    free( ptr );
 
    if ( FLA_Memory_leak_counter_status() == TRUE )
    {
#ifdef FLA_ENABLE_MULTITHREADING
      FLA_Lock_acquire( &fla_mem_leak_counter_lock );
      fla_mem_leak_counter -= 1;
      FLA_Lock_release( &fla_mem_leak_counter_lock );
#else
      fla_mem_leak_counter -= 1;
#endif
    }
  }
}

References FLA_Lock_acquire(), FLA_Lock_release(), and FLA_Memory_leak_counter_status().

Referenced by FLA_Apply_H2_UT_l_opc_var1(), FLA_Apply_H2_UT_l_opd_var1(), FLA_Apply_H2_UT_l_ops_var1(), FLA_Apply_H2_UT_l_opz_var1(), FLA_Apply_H2_UT_r_opc_var1(), FLA_Apply_H2_UT_r_opd_var1(), FLA_Apply_H2_UT_r_ops_var1(), FLA_Apply_H2_UT_r_opz_var1(), FLA_Bidiag_UT_u_step_ofc_var2(), FLA_Bidiag_UT_u_step_ofc_var3(), FLA_Bidiag_UT_u_step_ofc_var4(), FLA_Bidiag_UT_u_step_ofd_var2(), FLA_Bidiag_UT_u_step_ofd_var3(), FLA_Bidiag_UT_u_step_ofd_var4(), FLA_Bidiag_UT_u_step_ofs_var2(), FLA_Bidiag_UT_u_step_ofs_var3(), FLA_Bidiag_UT_u_step_ofs_var4(), FLA_Bidiag_UT_u_step_ofz_var2(), FLA_Bidiag_UT_u_step_ofz_var3(), FLA_Bidiag_UT_u_step_ofz_var4(), FLA_Bidiag_UT_u_step_opc_var1(), FLA_Bidiag_UT_u_step_opc_var2(), FLA_Bidiag_UT_u_step_opc_var3(), FLA_Bidiag_UT_u_step_opc_var4(), FLA_Bidiag_UT_u_step_opc_var5(), FLA_Bidiag_UT_u_step_opd_var1(), FLA_Bidiag_UT_u_step_opd_var2(), FLA_Bidiag_UT_u_step_opd_var3(), FLA_Bidiag_UT_u_step_opd_var4(), FLA_Bidiag_UT_u_step_opd_var5(), FLA_Bidiag_UT_u_step_ops_var1(), FLA_Bidiag_UT_u_step_ops_var2(), FLA_Bidiag_UT_u_step_ops_var3(), FLA_Bidiag_UT_u_step_ops_var4(), FLA_Bidiag_UT_u_step_ops_var5(), FLA_Bidiag_UT_u_step_opz_var1(), FLA_Bidiag_UT_u_step_opz_var2(), FLA_Bidiag_UT_u_step_opz_var3(), FLA_Bidiag_UT_u_step_opz_var4(), FLA_Bidiag_UT_u_step_opz_var5(), FLA_Blocksize_free(), FLA_Cntl_obj_free(), FLA_Hess_UT_step_ofc_var2(), FLA_Hess_UT_step_ofc_var3(), FLA_Hess_UT_step_ofc_var4(), FLA_Hess_UT_step_ofd_var2(), FLA_Hess_UT_step_ofd_var3(), FLA_Hess_UT_step_ofd_var4(), FLA_Hess_UT_step_ofs_var2(), FLA_Hess_UT_step_ofs_var3(), FLA_Hess_UT_step_ofs_var4(), FLA_Hess_UT_step_ofz_var2(), FLA_Hess_UT_step_ofz_var3(), FLA_Hess_UT_step_ofz_var4(), FLA_Hess_UT_step_opc_var2(), FLA_Hess_UT_step_opc_var3(), FLA_Hess_UT_step_opc_var4(), FLA_Hess_UT_step_opc_var5(), FLA_Hess_UT_step_opd_var2(), FLA_Hess_UT_step_opd_var3(), FLA_Hess_UT_step_opd_var4(), FLA_Hess_UT_step_opd_var5(), FLA_Hess_UT_step_ops_var2(), FLA_Hess_UT_step_ops_var3(), FLA_Hess_UT_step_ops_var4(), FLA_Hess_UT_step_ops_var5(), FLA_Hess_UT_step_opz_var2(), FLA_Hess_UT_step_opz_var3(), FLA_Hess_UT_step_opz_var4(), FLA_Hess_UT_step_opz_var5(), FLA_Obj_free(), FLA_Obj_free_buffer(), FLA_Obj_free_without_buffer(), FLA_realloc(), FLA_Tridiag_UT_l_step_ofc_var2(), FLA_Tridiag_UT_l_step_ofd_var2(), FLA_Tridiag_UT_l_step_ofs_var2(), FLA_Tridiag_UT_l_step_ofz_var2(), FLA_Tridiag_UT_l_step_opc_var1(), FLA_Tridiag_UT_l_step_opc_var2(), FLA_Tridiag_UT_l_step_opc_var3(), FLA_Tridiag_UT_l_step_opd_var1(), FLA_Tridiag_UT_l_step_opd_var2(), FLA_Tridiag_UT_l_step_opd_var3(), FLA_Tridiag_UT_l_step_ops_var1(), FLA_Tridiag_UT_l_step_ops_var2(), FLA_Tridiag_UT_l_step_ops_var3(), FLA_Tridiag_UT_l_step_opz_var1(), FLA_Tridiag_UT_l_step_opz_var2(), FLA_Tridiag_UT_l_step_opz_var3(), FLASH_Obj_create_conf_to(), FLASH_Obj_create_helper(), FLASH_Obj_free(), FLASH_Part_create_1x2(), FLASH_Part_create_2x1(), FLASH_Part_create_2x2(), FLASH_Queue_exec(), FLASH_Queue_exec_gpu(), FLASH_Queue_exec_parallel(), FLASH_Queue_exec_simulation(), FLASH_Queue_push_output(), FLASH_Task_free(), and FLASH_Task_free_parallel().

◆ FLA_Init()

void FLA_Init ( void )

{
  if ( FLA_initialized == TRUE ) return;
  
  FLA_initialized = TRUE;
 
  FLA_Error_messages_init();
 
  FLA_Memory_leak_counter_init();
 
  FLA_Init_constants();
 
  FLA_Cntl_init();
 
#if FLA_VECTOR_INTRINSIC_TYPE == FLA_SSE_INTRINSICS
  _MM_SET_FLUSH_ZERO_MODE( _MM_FLUSH_ZERO_ON );
#endif
 
#ifdef FLA_ENABLE_SUPERMATRIX
  FLASH_Queue_init();
#endif
}

References FLA_Cntl_init(), FLA_Error_messages_init(), FLA_Init_constants(), FLA_Memory_leak_counter_init(), and FLASH_Queue_init().

Referenced by FLA_Init_safe().

◆ FLA_Init_constants()

void FLA_Init_constants ( void )

{
  FLA_Obj_create_constant(  3.0, &FLA_THREE );
  FLA_Obj_create_constant(  2.0, &FLA_TWO );
  FLA_Obj_create_constant(  1.0, &FLA_ONE );
  FLA_Obj_create_constant(  0.5, &FLA_ONE_HALF );
  FLA_Obj_create_constant(  0.0, &FLA_ZERO );
  FLA_Obj_create_constant( -0.5, &FLA_MINUS_ONE_HALF );
  FLA_Obj_create_constant( -1.0, &FLA_MINUS_ONE );
  FLA_Obj_create_constant( -2.0, &FLA_MINUS_TWO );
  FLA_Obj_create_constant( -3.0, &FLA_MINUS_THREE );
 
 
  { 
    float  
      eps_f, 
      sfmin_f = FLT_MIN, sfmin_f2,
      small_f = ( 1.0F / FLT_MAX ), 
      under_f = FLT_MIN, 
      over_f  = FLT_MAX;
 
    double 
      eps_d, 
      sfmin_d = DBL_MIN, sfmin_d2,
      small_d = ( 1.0  / DBL_MAX ), 
      under_d = DBL_MIN,
      over_d  = DBL_MAX;
 
    if ( FLT_ROUNDS == 1 )
    {
      eps_f = FLT_EPSILON*0.5F;
      eps_d = DBL_EPSILON*0.5;
    }
    else 
    {
      eps_f = FLT_EPSILON;
      eps_d = DBL_EPSILON;
    }
 
    if ( small_f >= sfmin_f ) sfmin_f = small_f * ( 1.0F + eps_f );
    if ( small_d >= sfmin_d ) sfmin_d = small_d * ( 1.0  + eps_d );
 
    sfmin_f  = sfmin_f/eps_f;
    sfmin_d  = sfmin_d/eps_d;
 
    sfmin_f2 = sqrt( sfmin_f );
    sfmin_d2 = sqrt( sfmin_d );
 
    FLA_Obj_create_constant_ext( eps_f,           eps_d,           &FLA_EPSILON );
 
    FLA_Obj_create_constant_ext( sfmin_f,         sfmin_d,         &FLA_SAFE_MIN );
    FLA_Obj_create_constant_ext( 1.0F/sfmin_f,    1.0/sfmin_d,     &FLA_SAFE_INV_MIN );
 
    FLA_Obj_create_constant_ext( sfmin_f2,        sfmin_d2,        &FLA_SAFE_MIN_SQUARE );
    FLA_Obj_create_constant_ext( 1.0F/sfmin_f2,   1.0/sfmin_d2,    &FLA_SAFE_INV_MIN_SQUARE );
    
    FLA_Obj_create_constant_ext( under_f,         under_d,         &FLA_UNDERFLOW_THRES );
    FLA_Obj_create_constant_ext( over_f,          over_d,          &FLA_OVERFLOW_THRES );
 
    FLA_Obj_create_constant_ext( sqrt( under_f ), sqrt( under_d ), &FLA_UNDERFLOW_SQUARE_THRES );
    FLA_Obj_create_constant_ext( sqrt( over_f ),  sqrt( over_d ),  &FLA_OVERFLOW_SQUARE_THRES );
  } 
}

References FLA_EPSILON, FLA_MINUS_ONE, FLA_MINUS_ONE_HALF, FLA_MINUS_THREE, FLA_MINUS_TWO, FLA_Obj_create_constant(), FLA_Obj_create_constant_ext(), FLA_ONE, FLA_ONE_HALF, FLA_OVERFLOW_SQUARE_THRES, FLA_OVERFLOW_THRES, FLA_SAFE_INV_MIN, FLA_SAFE_INV_MIN_SQUARE, FLA_SAFE_MIN, FLA_SAFE_MIN_SQUARE, FLA_THREE, FLA_TWO, FLA_UNDERFLOW_SQUARE_THRES, FLA_UNDERFLOW_THRES, and FLA_ZERO.

Referenced by FLA_Init().

◆ FLA_Init_numerical_constants()

void FLA_Init_numerical_constants ( void )

◆ FLA_Init_safe()

void FLA_Init_safe ( FLA_Error * init_result )

{
  if ( FLA_Initialized() )
  {
    *init_result = FLA_FAILURE;
  }
  else
  {
    FLA_Init();
    *init_result = FLA_SUCCESS;
  }
}

References FLA_Init(), and FLA_Initialized().

◆ FLA_Initialized()

FLA_Bool FLA_Initialized ( void )

{
  return FLA_initialized;
}

Referenced by FLA_Init_safe().

◆ FLA_is_owner()

FLA_Bool FLA_is_owner ( void )

{
  if ( RCCE_ue() == 0 )
    return TRUE;
  return FALSE;
}

References RCCE_ue().

Referenced by FLA_Obj_create_complex_constant(), FLA_Obj_create_constant(), FLA_Obj_create_constant_ext(), FLA_Obj_create_copy_of(), FLASH_Axpy_hierarchy(), FLASH_Copy_hierarchy(), FLASH_Queue_exec(), and FLASH_Queue_init_tasks().

◆ FLA_Lock_acquire()

void FLA_Lock_acquire ( FLA_Lock * fla_lock_ptr )

{
#if   FLA_MULTITHREADING_MODEL == FLA_OPENMP
  omp_set_lock( &(fla_lock_ptr->lock) );
#elif FLA_MULTITHREADING_MODEL == FLA_PTHREADS
  pthread_mutex_lock( &(fla_lock_ptr->lock) );
#endif
}

References FLA_Lock_s::lock.

Referenced by FLA_free(), FLA_malloc(), FLASH_Queue_check_block_gpu(), FLASH_Queue_exec_gpu(), FLASH_Queue_exec_parallel_function(), FLASH_Queue_flush_block_gpu(), FLASH_Queue_flush_gpu(), FLASH_Queue_invalidate_block_gpu(), FLASH_Queue_mark_gpu(), FLASH_Queue_update_block_gpu(), FLASH_Queue_update_cache_block(), FLASH_Queue_wait_dequeue(), FLASH_Queue_work_stealing(), FLASH_Task_free_parallel(), FLASH_Task_update_binding(), and FLASH_Task_update_dependencies().

◆ FLA_Lock_destroy()

void FLA_Lock_destroy ( FLA_Lock * fla_lock_ptr )

{
#if   FLA_MULTITHREADING_MODEL == FLA_OPENMP
  omp_destroy_lock( &(fla_lock_ptr->lock) );
#elif FLA_MULTITHREADING_MODEL == FLA_PTHREADS
  pthread_mutex_destroy( &(fla_lock_ptr->lock) );
#endif
}

References FLA_Lock_s::lock.

Referenced by FLA_Memory_leak_counter_finalize(), and FLASH_Queue_exec().

◆ FLA_Lock_init()

void FLA_Lock_init ( FLA_Lock * fla_lock_ptr )

{
#if   FLA_MULTITHREADING_MODEL == FLA_OPENMP
  omp_init_lock( &(fla_lock_ptr->lock) );
#elif FLA_MULTITHREADING_MODEL == FLA_PTHREADS
  pthread_mutex_init( &(fla_lock_ptr->lock), NULL );
#endif
}

References FLA_Lock_s::lock.

Referenced by FLA_Memory_leak_counter_init(), and FLASH_Queue_exec().

◆ FLA_Lock_release()

void FLA_Lock_release ( FLA_Lock * fla_lock_ptr )

{
#if   FLA_MULTITHREADING_MODEL == FLA_OPENMP
  omp_unset_lock( &(fla_lock_ptr->lock) );
#elif FLA_MULTITHREADING_MODEL == FLA_PTHREADS
  pthread_mutex_unlock( &(fla_lock_ptr->lock) );
#endif
}

References FLA_Lock_s::lock.

Referenced by FLA_free(), FLA_malloc(), FLASH_Queue_check_block_gpu(), FLASH_Queue_exec_gpu(), FLASH_Queue_exec_parallel_function(), FLASH_Queue_flush_block_gpu(), FLASH_Queue_flush_gpu(), FLASH_Queue_invalidate_block_gpu(), FLASH_Queue_mark_gpu(), FLASH_Queue_update_block_gpu(), FLASH_Queue_update_cache_block(), FLASH_Queue_wait_dequeue(), FLASH_Queue_work_stealing(), FLASH_Task_free_parallel(), FLASH_Task_update_binding(), and FLASH_Task_update_dependencies().

◆ FLA_malloc()

void * FLA_malloc ( size_t size )

{
  void*     ptr = NULL;
  FLA_Error e_val;
#ifdef FLA_ENABLE_MEMORY_ALIGNMENT
  int       r_val;
#endif
 
  // In practice, the size argument should very rarely be zero. However, if the
  // calling code does request a memory region of zero length, we short-circut
  // the actual allocation request and just return NULL. Hopefully, the calling
  // code is written such that the pointer is never dereferenced. At free()-time
  // everything will be fine, as calling free() with a NULL pointer is safe.
  // Also note that we do NOT increment the memory leak counter before returning.
  // (Likewise, we will not decrement the counter when a NULL pointer is freed.)
  if ( size == 0 ) return NULL;
 
#ifdef FLA_ENABLE_MEMORY_ALIGNMENT
 
  // Allocate size bytes of memory. Here, we call posix_memalign() if
  // memory alignment was requested at configure-time, providing the
  // alignment boundary value given by the user. posix_memalign() also
  // returns an error code, which is how it signals that something
  // went wrong. Compare to malloc(), which does this by simply returning
  // a NULL pointer.
  r_val = posix_memalign( &ptr, ( size_t ) FLA_MEMORY_ALIGNMENT_BOUNDARY, size );
 
  // Check the return value of posix_memalign() for evidence that the
  // request failed.
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
  {
    e_val = FLA_Check_posix_memalign_failure( r_val );
    FLA_Check_error_code( e_val );
  }
 
#else
 
  // Allocate size bytes of memory. Note that malloc() only guarantees 8-byte
  // alignment.
  ptr = malloc( size );
 
  // It may not seem useful to have a check for a null pointer here, given
  // that such an occurance would cause the file and line of the error to
  // be reported as the below line of the current file instead of the file
  // and line number of the calling code. However, consider that in the
  // unlikely event that malloc() does return a null pointer, the user will
  // have much bigger problems on his hands (e.g. an exhausted memory heap)
  // than needing to know exactly what line in the library triggered error.
  // Note that such a line in the application code is likely not the root
  // source of the problem anyway (ie: not the reason why the heap is full).
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
  {
    e_val = FLA_Check_malloc_pointer( ptr );
    FLA_Check_error_code( e_val );
  }
 
#endif
 
  // Update the memory leak counter if it is enabled, and do so thread-safely
  // if multithreading is enabled.
  if ( FLA_Memory_leak_counter_status() == TRUE )
  {
#ifdef FLA_ENABLE_MULTITHREADING
    FLA_Lock_acquire( &fla_mem_leak_counter_lock );
    fla_mem_leak_counter += 1;
    FLA_Lock_release( &fla_mem_leak_counter_lock );
#else
    fla_mem_leak_counter += 1;
#endif
  }
  
  // Return the pointer to the new memory region returned by malloc().
  return ptr;
}

References FLA_Check_error_level(), FLA_Check_malloc_pointer(), FLA_Check_posix_memalign_failure(), FLA_Lock_acquire(), FLA_Lock_release(), and FLA_Memory_leak_counter_status().

◆ FLA_Memory_leak_counter_finalize()

void FLA_Memory_leak_counter_finalize ( void )

{
  // Output the memory leak counter, but only if it's currently enabled.
  if ( FLA_Memory_leak_counter_status() == TRUE )
  {
    fprintf( stderr, "libflame: memory leak counter: %d\n", fla_mem_leak_counter );
    fflush( stderr );
  }
 
  // Destroy the memory leak counter lock, but only if we have locks in
  // the first place (ie: only if multithreading is enabled).
#ifdef FLA_ENABLE_MULTITHREADING
  FLA_Lock_destroy( &fla_mem_leak_counter_lock );
#endif
 
  // We leave the fla_mem_leak_counter_status variable alone.
 
  // Reset the counter, just for good measure.
  fla_mem_leak_counter = 0;
}

References FLA_Lock_destroy(), and FLA_Memory_leak_counter_status().

Referenced by FLA_Finalize().

◆ FLA_Memory_leak_counter_init()

void FLA_Memory_leak_counter_init ( void )

{
  // Initialize the memory leak counter to zero.
  fla_mem_leak_counter = 0;
 
  // Initialize the memory leak counter status to whatever was requested at
  // configure-time.
#ifdef FLA_ENABLE_MEMORY_LEAK_COUNTER
  fla_mem_leak_counter_status = TRUE;
#else
  fla_mem_leak_counter_status = FALSE;
#endif
 
  // Initialize the memory leak counter lock, but only if we have locks in
  // the first place (ie: only if multithreading is enabled).
#ifdef FLA_ENABLE_MULTITHREADING
  FLA_Lock_init( &fla_mem_leak_counter_lock );
#endif
}

References FLA_Lock_init().

Referenced by FLA_Init().

◆ FLA_Memory_leak_counter_set()

FLA_Bool FLA_Memory_leak_counter_set ( FLA_Bool new_status )

{
  FLA_Bool old_status;
 
  // Grab the current status.
  old_status = fla_mem_leak_counter_status;
 
  // Only make the change if the status is boolean. If the user provides us
  // with garbage, we do nothing.
  if ( new_status == TRUE || new_status == FALSE )
    fla_mem_leak_counter_status = new_status;
 
  return old_status;
}

◆ FLA_Memory_leak_counter_status()

FLA_Bool FLA_Memory_leak_counter_status ( void )

{
  return fla_mem_leak_counter_status;
}

Referenced by FLA_free(), FLA_malloc(), and FLA_Memory_leak_counter_finalize().

◆ FLA_Merge_1x2()

FLA_Error FLA_Merge_1x2	(	FLA_Obj	AL,
		FLA_Obj	AR,
		FLA_Obj *	A
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Merge_1x2_check( AL, AR,    A );
 
  A->m    = AL.m;
  A->n    = AL.n + AR.n;
  A->offm = AL.offm;
  A->offn = AL.offn;
  A->base = AL.base;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Merge_1x2_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

Referenced by FLA_Accum_T_UT_fr_blk_var2(), FLA_LQ_UT_blk_var1(), FLA_LQ_UT_blk_var2(), FLA_LQ_UT_blk_var3(), and FLA_QR_UT_piv_unb_var1().

◆ FLA_Merge_1x2_check()

FLA_Error FLA_Merge_1x2_check	(	FLA_Obj	AL,
		FLA_Obj	AR,
		FLA_Obj *	A
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( AL );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( AR );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_base_buffer_mismatch( AL, AR );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_adjacent_objects_1x2( AL, AR );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_adjacent_objects_1x2(), FLA_Check_base_buffer_mismatch(), FLA_Check_null_pointer(), and FLA_Check_valid_object_datatype().

Referenced by FLA_Merge_1x2().

◆ FLA_Merge_2x1()

FLA_Error FLA_Merge_2x1	(	FLA_Obj	AT,
		FLA_Obj	AB,
		FLA_Obj *	A
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Merge_2x1_check( AT,
                         AB,   A );
 
  A->m    = AT.m + AB.m;
  A->n    = AT.n;
  A->offm = AT.offm;
  A->offn = AT.offn;
  A->base = AT.base;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Merge_2x1_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

Referenced by FLA_Accum_T_UT_fc_blk_var2(), FLA_Bidiag_UT_u_step_unb_var4(), FLA_Bidiag_UT_u_step_unb_var5(), FLA_CAQR2_UT_blk_var1(), FLA_CAQR2_UT_unb_var1(), FLA_Hess_UT_blk_var5(), FLA_Hess_UT_step_unb_var4(), FLA_LU_piv_blk_var3(), FLA_LU_piv_blk_var4(), FLA_LU_piv_blk_var5(), FLA_LU_piv_unb_var3(), FLA_LU_piv_unb_var3b(), FLA_LU_piv_unb_var4(), FLA_LU_piv_unb_var5(), FLA_QR_UT_blk_var1(), FLA_QR_UT_blk_var2(), FLA_QR_UT_blk_var3(), FLA_QR_UT_form_Q_blk_var1(), FLA_QR_UT_piv_unb_var2(), and FLA_Tridiag_UT_l_step_unb_var3().

◆ FLA_Merge_2x1_check()

FLA_Error FLA_Merge_2x1_check	(	FLA_Obj	AT,
		FLA_Obj	AB,
		FLA_Obj *	A
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( AT );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( AB );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_base_buffer_mismatch( AT, AB );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_adjacent_objects_2x1( AT,
                                          AB );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_adjacent_objects_2x1(), FLA_Check_base_buffer_mismatch(), FLA_Check_null_pointer(), and FLA_Check_valid_object_datatype().

Referenced by FLA_Merge_2x1().

◆ FLA_Merge_2x2()

FLA_Error FLA_Merge_2x2	(	FLA_Obj	A11,
		FLA_Obj	A12,
		FLA_Obj	A21,
		FLA_Obj	A22,
		FLA_Obj *	A
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Merge_2x2_check( A11, A12,
                         A21, A22,    A );
 
  A->m      = A11.m + A21.m;
  A->n      = A11.n + A12.n;
  A->offm   = A11.offm;
  A->offn   = A11.offn;
  A->base   = A11.base;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Merge_2x2_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Merge_2x2_check()

FLA_Error FLA_Merge_2x2_check	(	FLA_Obj	A11,
		FLA_Obj	A12,
		FLA_Obj	A21,
		FLA_Obj	A22,
		FLA_Obj *	A
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( A11 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A21 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A12 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( A22 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_base_buffer_mismatch( A11, A21 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_base_buffer_mismatch( A12, A22 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_base_buffer_mismatch( A11, A12 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_adjacent_objects_2x2( A11, A12,
                                          A21, A22 );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_adjacent_objects_2x2(), FLA_Check_base_buffer_mismatch(), FLA_Check_null_pointer(), and FLA_Check_valid_object_datatype().

Referenced by FLA_Merge_2x2().

◆ FLA_Obj_attach_buffer()

FLA_Error FLA_Obj_attach_buffer	(	void *	buffer,
		dim_t	rs,
		dim_t	cs,
		FLA_Obj *	obj
	)

{
  dim_t m, n;
 
  m = FLA_Obj_length( *obj );
  n = FLA_Obj_width( *obj );
 
  // Adjust the strides, if necessary.
  FLA_adjust_strides( m, n, &rs, &cs );
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_attach_buffer_check( buffer, rs, cs, obj );
 
  obj->base->buffer      = buffer;
  obj->base->rs          = rs;
  obj->base->cs          = cs;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Obj_struct::buffer, FLA_Obj_struct::cs, FLA_adjust_strides(), FLA_Check_error_level(), FLA_Obj_attach_buffer_check(), FLA_Obj_length(), FLA_Obj_width(), and FLA_Obj_struct::rs.

Referenced by FLA_Axpy_buffer_to_object(), FLA_Axpy_object_to_buffer(), FLA_Copy_buffer_to_object(), FLA_Copy_object_to_buffer(), FLASH_Axpy_buffer_to_hier(), FLASH_Axpy_hier_to_buffer(), FLASH_Copy_buffer_to_hier(), FLASH_Copy_hier_to_buffer(), FLASH_Obj_attach_buffer(), FLASH_Obj_attach_buffer_hierarchy(), and FLASH_Obj_create_hierarchy().

◆ FLA_Obj_attach_buffer_check()

FLA_Error FLA_Obj_attach_buffer_check	(	void *	buffer,
		dim_t	rs,
		dim_t	cs,
		FLA_Obj *	obj
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_matrix_strides( FLA_Obj_length( *obj ), FLA_Obj_width( *obj ), rs, cs );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_matrix_strides(), FLA_Check_null_pointer(), FLA_Obj_length(), and FLA_Obj_width().

Referenced by FLA_Obj_attach_buffer().

◆ FLA_Obj_base_buffer()

void * FLA_Obj_base_buffer ( FLA_Obj obj )

{
  return (obj.base)->buffer;
}

References FLA_Obj_view::base.

Referenced by FLASH_Obj_base_scalar_length(), FLASH_Obj_base_scalar_width(), FLASH_Obj_blocksizes(), FLASH_Obj_depth(), FLASH_Obj_extract_buffer(), FLASH_Obj_free_hierarchy(), FLASH_Obj_scalar_length_tl(), and FLASH_Obj_scalar_width_tl().

◆ FLA_Obj_base_length()

dim_t FLA_Obj_base_length ( FLA_Obj obj )

{
    return (obj.base)->m;
}

References FLA_Obj_view::base.

Referenced by FLASH_Obj_base_scalar_length(), FLASH_Obj_blocksizes(), and FLASH_Obj_scalar_length_tl().

◆ FLA_Obj_base_width()

dim_t FLA_Obj_base_width ( FLA_Obj obj )

{
    return (obj.base)->n;
}

References FLA_Obj_view::base.

Referenced by FLASH_Obj_base_scalar_width(), FLASH_Obj_blocksizes(), and FLASH_Obj_scalar_width_tl().

◆ FLA_Obj_buffer_at_view()

void * FLA_Obj_buffer_at_view ( FLA_Obj obj )

{
  char*  buffer;
  size_t elem_size, offm, offn, rs, cs;
  size_t byte_offset;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_buffer_at_view_check( obj );
 
  elem_size   = ( size_t ) FLA_Obj_elem_size( obj );
  rs          = ( size_t ) FLA_Obj_row_stride( obj );
  cs          = ( size_t ) FLA_Obj_col_stride( obj );
  offm        = ( size_t ) obj.offm;
  offn        = ( size_t ) obj.offn;
 
  byte_offset = elem_size * ( offn * cs + offm * rs );
 
  buffer      = ( char * ) (obj.base)->buffer;
 
  return ( void* ) ( buffer + byte_offset );
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Obj_buffer_at_view_check(), FLA_Obj_col_stride(), FLA_Obj_elem_size(), FLA_Obj_row_stride(), FLA_Obj_view::offm, and FLA_Obj_view::offn.

Referenced by FLA_Apply_pivots_macro_external(), FLA_CAQR_UT_inc_init_structure(), FLA_Obj_is_identical(), FLA_Obj_is_overlapped(), FLASH_Obj_attach_buffer_hierarchy(), FLASH_Obj_create_hierarchy(), FLASH_Obj_show_hierarchy(), FLASH_print_struct(), FLASH_print_struct_helper(), FLASH_Queue_read_gpu(), and FLASH_Queue_write_gpu().

◆ FLA_Obj_buffer_at_view_check()

FLA_Error FLA_Obj_buffer_at_view_check ( FLA_Obj obj )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj.base );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, and FLA_Check_null_pointer().

Referenced by FLA_Obj_buffer_at_view().

◆ FLA_Obj_buffer_is_null()

FLA_Bool FLA_Obj_buffer_is_null ( FLA_Obj obj )

{
  FLA_Bool r_val;
 
  if      ( obj.base == NULL )
    r_val = TRUE;
  else if ( (obj.base)->buffer == NULL )
    r_val = TRUE;
  else
    r_val = FALSE;
 
  return r_val;
}

References FLA_Obj_view::base.

◆ FLA_Obj_col_offset()

dim_t FLA_Obj_col_offset ( FLA_Obj obj )

{
    return obj.offn;
}

References FLA_Obj_view::offn.

Referenced by FLASH_Obj_adjust_views_hierarchy(), and FLASH_Obj_scalar_col_offset().

◆ FLA_Obj_col_stride()

dim_t FLA_Obj_col_stride ( FLA_Obj obj )

{
  return (obj.base)->cs;
}

References FLA_Obj_view::base.

Referenced by FLA_Accum_T_UT_fc_opt_var1(), FLA_Accum_T_UT_fr_opt_var1(), FLA_Add_to_diag(), FLA_Apply_diag_matrix(), FLA_Apply_G_lf_blk_var3(), FLA_Apply_G_lf_opt_var1(), FLA_Apply_G_rf_asm_var1(), FLA_Apply_G_rf_asm_var2(), FLA_Apply_G_rf_asm_var3(), FLA_Apply_G_rf_asm_var3b(), FLA_Apply_G_rf_asm_var6(), FLA_Apply_G_rf_asm_var6b(), FLA_Apply_G_rf_asm_var9(), FLA_Apply_G_rf_asm_var9b(), FLA_Apply_G_rf_blk_var1(), FLA_Apply_G_rf_blk_var2(), FLA_Apply_G_rf_blk_var3(), FLA_Apply_G_rf_blk_var3b(), FLA_Apply_G_rf_blk_var6(), FLA_Apply_G_rf_blk_var6b(), FLA_Apply_G_rf_blk_var9(), FLA_Apply_G_rf_blk_var9b(), FLA_Apply_G_rf_opt_var1(), FLA_Apply_G_rf_opt_var2(), FLA_Apply_G_rf_opt_var3(), FLA_Apply_G_rf_opt_var6(), FLA_Apply_G_rf_opt_var9(), FLA_Apply_H2_UT_l_opt_var1(), FLA_Apply_H2_UT_r_opt_var1(), FLA_Apply_HUD_UT_l_opt_var1(), FLA_Apply_pivots_ln_opt_var1(), FLA_Apply_pivots_lt_opt_var1(), FLA_Apply_pivots_macro_external(), FLA_Apply_pivots_rn_opt_var1(), FLA_Apply_pivots_rt_opt_var1(), FLA_Apply_pivots_unb_external(), FLA_Apply_Q_blk_external(), FLA_Axpy_external(), FLA_Axpyrt_external(), FLA_Axpys_external(), FLA_Axpyt_external(), FLA_Bidiag_apply_U_external(), FLA_Bidiag_apply_V_external(), FLA_Bidiag_blk_external(), FLA_Bidiag_form_U_external(), FLA_Bidiag_form_V_external(), FLA_Bidiag_unb_external(), FLA_Bidiag_UT_l_extract_diagonals(), FLA_Bidiag_UT_l_extract_real_diagonals(), FLA_Bidiag_UT_l_realify_opt(), FLA_Bidiag_UT_l_scale_diagonals(), FLA_Bidiag_UT_u_extract_diagonals(), FLA_Bidiag_UT_u_extract_real_diagonals(), FLA_Bidiag_UT_u_realify_opt(), FLA_Bidiag_UT_u_scale_diagonals(), FLA_Bidiag_UT_u_step_ofu_var2(), FLA_Bidiag_UT_u_step_ofu_var3(), FLA_Bidiag_UT_u_step_ofu_var4(), FLA_Bidiag_UT_u_step_opt_var1(), FLA_Bidiag_UT_u_step_opt_var2(), FLA_Bidiag_UT_u_step_opt_var3(), FLA_Bidiag_UT_u_step_opt_var4(), FLA_Bidiag_UT_u_step_opt_var5(), FLA_Bsvd_ext_opt_var1(), FLA_Bsvd_external(), FLA_Bsvd_sinval_v_opt_var1(), FLA_Bsvd_v_opt_var1(), FLA_Bsvd_v_opt_var2(), FLA_Bsvdd_external(), FLA_CAQR2_UT_opt_var1(), FLA_CAQR_UT_inc_init_structure(), FLA_Check_row_storage(), FLA_Chol_blk_external(), FLA_Chol_l_opt_var1(), FLA_Chol_l_opt_var2(), FLA_Chol_l_opt_var3(), FLA_Chol_u_opt_var1(), FLA_Chol_u_opt_var2(), FLA_Chol_u_opt_var3(), FLA_Chol_unb_external(), FLA_Conjugate(), FLA_Conjugate_r(), FLA_Copy_external(), FLA_Copyr_external(), FLA_Copyrt_external(), FLA_Copyt_external(), FLA_Eig_gest_blk_external(), FLA_Eig_gest_il_opt_var1(), FLA_Eig_gest_il_opt_var2(), FLA_Eig_gest_il_opt_var3(), FLA_Eig_gest_il_opt_var4(), FLA_Eig_gest_il_opt_var5(), FLA_Eig_gest_iu_opt_var1(), FLA_Eig_gest_iu_opt_var2(), FLA_Eig_gest_iu_opt_var3(), FLA_Eig_gest_iu_opt_var4(), FLA_Eig_gest_iu_opt_var5(), FLA_Eig_gest_nl_opt_var1(), FLA_Eig_gest_nl_opt_var2(), FLA_Eig_gest_nl_opt_var4(), FLA_Eig_gest_nl_opt_var5(), FLA_Eig_gest_nu_opt_var1(), FLA_Eig_gest_nu_opt_var2(), FLA_Eig_gest_nu_opt_var4(), FLA_Eig_gest_nu_opt_var5(), FLA_Eig_gest_unb_external(), FLA_Fused_Ahx_Ax_opt_var1(), FLA_Fused_Ahx_Axpy_Ax_opt_var1(), FLA_Fused_Gerc2_Ahx_Ax_opt_var1(), FLA_Fused_Gerc2_Ahx_Axpy_Ax_opt_var1(), FLA_Fused_Gerc2_opt_var1(), FLA_Fused_Her2_Ax_l_opt_var1(), FLA_Fused_Uhu_Yhu_Zhu_opt_var1(), FLA_Fused_UYx_ZVx_opt_var1(), FLA_Fused_UZhu_ZUhu_opt_var1(), FLA_Gemm_external(), FLA_Gemv_external(), FLA_Gemvc_external(), FLA_Ger_external(), FLA_Gerc_external(), FLA_Hemm_external(), FLA_Hemv_external(), FLA_Hemvc_external(), FLA_Her2_external(), FLA_Her2c_external(), FLA_Her2k_external(), FLA_Her_external(), FLA_Herc_external(), FLA_Herk_external(), FLA_Hermitianize(), FLA_Hess_blk_external(), FLA_Hess_unb_external(), FLA_Hess_UT_step_ofu_var2(), FLA_Hess_UT_step_ofu_var3(), FLA_Hess_UT_step_ofu_var4(), FLA_Hess_UT_step_opt_var1(), FLA_Hess_UT_step_opt_var2(), FLA_Hess_UT_step_opt_var3(), FLA_Hess_UT_step_opt_var4(), FLA_Hess_UT_step_opt_var5(), FLA_Hevd_external(), FLA_Hevdd_external(), FLA_Hevdr_external(), FLA_Inv_scal_elemwise(), FLA_Inv_scal_external(), FLA_Inv_scalc_external(), FLA_LQ_blk_external(), FLA_LQ_unb_external(), FLA_LQ_UT_opt_var1(), FLA_LQ_UT_opt_var2(), FLA_LU_nopiv_opt_var1(), FLA_LU_nopiv_opt_var2(), FLA_LU_nopiv_opt_var3(), FLA_LU_nopiv_opt_var4(), FLA_LU_nopiv_opt_var5(), FLA_LU_piv_blk_external(), FLA_LU_piv_opt_var3(), FLA_LU_piv_opt_var4(), FLA_LU_piv_opt_var5(), FLA_LU_piv_unb_external(), FLA_Lyap_h_opt_var1(), FLA_Lyap_h_opt_var2(), FLA_Lyap_h_opt_var3(), FLA_Lyap_h_opt_var4(), FLA_Lyap_n_opt_var1(), FLA_Lyap_n_opt_var2(), FLA_Lyap_n_opt_var3(), FLA_Lyap_n_opt_var4(), FLA_Max_abs_value(), FLA_Max_abs_value_herm(), FLA_Max_elemwise_diff(), FLA_Norm_frob(), FLA_Obj_buffer_at_view(), FLA_Obj_create_conf_to(), FLA_Obj_equals(), FLA_Obj_fshow(), FLA_Obj_has_nan(), FLA_Obj_is_row_major(), FLA_Obj_set_imag_part(), FLA_Obj_set_real_part(), FLA_QR2_UT_opt_var1(), FLA_QR_blk_external(), FLA_QR_form_Q_external(), FLA_QR_unb_external(), FLA_QR_UT_form_Q_opt_var1(), FLA_QR_UT_opt_var1(), FLA_QR_UT_opt_var2(), FLA_Random_matrix(), FLA_Random_tri_matrix(), FLA_SA_Apply_pivots(), FLA_SA_LU_unb(), FLA_Scal_elemwise(), FLA_Scal_external(), FLA_Scalc_external(), FLA_Scale_diag(), FLA_Scalr_external(), FLA_Set(), FLA_Set_diag(), FLA_Set_diagonal_matrix(), FLA_Set_diagonal_vector(), FLA_Set_offdiag(), FLA_Setr(), FLA_Shift_diag(), FLA_Sort_evd(), FLA_Sort_svd(), FLA_Svd_external(), FLA_Svdd_external(), FLA_Swap_external(), FLA_Swapt_external(), FLA_Sylv_hh_opt_var1(), FLA_Sylv_hn_opt_var1(), FLA_Sylv_nh_opt_var1(), FLA_Sylv_nn_opt_var1(), FLA_Sylv_unb_external(), FLA_Symm_external(), FLA_Symmetrize(), FLA_Symv_external(), FLA_Syr2_external(), FLA_Syr2k_external(), FLA_Syr_external(), FLA_Syrk_external(), FLA_Tevd_eigval_v_opt_var1(), FLA_Tevd_external(), FLA_Tevd_n_opt_var1(), FLA_Tevd_v_opt_var1(), FLA_Tevd_v_opt_var2(), FLA_Tevdd_external(), FLA_Tevdr_external(), FLA_Triangularize(), FLA_Tridiag_apply_Q_external(), FLA_Tridiag_blk_external(), FLA_Tridiag_form_Q_external(), FLA_Tridiag_unb_external(), FLA_Tridiag_UT_l_realify_opt(), FLA_Tridiag_UT_l_step_ofu_var2(), FLA_Tridiag_UT_l_step_ofu_var3(), FLA_Tridiag_UT_l_step_opt_var1(), FLA_Tridiag_UT_l_step_opt_var2(), FLA_Tridiag_UT_l_step_opt_var3(), FLA_Tridiag_UT_shift_U(), FLA_Tridiag_UT_u_realify_opt(), FLA_Trinv_blk_external(), FLA_Trinv_ln_opt_var1(), FLA_Trinv_ln_opt_var2(), FLA_Trinv_ln_opt_var3(), FLA_Trinv_ln_opt_var4(), FLA_Trinv_lu_opt_var1(), FLA_Trinv_lu_opt_var2(), FLA_Trinv_lu_opt_var3(), FLA_Trinv_lu_opt_var4(), FLA_Trinv_un_opt_var1(), FLA_Trinv_un_opt_var2(), FLA_Trinv_un_opt_var3(), FLA_Trinv_un_opt_var4(), FLA_Trinv_unb_external(), FLA_Trinv_uu_opt_var1(), FLA_Trinv_uu_opt_var2(), FLA_Trinv_uu_opt_var3(), FLA_Trinv_uu_opt_var4(), FLA_Trmm_external(), FLA_Trmmsx_external(), FLA_Trmv_external(), FLA_Trsm_external(), FLA_Trsmsx_external(), FLA_Trsv_external(), FLA_Ttmm_blk_external(), FLA_Ttmm_l_opt_var1(), FLA_Ttmm_l_opt_var2(), FLA_Ttmm_l_opt_var3(), FLA_Ttmm_u_opt_var1(), FLA_Ttmm_u_opt_var2(), FLA_Ttmm_u_opt_var3(), FLA_Ttmm_unb_external(), FLA_UDdate_UT_opt_var1(), FLASH_Obj_attach_buffer_hierarchy(), FLASH_Obj_base_scalar_length(), FLASH_Obj_base_scalar_width(), FLASH_Obj_show_hierarchy(), FLASH_print_struct(), FLASH_print_struct_helper(), FLASH_Queue_check_gpu(), FLASH_Queue_exec_gpu(), FLASH_Queue_init_tasks(), FLASH_Queue_push(), FLASH_Queue_read_gpu(), FLASH_Queue_update_cache(), FLASH_Queue_write_gpu(), FLASH_Task_free(), and FLASH_Task_free_parallel().

◆ FLA_Obj_copy_view()

FLA_Error FLA_Obj_copy_view	(	FLA_Obj	A,
		FLA_Obj *	B
	)

{
  FLA_Obj  A_view;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_copy_view_check( A, B );
 
  // Set the m_inner and n_inner fields of a temporary copy of A.
  A_view         = A;
  A_view.m_inner = FLASH_Obj_scalar_length( A );
  A_view.n_inner = FLASH_Obj_scalar_width( A ); 
 
  // Copy the modified view into B. 
  *B = A_view; 
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_Obj_copy_view_check(), FLASH_Obj_scalar_length(), FLASH_Obj_scalar_width(), FLA_Obj_view::m_inner, and FLA_Obj_view::n_inner.

◆ FLA_Obj_copy_view_check()

FLA_Error FLA_Obj_copy_view_check	(	FLA_Obj	A,
		FLA_Obj *	B
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( A.base );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( B->base );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, and FLA_Check_null_pointer().

Referenced by FLA_Obj_copy_view().

◆ FLA_Obj_create()

FLA_Error FLA_Obj_create	(	FLA_Datatype	datatype,
		dim_t	m,
		dim_t	n,
		dim_t	rs,
		dim_t	cs,
		FLA_Obj *	obj
	)

{
  FLA_Obj_create_ext( datatype, FLA_SCALAR, m, n, m, n, rs, cs, obj );
 
  return FLA_SUCCESS;
}

References FLA_Obj_create_ext().

Referenced by FLA_Apply_Q_blk_external(), FLA_Apply_Q_UT_create_workspace(), FLA_Apply_Q_UT_create_workspace_side(), FLA_Apply_QUD_UT_create_workspace(), FLA_Bidiag_apply_U_external(), FLA_Bidiag_apply_V_external(), FLA_Bidiag_blk_external(), FLA_Bidiag_form_U_external(), FLA_Bidiag_form_V_external(), FLA_Bidiag_unb_external(), FLA_Bidiag_UT_create_T(), FLA_Bidiag_UT_form_U_ext(), FLA_Bidiag_UT_form_V_ext(), FLA_Bidiag_UT_l_realify_unb(), FLA_Bidiag_UT_u_blf_var4(), FLA_Bidiag_UT_u_blk_var4(), FLA_Bidiag_UT_u_blk_var5(), FLA_Bidiag_UT_u_ofu_var4(), FLA_Bidiag_UT_u_opt_var4(), FLA_Bidiag_UT_u_opt_var5(), FLA_Bidiag_UT_u_realify_unb(), FLA_Bidiag_UT_u_step_unb_var1(), FLA_Bidiag_UT_u_step_unb_var2(), FLA_Bidiag_UT_u_step_unb_var3(), FLA_Bidiag_UT_u_step_unb_var4(), FLA_Bidiag_UT_u_step_unb_var5(), FLA_Bidiag_UT_u_unb_var4(), FLA_Bidiag_UT_u_unb_var5(), FLA_Bsvd_create_workspace(), FLA_Bsvd_external(), FLA_Bsvdd_external(), FLA_Fill_with_cluster_dist(), FLA_Fill_with_geometric_dist(), FLA_Fill_with_inverse_dist(), FLA_Fill_with_linear_dist(), FLA_Fill_with_logarithmic_dist(), FLA_Fill_with_random_dist(), FLA_Hess_blk_external(), FLA_Hess_unb_external(), FLA_Hess_UT_blf_var2(), FLA_Hess_UT_blf_var3(), FLA_Hess_UT_blf_var4(), FLA_Hess_UT_blk_var1(), FLA_Hess_UT_blk_var2(), FLA_Hess_UT_blk_var3(), FLA_Hess_UT_blk_var4(), FLA_Hess_UT_blk_var5(), FLA_Hess_UT_create_T(), FLA_Hess_UT_step_unb_var1(), FLA_Hess_UT_step_unb_var2(), FLA_Hess_UT_step_unb_var3(), FLA_Hess_UT_step_unb_var4(), FLA_Hess_UT_step_unb_var5(), FLA_Hevd_compute_scaling(), FLA_Hevd_external(), FLA_Hevd_lv_unb_var1(), FLA_Hevd_lv_unb_var2(), FLA_Hevdd_external(), FLA_Hevdr_external(), FLA_LQ_blk_external(), FLA_LQ_unb_external(), FLA_LQ_UT_create_T(), FLA_Lyap_h_unb_var1(), FLA_Lyap_h_unb_var2(), FLA_Lyap_h_unb_var3(), FLA_Lyap_h_unb_var4(), FLA_Lyap_n_unb_var1(), FLA_Lyap_n_unb_var2(), FLA_Lyap_n_unb_var3(), FLA_Lyap_n_unb_var4(), FLA_Norm1(), FLA_Norm_inf(), FLA_Obj_create_complex_constant(), FLA_Obj_create_constant(), FLA_Obj_create_constant_ext(), FLA_QR_blk_external(), FLA_QR_form_Q_external(), FLA_QR_unb_external(), FLA_QR_UT_create_T(), FLA_QR_UT_piv_colnorm(), FLA_QR_UT_piv_unb_var2(), FLA_Svd_compute_scaling(), FLA_Svd_ext_u_unb_var1(), FLA_Svd_external(), FLA_Svd_uv_unb_var1(), FLA_Svd_uv_unb_var2(), FLA_Svdd_external(), FLA_Tevd_external(), FLA_Tevdd_external(), FLA_Tevdr_external(), FLA_Tridiag_apply_Q_external(), FLA_Tridiag_blk_external(), FLA_Tridiag_form_Q_external(), FLA_Tridiag_unb_external(), FLA_Tridiag_UT_create_T(), FLA_Tridiag_UT_l_blf_var3(), FLA_Tridiag_UT_l_blk_var3(), FLA_Tridiag_UT_l_realify_unb(), FLA_Tridiag_UT_l_step_unb_var1(), FLA_Tridiag_UT_l_step_unb_var2(), FLA_Tridiag_UT_l_step_unb_var3(), FLA_Tridiag_UT_u_realify_unb(), FLA_UDdate_UT_create_T(), FLASH_Obj_create_flat_conf_to_hier(), and FLASH_Obj_create_helper().

◆ FLA_Obj_create_buffer()

FLA_Error FLA_Obj_create_buffer	(	dim_t	rs,
		dim_t	cs,
		FLA_Obj *	obj
	)

{
  size_t buffer_size;
  size_t n_elem;
  dim_t  m, n;
 
  m = FLA_Obj_length( *obj );
  n = FLA_Obj_width( *obj );
 
  // Adjust the strides, if necessary.
  FLA_adjust_strides( m, n, &rs, &cs );
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_create_buffer_check( rs, cs, obj );
 
  // Compute the number of elements needed for the buffer, adjusting
  // the strides for alignment if needed.
  n_elem = FLA_compute_num_elem( FLA_Obj_elem_size( *obj ),
                                 m, n, &rs, &cs );
 
  // Compute the buffer size in bytes.
  buffer_size = ( size_t ) n_elem *
                ( size_t ) FLA_Obj_elem_size( *obj );
 
  // Allocate the base object's element buffer.
#ifdef FLA_ENABLE_SCC
  obj->base->buffer = ( FLA_Obj_elemtype( *obj ) == FLA_MATRIX ? FLA_malloc( buffer_size ) : FLA_shmalloc( buffer_size ) );
#else
  obj->base->buffer = FLA_malloc( buffer_size );
#endif
  obj->base->buffer_info = 0;
 
  // Save the number of elements allocated (for use with FLASH).
  obj->base->n_elem_alloc = n_elem;
 
  // Save the row and column strides used in the memory allocation.
  obj->base->rs     = rs;
  obj->base->cs     = cs;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Obj_struct::buffer, FLA_Obj_struct::buffer_info, FLA_Obj_struct::cs, FLA_adjust_strides(), FLA_Check_error_level(), FLA_compute_num_elem(), FLA_malloc(), FLA_Obj_create_buffer_check(), FLA_Obj_elem_size(), FLA_Obj_elemtype(), FLA_Obj_length(), FLA_Obj_width(), FLA_shmalloc(), FLA_Obj_struct::n_elem_alloc, and FLA_Obj_struct::rs.

Referenced by FLA_Obj_create_buffer_task().

◆ FLA_Obj_create_buffer_check()

FLA_Error FLA_Obj_create_buffer_check	(	dim_t	rs,
		dim_t	cs,
		FLA_Obj *	obj
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_matrix_strides( FLA_Obj_length( *obj ), FLA_Obj_width( *obj ), rs, cs );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_matrix_strides(), FLA_Check_null_pointer(), FLA_Obj_length(), and FLA_Obj_width().

Referenced by FLA_Obj_create_buffer().

◆ FLA_Obj_create_buffer_task()

FLA_Error FLA_Obj_create_buffer_task	(	dim_t	rs,
		dim_t	cs,
		FLA_Obj	obj,
		void *	cntl
	)

{
  FLA_Error r_val;
 
  r_val = FLA_Obj_create_buffer( rs, cs, &obj );
 
  FLA_Set( FLA_ZERO, obj );
 
  return r_val;
}

References FLA_Obj_create_buffer(), FLA_Set(), FLA_ZERO, and i.

Referenced by FLASH_Queue_exec_task().

◆ FLA_Obj_create_complex_constant()

FLA_Error FLA_Obj_create_complex_constant	(	double	const_real,
		double	const_imag,
		FLA_Obj *	obj
	)

{
  int*      temp_i;
  float*    temp_s;
  double*   temp_d;
  scomplex* temp_c;
  dcomplex* temp_z;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_create_complex_constant_check( const_real, const_imag, obj );
 
  FLA_Obj_create( FLA_CONSTANT, 1, 1, 0, 0, obj );
 
#ifdef FLA_ENABLE_SCC
  if ( !FLA_is_owner() )
    return FLA_SUCCESS;
#endif
 
  temp_i       = FLA_INT_PTR( *obj );
  temp_s       = FLA_FLOAT_PTR( *obj );
  temp_d       = FLA_DOUBLE_PTR( *obj );
  temp_c       = FLA_COMPLEX_PTR( *obj );
  temp_z       = FLA_DOUBLE_COMPLEX_PTR( *obj );
 
  *temp_i      = ( int   ) const_real;
  *temp_s      = ( float ) const_real;
  *temp_d      =           const_real;
  temp_c->real = ( float ) const_real;
  temp_c->imag = ( float ) const_imag;
  temp_z->real =           const_real;
  temp_z->imag =           const_imag;
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_is_owner(), FLA_Obj_create(), FLA_Obj_create_complex_constant_check(), scomplex::imag, dcomplex::imag, scomplex::real, and dcomplex::real.

◆ FLA_Obj_create_complex_constant_check()

FLA_Error FLA_Obj_create_complex_constant_check	(	double	const_real,
		double	const_imag,
		FLA_Obj *	obj
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer().

Referenced by FLA_Obj_create_complex_constant().

◆ FLA_Obj_create_conf_to()

FLA_Error FLA_Obj_create_conf_to	(	FLA_Trans	trans,
		FLA_Obj	old,
		FLA_Obj *	obj
	)

{
  FLA_Datatype datatype;
  FLA_Elemtype elemtype;
  dim_t        m, n;
  dim_t        rs, cs;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_create_conf_to_check( trans, obj_cur, obj_new );
 
  datatype = FLA_Obj_datatype( obj_cur );
  elemtype = FLA_Obj_elemtype( obj_cur );
 
  // Query the dimensions of the existing object.
  if ( trans == FLA_NO_TRANSPOSE || trans == FLA_CONJ_NO_TRANSPOSE )
  {
    m = FLA_Obj_length( obj_cur );
    n = FLA_Obj_width( obj_cur );
  }
  else // if ( trans == FLA_TRANSPOSE || trans == FLA_CONJ_TRANSPOSE )
  {
    m = FLA_Obj_width( obj_cur );
    n = FLA_Obj_length( obj_cur );
  }
 
  // Query the row and column strides of the existing object. We don't care
  // about the actual leading dimension of the existing object, only whether
  // it is in row- or column-major format.
  rs = FLA_Obj_row_stride( obj_cur );
  cs = FLA_Obj_col_stride( obj_cur );
 
  if ( ( rs == 1 && cs == 1 ) )
  {
    // Do nothing. This special case will be handled by FLA_adjust_strides().
    ;
  }
  else if ( rs == 1 )
  {
    // For column-major storage, use the m dimension as the column stride.
    // Row stride is already set to 1.
    cs = m;
  }
  else if ( cs == 1 )
  {
    // For row-major storage, use the n dimension as the row stride.
    // Column stride is already set to 1.
    rs = n;
  }
 
  // Handle empty views.
  if ( m == 0 ) cs = 1;
  if ( n == 0 ) rs = 1;
 
  FLA_Obj_create_ext( datatype, elemtype, m, n, m, n, rs, cs, obj_new );
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_Obj_col_stride(), FLA_Obj_create_conf_to_check(), FLA_Obj_create_ext(), FLA_Obj_datatype(), FLA_Obj_elemtype(), FLA_Obj_length(), FLA_Obj_row_stride(), and FLA_Obj_width().

Referenced by FLA_Apply_H2_UT_l_unb_var1(), FLA_Apply_H2_UT_r_unb_var1(), FLA_Eig_gest(), FLA_Hess_UT_ofu_var4(), FLA_Hess_UT_opt_var4(), FLA_Hess_UT_opt_var5(), FLA_Hess_UT_unb_var4(), FLA_Hess_UT_unb_var5(), FLA_Lyap_h_opt_var1(), FLA_Lyap_h_opt_var2(), FLA_Lyap_h_opt_var3(), FLA_Lyap_h_opt_var4(), FLA_Lyap_h_unb_var1(), FLA_Lyap_h_unb_var2(), FLA_Lyap_h_unb_var3(), FLA_Lyap_h_unb_var4(), FLA_Lyap_n_opt_var1(), FLA_Lyap_n_opt_var2(), FLA_Lyap_n_opt_var3(), FLA_Lyap_n_opt_var4(), FLA_Lyap_n_unb_var1(), FLA_Lyap_n_unb_var2(), FLA_Lyap_n_unb_var3(), FLA_Lyap_n_unb_var4(), FLA_Obj_create_copy_of(), FLA_Random_spd_matrix(), FLA_Random_unitary_matrix(), FLA_Svd_ext_u_unb_var1(), FLA_Tridiag_UT_l_ofu_var3(), FLA_Tridiag_UT_l_opt_var3(), FLA_Tridiag_UT_l_unb_var3(), FLA_Trmvsx_external(), and FLA_Trsvsx_external().

◆ FLA_Obj_create_conf_to_check()

FLA_Error FLA_Obj_create_conf_to_check	(	FLA_Trans	trans,
		FLA_Obj	obj_old,
		FLA_Obj *	obj
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_trans( trans );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( obj_old );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), FLA_Check_valid_object_datatype(), and FLA_Check_valid_trans().

Referenced by FLA_Obj_create_conf_to().

◆ FLA_Obj_create_constant()

FLA_Error FLA_Obj_create_constant	(	double	const_real,
		FLA_Obj *	obj
	)

{
  int*      temp_i;
  float*    temp_s;
  double*   temp_d;
  scomplex* temp_c;
  dcomplex* temp_z;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_create_constant_check( const_real, obj );
 
  FLA_Obj_create( FLA_CONSTANT, 1, 1, 0, 0, obj );
 
#ifdef FLA_ENABLE_SCC
  if ( !FLA_is_owner() )
    return FLA_SUCCESS;
#endif
 
  temp_i       = FLA_INT_PTR( *obj );
  temp_s       = FLA_FLOAT_PTR( *obj );
  temp_d       = FLA_DOUBLE_PTR( *obj );
  temp_c       = FLA_COMPLEX_PTR( *obj );
  temp_z       = FLA_DOUBLE_COMPLEX_PTR( *obj );
 
  *temp_i      = ( int   ) const_real;
  *temp_s      = ( float ) const_real;
  *temp_d      =           const_real;
  temp_c->real = ( float ) const_real;
  temp_c->imag = ( float ) 0.0;
  temp_z->real =           const_real;
  temp_z->imag =           0.0;
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_is_owner(), FLA_Obj_create(), FLA_Obj_create_constant_check(), scomplex::imag, dcomplex::imag, scomplex::real, and dcomplex::real.

Referenced by FLA_Init_constants().

◆ FLA_Obj_create_constant_check()

FLA_Error FLA_Obj_create_constant_check	(	double	const_real,
		FLA_Obj *	obj
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer().

Referenced by FLA_Obj_create_constant().

◆ FLA_Obj_create_constant_ext()

FLA_Error FLA_Obj_create_constant_ext	(	float	const_s,
		double	const_d,
		FLA_Obj *	obj
	)

{
  int*      temp_i;
  float*    temp_s;
  double*   temp_d;
  scomplex* temp_c;
  dcomplex* temp_z;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_create_constant_ext_check( const_s, const_d, obj );
 
  FLA_Obj_create( FLA_CONSTANT, 1, 1, 0, 0, obj );
 
#ifdef FLA_ENABLE_SCC
  if ( !FLA_is_owner() )
    return FLA_SUCCESS;
#endif
 
  temp_i       = FLA_INT_PTR( *obj );
  temp_s       = FLA_FLOAT_PTR( *obj );
  temp_d       = FLA_DOUBLE_PTR( *obj );
  temp_c       = FLA_COMPLEX_PTR( *obj );
  temp_z       = FLA_DOUBLE_COMPLEX_PTR( *obj );
 
  *temp_i      = ( int   ) const_s;
  *temp_s      =           const_s;
  *temp_d      =           const_d;
  temp_c->real =           const_s;
  temp_c->imag =           0.0F;
  temp_z->real =           const_d;
  temp_z->imag =           0.0;
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_is_owner(), FLA_Obj_create(), FLA_Obj_create_constant_ext_check(), scomplex::imag, dcomplex::imag, scomplex::real, and dcomplex::real.

Referenced by FLA_Init_constants().

◆ FLA_Obj_create_constant_ext_check()

FLA_Error FLA_Obj_create_constant_ext_check	(	float	const_s,
		double	const_d,
		FLA_Obj *	obj
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer().

Referenced by FLA_Obj_create_constant_ext().

◆ FLA_Obj_create_copy_of()

FLA_Error FLA_Obj_create_copy_of	(	FLA_Trans	trans,
		FLA_Obj	old,
		FLA_Obj *	obj
	)

{
  // Create a new object conformal to the current object.
  FLA_Obj_create_conf_to( trans, obj_cur, obj_new );
 
#ifdef FLA_ENABLE_SCC
  if ( !FLA_is_owner() )
    return FLA_SUCCESS;
#endif
 
  // Copy the contents of the current object to the new object.
  FLA_Copyt_external( trans, obj_cur, *obj_new );
 
  return FLA_SUCCESS;
}

References FLA_Copyt_external(), FLA_is_owner(), and FLA_Obj_create_conf_to().

Referenced by FLA_QR_UT_solve(), FLA_Sort(), FLA_UDdate_UT_update_rhs(), and FLASH_Obj_create_copy_of().

◆ FLA_Obj_create_ext()

FLA_Error FLA_Obj_create_ext	(	FLA_Datatype	datatype,
		FLA_Elemtype	elemtype,
		dim_t	m,
		dim_t	n,
		dim_t	m_inner,
		dim_t	n_inner,
		dim_t	rs,
		dim_t	cs,
		FLA_Obj *	obj
	)

{
  size_t buffer_size;
  size_t n_elem;
 
  // Adjust the strides, if necessary.
  FLA_adjust_strides( m, n, &rs, &cs );
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_create_ext_check( datatype, elemtype, m, n, m_inner, n_inner, rs, cs, obj );
 
  // Populate the fields in the view object.
  obj->m                = m;
  obj->n                = n;
  obj->offm             = 0;
  obj->offn             = 0;
  obj->m_inner          = m_inner;
  obj->n_inner          = n_inner;
 
  // Allocate the base object field.
  obj->base             = ( FLA_Base_obj * ) FLA_malloc( sizeof( FLA_Base_obj ) );
 
  // Populate the fields in the base object.
  obj->base->datatype   = datatype;
  obj->base->elemtype   = elemtype;
  obj->base->m          = m;
  obj->base->n          = n;
  obj->base->m_inner    = m_inner;
  obj->base->n_inner    = n_inner;
  obj->base->id         = ( unsigned long ) obj->base;
  obj->base->m_index    = 0;
  obj->base->n_index    = 0;
 
  // Compute the number of elements needed for the buffer, adjusting
  // the strides for alignment if needed.
  n_elem = FLA_compute_num_elem( FLA_Obj_elem_size( *obj ),
                                 m, n, &rs, &cs );
 
  // Compute the buffer size in bytes.
  buffer_size = ( size_t ) n_elem *
                ( size_t ) FLA_Obj_elem_size( *obj );
 
  // Allocate the base object's element buffer.
#ifdef FLA_ENABLE_SCC
  obj->base->buffer = ( FLA_Obj_elemtype( *obj ) == FLA_MATRIX ? FLA_malloc( buffer_size ) : FLA_shmalloc( buffer_size ) );
#else
  obj->base->buffer = FLA_malloc( buffer_size );
#endif
  obj->base->buffer_info = 0;
 
  // Just in case this is a FLASH object, save the number of elements
  // allocated so that we can more easily free the elements later on.
  obj->base->n_elem_alloc = n_elem;
 
  // Save the row and column strides used in the memory allocation.
  obj->base->rs     = rs;
  obj->base->cs     = cs;
 
#ifdef FLA_ENABLE_SUPERMATRIX
  // Initialize SuperMatrix fields.
  obj->base->n_read_tasks   = 0;
  obj->base->read_task_head = NULL;
  obj->base->read_task_tail = NULL;
  obj->base->write_task     = NULL;
#endif
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Obj_struct::buffer, FLA_Obj_struct::buffer_info, FLA_Obj_struct::cs, FLA_Obj_struct::datatype, FLA_Obj_struct::elemtype, FLA_adjust_strides(), FLA_Check_error_level(), FLA_compute_num_elem(), FLA_malloc(), FLA_Obj_create_ext_check(), FLA_Obj_elem_size(), FLA_Obj_elemtype(), FLA_shmalloc(), FLA_Obj_struct::id, FLA_Obj_struct::m, FLA_Obj_view::m, FLA_Obj_struct::m_index, FLA_Obj_struct::m_inner, FLA_Obj_view::m_inner, FLA_Obj_struct::n, FLA_Obj_view::n, FLA_Obj_struct::n_elem_alloc, FLA_Obj_struct::n_index, FLA_Obj_struct::n_inner, FLA_Obj_view::n_inner, FLA_Obj_struct::n_read_tasks, FLA_Obj_view::offm, FLA_Obj_view::offn, FLA_Obj_struct::read_task_head, FLA_Obj_struct::read_task_tail, FLA_Obj_struct::rs, and FLA_Obj_struct::write_task.

Referenced by FLA_Obj_create(), FLA_Obj_create_conf_to(), and FLASH_Obj_create_hierarchy().

◆ FLA_Obj_create_ext_check()

FLA_Error FLA_Obj_create_ext_check	(	FLA_Datatype	datatype,
		FLA_Elemtype	elemtype,
		dim_t	m,
		dim_t	n,
		dim_t	m_inner,
		dim_t	n_inner,
		dim_t	rs,
		dim_t	cs,
		FLA_Obj *	obj
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_elemtype( elemtype );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_datatype( datatype );
  FLA_Check_error_code( e_val );
 
  // If both m and n are zero, we do not need to check cs/rs.
  if ( m > 0 && n > 0 )
  {
    e_val = FLA_Check_matrix_strides( m, n, rs, cs );
    FLA_Check_error_code( e_val );
  }
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_matrix_strides(), FLA_Check_null_pointer(), FLA_Check_valid_datatype(), and FLA_Check_valid_elemtype().

Referenced by FLA_Obj_create_ext().

◆ FLA_Obj_create_without_buffer()

FLA_Error FLA_Obj_create_without_buffer	(	FLA_Datatype	datatype,
		dim_t	m,
		dim_t	n,
		FLA_Obj *	obj
	)

{
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_create_without_buffer_check( datatype, m, n, obj );
 
  // Populate the fields in the view object.
  obj->m                = m;
  obj->n                = n;
  obj->offm             = 0;
  obj->offn             = 0;
  obj->m_inner          = m;
  obj->n_inner          = n;
 
  // Allocate the base object field.
  obj->base             = ( FLA_Base_obj * ) FLA_malloc( sizeof( FLA_Base_obj ) );
 
  // Populate the fields in the base object.
  obj->base->datatype   = datatype;
  obj->base->elemtype   = FLA_SCALAR;
  obj->base->m          = m;
  obj->base->n          = n;
  obj->base->m_inner    = m;
  obj->base->n_inner    = n;
  obj->base->id         = ( unsigned long ) obj->base;
  obj->base->m_index    = 0;
  obj->base->n_index    = 0;
 
  // Set the row and column strides to invalid values.
  obj->base->rs         = 0;
  obj->base->cs         = 0;
 
  // Initialize the base object's element buffer to NULL.
  obj->base->buffer       = NULL;
  obj->base->buffer_info  = 0;
  obj->base->n_elem_alloc = 0;
 
#ifdef FLA_ENABLE_SUPERMATRIX
  // Initialize SuperMatrix fields.
  obj->base->n_read_tasks   = 0;
  obj->base->read_task_head = NULL;
  obj->base->read_task_tail = NULL;
  obj->base->write_task     = NULL;
#endif
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Obj_struct::buffer, FLA_Obj_struct::buffer_info, FLA_Obj_struct::cs, FLA_Obj_struct::datatype, FLA_Obj_struct::elemtype, FLA_Check_error_level(), FLA_malloc(), FLA_Obj_create_without_buffer_check(), FLA_Obj_struct::id, FLA_Obj_struct::m, FLA_Obj_view::m, FLA_Obj_struct::m_index, FLA_Obj_struct::m_inner, FLA_Obj_view::m_inner, FLA_Obj_struct::n, FLA_Obj_view::n, FLA_Obj_struct::n_elem_alloc, FLA_Obj_struct::n_index, FLA_Obj_struct::n_inner, FLA_Obj_view::n_inner, FLA_Obj_struct::n_read_tasks, FLA_Obj_view::offm, FLA_Obj_view::offn, FLA_Obj_struct::read_task_head, FLA_Obj_struct::read_task_tail, FLA_Obj_struct::rs, and FLA_Obj_struct::write_task.

Referenced by FLA_Axpy_buffer_to_object(), FLA_Axpy_object_to_buffer(), FLA_Copy_buffer_to_object(), FLA_Copy_object_to_buffer(), FLASH_Axpy_buffer_to_hier(), FLASH_Axpy_hier_to_buffer(), FLASH_Copy_buffer_to_hier(), FLASH_Copy_hier_to_buffer(), FLASH_Obj_attach_buffer(), FLASH_Obj_create_helper(), and FLASH_Obj_create_hierarchy().

◆ FLA_Obj_create_without_buffer_check()

FLA_Error FLA_Obj_create_without_buffer_check	(	FLA_Datatype	datatype,
		dim_t	m,
		dim_t	n,
		FLA_Obj *	obj
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_datatype( datatype );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), and FLA_Check_valid_datatype().

Referenced by FLA_Obj_create_without_buffer().

◆ FLA_Obj_datatype()

FLA_Datatype FLA_Obj_datatype ( FLA_Obj obj )

{
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_datatype_check( obj );
 
  return obj.base->datatype;
}

References FLA_Obj_view::base, FLA_Obj_struct::datatype, FLA_Check_error_level(), and FLA_Obj_datatype_check().

Referenced by FLA_Absolute_square(), FLA_Absolute_value(), FLA_Accum_T_UT_fc_opt_var1(), FLA_Accum_T_UT_fr_opt_var1(), FLA_Add_to_diag(), FLA_Amax_external(), FLA_Apply_diag_matrix(), FLA_Apply_G_lf_blk_var3(), FLA_Apply_G_lf_opt_var1(), FLA_Apply_G_rf_asm_var1(), FLA_Apply_G_rf_asm_var2(), FLA_Apply_G_rf_asm_var3(), FLA_Apply_G_rf_asm_var3b(), FLA_Apply_G_rf_asm_var6(), FLA_Apply_G_rf_asm_var6b(), FLA_Apply_G_rf_asm_var9(), FLA_Apply_G_rf_asm_var9b(), FLA_Apply_G_rf_blk_var1(), FLA_Apply_G_rf_blk_var2(), FLA_Apply_G_rf_blk_var3(), FLA_Apply_G_rf_blk_var3b(), FLA_Apply_G_rf_blk_var6(), FLA_Apply_G_rf_blk_var6b(), FLA_Apply_G_rf_blk_var9(), FLA_Apply_G_rf_blk_var9b(), FLA_Apply_G_rf_opt_var1(), FLA_Apply_G_rf_opt_var2(), FLA_Apply_G_rf_opt_var3(), FLA_Apply_G_rf_opt_var6(), FLA_Apply_G_rf_opt_var9(), FLA_Apply_H2_UT_l_opt_var1(), FLA_Apply_H2_UT_r_opt_var1(), FLA_Apply_HUD_UT_l_opt_var1(), FLA_Apply_pivots_ln_opt_var1(), FLA_Apply_pivots_lt_opt_var1(), FLA_Apply_pivots_macro_external(), FLA_Apply_pivots_rn_opt_var1(), FLA_Apply_pivots_rt_opt_var1(), FLA_Apply_pivots_unb_external(), FLA_Apply_Q_blk_external(), FLA_Apply_Q_UT_create_workspace(), FLA_Apply_Q_UT_create_workspace_side(), FLA_Apply_QUD_UT_create_workspace(), FLA_Asum_external(), FLA_Axpy_buffer_to_object(), FLA_Axpy_external(), FLA_Axpy_external_gpu(), FLA_Axpy_object_to_buffer(), FLA_Axpyrt_external(), FLA_Axpys_external(), FLA_Axpyt_external(), FLA_Bidiag_apply_U_external(), FLA_Bidiag_apply_V_external(), FLA_Bidiag_blk_external(), FLA_Bidiag_form_U_external(), FLA_Bidiag_form_V_external(), FLA_Bidiag_unb_external(), FLA_Bidiag_UT_create_T(), FLA_Bidiag_UT_l_extract_diagonals(), FLA_Bidiag_UT_l_extract_real_diagonals(), FLA_Bidiag_UT_l_realify_opt(), FLA_Bidiag_UT_l_realify_unb(), FLA_Bidiag_UT_l_scale_diagonals(), FLA_Bidiag_UT_realify_diagonals_opt(), FLA_Bidiag_UT_u_blf_var4(), FLA_Bidiag_UT_u_blk_var4(), FLA_Bidiag_UT_u_blk_var5(), FLA_Bidiag_UT_u_extract_diagonals(), FLA_Bidiag_UT_u_extract_real_diagonals(), FLA_Bidiag_UT_u_ofu_var4(), FLA_Bidiag_UT_u_opt_var4(), FLA_Bidiag_UT_u_opt_var5(), FLA_Bidiag_UT_u_realify_opt(), FLA_Bidiag_UT_u_realify_unb(), FLA_Bidiag_UT_u_scale_diagonals(), FLA_Bidiag_UT_u_step_ofu_var2(), FLA_Bidiag_UT_u_step_ofu_var3(), FLA_Bidiag_UT_u_step_ofu_var4(), FLA_Bidiag_UT_u_step_opt_var1(), FLA_Bidiag_UT_u_step_opt_var2(), FLA_Bidiag_UT_u_step_opt_var3(), FLA_Bidiag_UT_u_step_opt_var4(), FLA_Bidiag_UT_u_step_opt_var5(), FLA_Bidiag_UT_u_step_unb_var1(), FLA_Bidiag_UT_u_step_unb_var2(), FLA_Bidiag_UT_u_step_unb_var3(), FLA_Bidiag_UT_u_step_unb_var4(), FLA_Bidiag_UT_u_step_unb_var5(), FLA_Bidiag_UT_u_unb_var4(), FLA_Bidiag_UT_u_unb_var5(), FLA_Bsvd_compute_shift(), FLA_Bsvd_compute_tol_thresh(), FLA_Bsvd_ext_opt_var1(), FLA_Bsvd_external(), FLA_Bsvd_find_converged(), FLA_Bsvd_find_max(), FLA_Bsvd_francis_v_opt_var1(), FLA_Bsvd_sinval_v_opt_var1(), FLA_Bsvd_v_opt_var1(), FLA_Bsvd_v_opt_var2(), FLA_Bsvdd_external(), FLA_CAQR2_UT_opt_var1(), FLA_Check_comparable_object(), FLA_Check_complex_object(), FLA_Check_consistent_datatype(), FLA_Check_consistent_object_datatype(), FLA_Check_floating_object(), FLA_Check_householder_panel_dims(), FLA_Check_identical_object_datatype(), FLA_Check_identical_object_precision(), FLA_Check_int_object(), FLA_Check_nonconstant_object(), FLA_Check_real_object(), FLA_Check_valid_object_datatype(), FLA_Chol_blk_external(), FLA_Chol_l_opt_var1(), FLA_Chol_l_opt_var2(), FLA_Chol_l_opt_var3(), FLA_Chol_u_opt_var1(), FLA_Chol_u_opt_var2(), FLA_Chol_u_opt_var3(), FLA_Chol_unb_external(), FLA_Conjugate(), FLA_Conjugate_r(), FLA_Copy_buffer_to_object(), FLA_Copy_external(), FLA_Copy_external_gpu(), FLA_Copy_object_to_buffer(), FLA_Copyr_external(), FLA_Copyrt_external(), FLA_Copyt_external(), FLA_Determine_blocksize(), FLA_Dot2cs_external(), FLA_Dot2s_external(), FLA_Dot_external(), FLA_Dotc_external(), FLA_Dotcs_external(), FLA_Dots_external(), FLA_Eig_gest_blk_external(), FLA_Eig_gest_il_opt_var1(), FLA_Eig_gest_il_opt_var2(), FLA_Eig_gest_il_opt_var3(), FLA_Eig_gest_il_opt_var4(), FLA_Eig_gest_il_opt_var5(), FLA_Eig_gest_iu_opt_var1(), FLA_Eig_gest_iu_opt_var2(), FLA_Eig_gest_iu_opt_var3(), FLA_Eig_gest_iu_opt_var4(), FLA_Eig_gest_iu_opt_var5(), FLA_Eig_gest_nl_opt_var1(), FLA_Eig_gest_nl_opt_var2(), FLA_Eig_gest_nl_opt_var4(), FLA_Eig_gest_nl_opt_var5(), FLA_Eig_gest_nu_opt_var1(), FLA_Eig_gest_nu_opt_var2(), FLA_Eig_gest_nu_opt_var4(), FLA_Eig_gest_nu_opt_var5(), FLA_Eig_gest_unb_external(), FLA_Fused_Ahx_Ax_opt_var1(), FLA_Fused_Ahx_Axpy_Ax_opt_var1(), FLA_Fused_Gerc2_Ahx_Ax_opt_var1(), FLA_Fused_Gerc2_Ahx_Axpy_Ax_opt_var1(), FLA_Fused_Gerc2_opt_var1(), FLA_Fused_Her2_Ax_l_opt_var1(), FLA_Fused_Uhu_Yhu_Zhu_opt_var1(), FLA_Fused_UYx_ZVx_opt_var1(), FLA_Fused_UZhu_ZUhu_opt_var1(), FLA_Gemm_external(), FLA_Gemm_external_gpu(), FLA_Gemv_external(), FLA_Gemv_external_gpu(), FLA_Gemvc_external(), FLA_Ger_external(), FLA_Gerc_external(), FLA_Givens2(), FLA_Hemm_external(), FLA_Hemm_external_gpu(), FLA_Hemv_external(), FLA_Hemvc_external(), FLA_Her2_external(), FLA_Her2c_external(), FLA_Her2k_external(), FLA_Her2k_external_gpu(), FLA_Her_external(), FLA_Herc_external(), FLA_Herk_external(), FLA_Herk_external_gpu(), FLA_Hermitianize(), FLA_Hess_blk_external(), FLA_Hess_unb_external(), FLA_Hess_UT_blf_var2(), FLA_Hess_UT_blf_var3(), FLA_Hess_UT_blf_var4(), FLA_Hess_UT_blk_var1(), FLA_Hess_UT_blk_var2(), FLA_Hess_UT_blk_var3(), FLA_Hess_UT_blk_var4(), FLA_Hess_UT_blk_var5(), FLA_Hess_UT_create_T(), FLA_Hess_UT_step_ofu_var2(), FLA_Hess_UT_step_ofu_var3(), FLA_Hess_UT_step_ofu_var4(), FLA_Hess_UT_step_opt_var1(), FLA_Hess_UT_step_opt_var2(), FLA_Hess_UT_step_opt_var3(), FLA_Hess_UT_step_opt_var4(), FLA_Hess_UT_step_opt_var5(), FLA_Hess_UT_step_unb_var1(), FLA_Hess_UT_step_unb_var2(), FLA_Hess_UT_step_unb_var3(), FLA_Hess_UT_step_unb_var4(), FLA_Hess_UT_step_unb_var5(), FLA_Hev_2x2(), FLA_Hevd_external(), FLA_Hevd_lv_unb_var1(), FLA_Hevd_lv_unb_var2(), FLA_Hevdd_external(), FLA_Hevdr_external(), FLA_Hevv_2x2(), FLA_Househ2_UT(), FLA_Househ2s_UT(), FLA_Househ3UD_UT(), FLA_Inv_scal_elemwise(), FLA_Inv_scal_external(), FLA_Inv_scalc_external(), FLA_Invert(), FLA_LQ_blk_external(), FLA_LQ_unb_external(), FLA_LQ_UT_create_T(), FLA_LQ_UT_opt_var1(), FLA_LQ_UT_opt_var2(), FLA_LU_nopiv_opt_var1(), FLA_LU_nopiv_opt_var2(), FLA_LU_nopiv_opt_var3(), FLA_LU_nopiv_opt_var4(), FLA_LU_nopiv_opt_var5(), FLA_LU_piv_blk_external(), FLA_LU_piv_opt_var3(), FLA_LU_piv_opt_var4(), FLA_LU_piv_opt_var5(), FLA_LU_piv_unb_external(), FLA_Lyap_h_opt_var1(), FLA_Lyap_h_opt_var2(), FLA_Lyap_h_opt_var3(), FLA_Lyap_h_opt_var4(), FLA_Lyap_h_unb_var1(), FLA_Lyap_h_unb_var2(), FLA_Lyap_h_unb_var3(), FLA_Lyap_h_unb_var4(), FLA_Lyap_n_opt_var1(), FLA_Lyap_n_opt_var2(), FLA_Lyap_n_opt_var3(), FLA_Lyap_n_opt_var4(), FLA_Lyap_n_unb_var1(), FLA_Lyap_n_unb_var2(), FLA_Lyap_n_unb_var3(), FLA_Lyap_n_unb_var4(), FLA_Mach_params(), FLA_Max_abs_value(), FLA_Max_abs_value_herm(), FLA_Max_elemwise_diff(), FLA_Mult_add(), FLA_Norm1(), FLA_Norm1_tridiag(), FLA_Norm_frob(), FLA_Norm_inf(), FLA_Nrm2_external(), FLA_Obj_create_conf_to(), FLA_Obj_elem_size(), FLA_Obj_elem_size_check(), FLA_Obj_equals(), FLA_Obj_extract_imag_part(), FLA_Obj_extract_real_part(), FLA_Obj_fshow(), FLA_Obj_ge(), FLA_Obj_gt(), FLA_Obj_has_nan(), FLA_Obj_is_complex(), FLA_Obj_is_constant(), FLA_Obj_is_double_precision(), FLA_Obj_is_floating_point(), FLA_Obj_is_int(), FLA_Obj_is_real(), FLA_Obj_is_single_precision(), FLA_Obj_le(), FLA_Obj_lt(), FLA_Obj_set_imag_part(), FLA_Obj_set_real_part(), FLA_Pow(), FLA_Pythag2(), FLA_Pythag3(), FLA_QR2_UT_opt_var1(), FLA_QR_blk_external(), FLA_QR_form_Q_external(), FLA_QR_unb_external(), FLA_QR_UT_create_T(), FLA_QR_UT_form_Q_opt_var1(), FLA_QR_UT_opt_var1(), FLA_QR_UT_opt_var2(), FLA_QR_UT_piv_colnorm(), FLA_QR_UT_piv_unb_var2(), FLA_Random_matrix(), FLA_Random_tri_matrix(), FLA_SA_Apply_pivots(), FLA_SA_LU_unb(), FLA_Scal_elemwise(), FLA_Scal_external(), FLA_Scal_external_gpu(), FLA_Scalc_external(), FLA_Scale_diag(), FLA_Scalr_external(), FLA_Scalr_external_gpu(), FLA_Set(), FLA_Set_diag(), FLA_Set_diagonal_matrix(), FLA_Set_diagonal_vector(), FLA_Set_offdiag(), FLA_Setr(), FLA_Shift_diag(), FLA_Sort(), FLA_Sort_evd(), FLA_Sort_svd(), FLA_Sqrt(), FLA_Sv_2x2(), FLA_Svd_ext_u_unb_var1(), FLA_Svd_external(), FLA_Svd_uv_unb_var1(), FLA_Svd_uv_unb_var2(), FLA_Svdd_external(), FLA_Svv_2x2(), FLA_Swap_external(), FLA_Swapt_external(), FLA_Sylv_hh_opt_var1(), FLA_Sylv_hn_opt_var1(), FLA_Sylv_nh_opt_var1(), FLA_Sylv_nn_opt_var1(), FLA_Sylv_unb_external(), FLA_Symm_external(), FLA_Symm_external_gpu(), FLA_Symmetrize(), FLA_Symv_external(), FLA_Syr2_external(), FLA_Syr2k_external(), FLA_Syr2k_external_gpu(), FLA_Syr_external(), FLA_Syrk_external(), FLA_Syrk_external_gpu(), FLA_Tevd_eigval_n_opt_var1(), FLA_Tevd_eigval_v_opt_var1(), FLA_Tevd_external(), FLA_Tevd_francis_n_opt_var1(), FLA_Tevd_francis_v_opt_var1(), FLA_Tevd_n_opt_var1(), FLA_Tevd_v_opt_var1(), FLA_Tevd_v_opt_var2(), FLA_Tevdd_external(), FLA_Tevdr_external(), FLA_Triangularize(), FLA_Tridiag_apply_Q_external(), FLA_Tridiag_blk_external(), FLA_Tridiag_form_Q_external(), FLA_Tridiag_unb_external(), FLA_Tridiag_UT_create_T(), FLA_Tridiag_UT_l_blf_var3(), FLA_Tridiag_UT_l_blk_var3(), FLA_Tridiag_UT_l_realify_opt(), FLA_Tridiag_UT_l_realify_unb(), FLA_Tridiag_UT_l_step_ofu_var2(), FLA_Tridiag_UT_l_step_ofu_var3(), FLA_Tridiag_UT_l_step_opt_var1(), FLA_Tridiag_UT_l_step_opt_var2(), FLA_Tridiag_UT_l_step_opt_var3(), FLA_Tridiag_UT_l_step_unb_var1(), FLA_Tridiag_UT_l_step_unb_var2(), FLA_Tridiag_UT_l_step_unb_var3(), FLA_Tridiag_UT_realify_subdiagonal_opt(), FLA_Tridiag_UT_shift_U(), FLA_Tridiag_UT_u_realify_opt(), FLA_Tridiag_UT_u_realify_unb(), FLA_Trinv(), FLA_Trinv_blk_external(), FLA_Trinv_ln_opt_var1(), FLA_Trinv_ln_opt_var2(), FLA_Trinv_ln_opt_var3(), FLA_Trinv_ln_opt_var4(), FLA_Trinv_lu_opt_var1(), FLA_Trinv_lu_opt_var2(), FLA_Trinv_lu_opt_var3(), FLA_Trinv_lu_opt_var4(), FLA_Trinv_un_opt_var1(), FLA_Trinv_un_opt_var2(), FLA_Trinv_un_opt_var3(), FLA_Trinv_un_opt_var4(), FLA_Trinv_unb_external(), FLA_Trinv_uu_opt_var1(), FLA_Trinv_uu_opt_var2(), FLA_Trinv_uu_opt_var3(), FLA_Trinv_uu_opt_var4(), FLA_Trmm_external(), FLA_Trmm_external_gpu(), FLA_Trmmsx_external(), FLA_Trmv_external(), FLA_Trsm_external(), FLA_Trsm_external_gpu(), FLA_Trsmsx_external(), FLA_Trsv_external(), FLA_Trsv_external_gpu(), FLA_Ttmm(), FLA_Ttmm_blk_external(), FLA_Ttmm_l_opt_var1(), FLA_Ttmm_l_opt_var2(), FLA_Ttmm_l_opt_var3(), FLA_Ttmm_u_opt_var1(), FLA_Ttmm_u_opt_var2(), FLA_Ttmm_u_opt_var3(), FLA_Ttmm_unb_external(), FLA_UDdate_UT_create_T(), FLA_UDdate_UT_opt_var1(), FLA_Wilkshift_tridiag(), FLASH_Apply_CAQ_UT_inc_create_workspace(), FLASH_Apply_Q_UT_create_workspace(), FLASH_Apply_Q_UT_inc_create_workspace(), FLASH_Apply_QUD_UT_inc_create_workspace(), FLASH_CAQR_UT_inc_create_hier_matrices(), FLASH_LQ_UT_create_hier_matrices(), FLASH_LU_incpiv_create_hier_matrices(), FLASH_Obj_create_diag_panel(), FLASH_Obj_create_hier_conf_to_flat(), FLASH_Obj_create_hier_conf_to_flat_ext(), FLASH_Obj_datatype(), FLASH_Obj_show_hierarchy(), FLASH_print_struct_helper(), FLASH_QR_UT_create_hier_matrices(), FLASH_QR_UT_inc_create_hier_matrices(), FLASH_Queue_init_tasks(), FLASH_Queue_prefetch_block(), FLASH_Queue_read_gpu(), FLASH_Queue_write_gpu(), and FLASH_UDdate_UT_inc_create_hier_matrices().

◆ FLA_Obj_datatype_check()

FLA_Error FLA_Obj_datatype_check ( FLA_Obj obj )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj.base );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, and FLA_Check_null_pointer().

Referenced by FLA_Obj_datatype().

◆ FLA_Obj_datatype_proj_to_complex()

FLA_Datatype FLA_Obj_datatype_proj_to_complex ( FLA_Obj A )

{
    FLA_Datatype datatype;
 
    if ( FLA_Obj_is_single_precision( A ) )
        datatype = FLA_COMPLEX;
    else
        datatype = FLA_DOUBLE_COMPLEX;
 
    return datatype;
}

References FLA_Obj_is_single_precision().

Referenced by FLA_Bsvd_create_workspace(), FLA_Hevd_lv_unb_var1(), FLA_Hevd_lv_unb_var2(), FLA_Svd_ext_u_unb_var1(), FLA_Svd_uv_unb_var1(), and FLA_Svd_uv_unb_var2().

◆ FLA_Obj_datatype_proj_to_real()

FLA_Datatype FLA_Obj_datatype_proj_to_real ( FLA_Obj A )

{
    FLA_Datatype datatype;
 
    if ( FLA_Obj_is_single_precision( A ) )
        datatype = FLA_FLOAT;
    else
        datatype = FLA_DOUBLE;
 
    return datatype;
}

References FLA_Obj_is_single_precision().

Referenced by FLA_Bidiag_blk_external(), FLA_Bidiag_unb_external(), FLA_Bsvd_external(), FLA_Bsvdd_external(), FLA_Fill_with_cluster_dist(), FLA_Fill_with_geometric_dist(), FLA_Fill_with_inverse_dist(), FLA_Fill_with_linear_dist(), FLA_Fill_with_logarithmic_dist(), FLA_Fill_with_random_dist(), FLA_Hevd_compute_scaling(), FLA_Hevd_external(), FLA_Hevd_lv_unb_var1(), FLA_Hevd_lv_unb_var2(), FLA_Hevdd_external(), FLA_Hevdr_external(), FLA_Svd_compute_scaling(), FLA_Svd_ext_u_unb_var1(), FLA_Svd_external(), FLA_Svd_uv_unb_var1(), FLA_Svd_uv_unb_var2(), FLA_Svdd_external(), FLA_Tevd_external(), FLA_Tevdd_external(), FLA_Tevdr_external(), FLA_Tridiag_blk_external(), and FLA_Tridiag_unb_external().

◆ FLA_Obj_datatype_proj_to_real_check()

FLA_Error FLA_Obj_datatype_proj_to_real_check ( FLA_Obj obj )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj.base );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_floating_object( obj );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( obj );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_floating_object(), FLA_Check_nonconstant_object(), and FLA_Check_null_pointer().

◆ FLA_Obj_datatype_size()

dim_t FLA_Obj_datatype_size ( FLA_Datatype datatype )

{
  dim_t datatype_size = 0;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_datatype_size_check( datatype );
 
  switch( datatype )
  {
    case FLA_INT: 
      datatype_size = sizeof( int );
      break;
    case FLA_FLOAT: 
      datatype_size = sizeof( float );
      break;
    case FLA_DOUBLE: 
      datatype_size = sizeof( double );
      break;
    case FLA_COMPLEX: 
      datatype_size = sizeof( scomplex );
      break;
    case FLA_DOUBLE_COMPLEX: 
      datatype_size = sizeof( dcomplex );
      break;
    case FLA_CONSTANT: 
      datatype_size = FLA_CONSTANT_SIZE;
      break;
  }
 
  return datatype_size;
}

References FLA_Check_error_level(), and FLA_Obj_datatype_size_check().

Referenced by FLA_Check_identical_object_precision(), FLA_Obj_elem_size(), FLASH_Obj_create_hierarchy(), FLASH_Queue_alloc_gpu(), FLASH_Queue_init_tasks(), FLASH_Queue_read_gpu(), and FLASH_Queue_write_gpu().

◆ FLA_Obj_datatype_size_check()

FLA_Error FLA_Obj_datatype_size_check ( FLA_Datatype datatype )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_datatype( datatype );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_valid_datatype().

Referenced by FLA_Obj_datatype_size().

◆ FLA_Obj_elem_size()

dim_t FLA_Obj_elem_size ( FLA_Obj obj )

{
  dim_t elem_size = 0;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_elem_size_check( obj );
 
  if ( FLA_Obj_elemtype( obj ) == FLA_MATRIX )
  {
    elem_size = sizeof( FLA_Obj );
  }
  else // if ( FLA_Obj_elemtype( obj ) == FLA_SCALAR )
  {
    elem_size = FLA_Obj_datatype_size( FLA_Obj_datatype( obj ) );
  }
 
  return elem_size;
}

References FLA_Check_error_level(), FLA_Obj_datatype(), FLA_Obj_datatype_size(), FLA_Obj_elem_size_check(), and FLA_Obj_elemtype().

Referenced by FLA_Obj_buffer_at_view(), FLA_Obj_create_buffer(), FLA_Obj_create_ext(), and FLASH_Queue_prefetch_block().

◆ FLA_Obj_elem_size_check()

FLA_Error FLA_Obj_elem_size_check ( FLA_Obj obj )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_elemtype( FLA_Obj_elemtype( obj ) );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_datatype( FLA_Obj_datatype( obj ) );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_valid_datatype(), FLA_Check_valid_elemtype(), FLA_Obj_datatype(), and FLA_Obj_elemtype().

Referenced by FLA_Obj_elem_size().

◆ FLA_Obj_elemtype()

FLA_Elemtype FLA_Obj_elemtype ( FLA_Obj obj )

{
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_elemtype_check( obj );
 
  return obj.base->elemtype;
}

References FLA_Obj_view::base, FLA_Obj_struct::elemtype, FLA_Check_error_level(), and FLA_Obj_elemtype_check().

Referenced by FLA_Apply_CAQ2_UT_internal(), FLA_Apply_CAQ2_UT_internal_check(), FLA_Apply_Q2_UT_internal(), FLA_Apply_Q2_UT_internal_check(), FLA_Apply_Q_UT_internal(), FLA_Apply_QUD_UT_internal(), FLA_Apply_QUD_UT_internal_check(), FLA_Axpy_internal(), FLA_Axpyt_internal(), FLA_CAQR2_UT_internal(), FLA_Check_identical_object_elemtype(), FLA_Check_object_matrix_elemtype(), FLA_Check_object_scalar_elemtype(), FLA_Check_submatrix_dims_and_offset(), FLA_Chol_internal(), FLA_Copy_internal(), FLA_Copyr_internal(), FLA_Copyt_internal(), FLA_Eig_gest_internal(), FLA_Gemm_internal(), FLA_Gemv_internal(), FLA_Hemm_internal(), FLA_Her2k_internal(), FLA_Herk_internal(), FLA_LU_nopiv_internal(), FLA_Lyap_internal(), FLA_Obj_create_buffer(), FLA_Obj_create_conf_to(), FLA_Obj_create_ext(), FLA_Obj_elem_size(), FLA_Obj_elem_size_check(), FLA_Obj_free(), FLA_Obj_free_buffer(), FLA_QR2_UT_internal(), FLA_Scal_internal(), FLA_Scalr_internal(), FLA_Sylv_internal(), FLA_Symm_internal(), FLA_Syr2k_internal(), FLA_Syrk_internal(), FLA_Trinv_internal(), FLA_Trmm_internal(), FLA_Trsm_internal(), FLA_Trsv_internal(), FLA_Ttmm_internal(), FLA_UDdate_UT_internal(), FLA_UDdate_UT_internal_check(), FLASH_Axpy_hierarchy(), FLASH_Copy_hierarchy(), FLASH_LU_find_zero_on_diagonal(), FLASH_Obj_adjust_views_hierarchy(), FLASH_Obj_attach_buffer_hierarchy(), FLASH_Obj_base_scalar_length(), FLASH_Obj_base_scalar_width(), FLASH_Obj_blocksizes(), FLASH_Obj_depth(), FLASH_Obj_extract_buffer(), FLASH_Obj_free(), FLASH_Obj_free_hierarchy(), FLASH_Obj_free_without_buffer(), FLASH_Obj_scalar_col_offset(), FLASH_Obj_scalar_length(), FLASH_Obj_scalar_length_tl(), FLASH_Obj_scalar_row_offset(), FLASH_Obj_scalar_width(), FLASH_Obj_scalar_width_tl(), FLASH_Obj_show(), FLASH_Obj_show_hierarchy(), FLASH_print_struct(), FLASH_print_struct_helper(), FLASH_Queue_check_gpu(), FLASH_Queue_exec_gpu(), FLASH_Queue_init_tasks(), FLASH_Queue_push(), FLASH_Queue_update_cache(), FLASH_Queue_wait_dequeue_block(), FLASH_Task_free(), and FLASH_Task_free_parallel().

◆ FLA_Obj_elemtype_check()

FLA_Error FLA_Obj_elemtype_check ( FLA_Obj obj )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj.base );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, and FLA_Check_null_pointer().

Referenced by FLA_Obj_elemtype().

◆ FLA_Obj_equals()

FLA_Bool FLA_Obj_equals	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Datatype datatype_A;
  FLA_Datatype datatype_B;
  FLA_Datatype datatype;
  dim_t        m, n;
  dim_t        rs_A, cs_A;
  dim_t        rs_B, cs_B;
  dim_t        i, j;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_equals_check( A, B );
 
  m      = FLA_Obj_length( A );
  n      = FLA_Obj_width( A );
  rs_A   = FLA_Obj_row_stride( A );
  cs_A   = FLA_Obj_col_stride( A );
  rs_B   = FLA_Obj_row_stride( B );
  cs_B   = FLA_Obj_col_stride( B );
 
  datatype_A = FLA_Obj_datatype( A );
  datatype_B = FLA_Obj_datatype( B );
 
  // If A is a non-FLA_CONSTANT object, then we should proceed based on the
  // value of datatype_A. In such a situation, either datatype_B is an exact
  // match and we're fine, or datatype_B is FLA_CONSTANT, in which case we're
  // also covered since FLA_CONSTANT encompassas all numerical types.
  // If A is an FLA_CONSTANT object, then we should proceed based on the value
  // of datatype_B. In this case, datatype_B is either a non-FLA_CONSTANT type,
  // which mirrors the second sub-case above, or datatype_B is FLA_CONSTANT,
  // in which case both types are FLA_CONSTANT and therefore we have to handle
  // that case. Only if both are FLA_CONSTANTs does the FLA_CONSTANT case
  // statement below execute.
  if ( datatype_A != FLA_CONSTANT )
    datatype = datatype_A;
  else
    datatype = datatype_B;
 
  switch ( datatype )
  {
    case FLA_CONSTANT:
    {
      // We require ALL floating-point fields to be the same.
      float*    buffs_A = ( float    * ) FLA_FLOAT_PTR( A );
      float*    buffs_B = ( float    * ) FLA_FLOAT_PTR( B );
      double*   buffd_A = ( double   * ) FLA_DOUBLE_PTR( A );
      double*   buffd_B = ( double   * ) FLA_DOUBLE_PTR( B );
      scomplex* buffc_A = ( scomplex * ) FLA_COMPLEX_PTR( A );
      scomplex* buffc_B = ( scomplex * ) FLA_COMPLEX_PTR( B );
      dcomplex* buffz_A = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
      dcomplex* buffz_B = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( B );
 
      if ( *buffs_A != *buffs_B ||
           *buffd_A != *buffd_B ||
           buffc_A->real != buffc_B->real ||
           buffc_A->imag != buffc_B->imag ||
           buffz_A->real != buffz_B->real ||
           buffz_A->imag != buffz_B->imag )
      {
        return FALSE;
      }
 
      break;
    }
 
    case FLA_INT:
    {
      int *buff_A = ( int * ) FLA_INT_PTR( A );
      int *buff_B = ( int * ) FLA_INT_PTR( B );
 
      for ( j = 0; j < n; j++ )
        for ( i = 0; i < m; i++ )
          if ( buff_A[ j * cs_A + i * rs_A ] != 
               buff_B[ j * cs_B + i * rs_B ] )
          {
            return FALSE;
          }
 
      break;
    }
 
    case FLA_FLOAT:
    {
      float *buff_A = ( float * ) FLA_FLOAT_PTR( A );
      float *buff_B = ( float * ) FLA_FLOAT_PTR( B );
 
      for ( j = 0; j < n; j++ )
        for ( i = 0; i < m; i++ )
          if ( buff_A[ j * cs_A + i * rs_A ] != 
               buff_B[ j * cs_B + i * rs_B ] )
          {
            return FALSE;
          }
 
      break;
    }
 
    case FLA_DOUBLE:
    {
      double *buff_A = ( double * ) FLA_DOUBLE_PTR( A );
      double *buff_B = ( double * ) FLA_DOUBLE_PTR( B );
 
      for ( j = 0; j < n; j++ )
        for ( i = 0; i < m; i++ )
          if ( buff_A[ j * cs_A + i * rs_A ] != 
               buff_B[ j * cs_B + i * rs_B ] )
          {
            return FALSE;
          }
 
      break;
    }
 
    case FLA_COMPLEX:
    {
      scomplex *buff_A = ( scomplex * ) FLA_COMPLEX_PTR( A );
      scomplex *buff_B = ( scomplex * ) FLA_COMPLEX_PTR( B );
 
      for ( j = 0; j < n; j++ )
        for ( i = 0; i < m; i++ )
          if ( buff_A[ j * cs_A + i * rs_A ].real != buff_B[ j * cs_B + i * rs_B ].real ||
               buff_A[ j * cs_A + i * rs_A ].imag != buff_B[ j * cs_B + i * rs_B ].imag )
          {
            return FALSE;
          }
 
      break;
    }
 
    case FLA_DOUBLE_COMPLEX:
    {
      dcomplex *buff_A = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
      dcomplex *buff_B = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( B );
 
      for ( j = 0; j < n; j++ )
        for ( i = 0; i < m; i++ )
          if ( buff_A[ j * cs_A + i * rs_A ].real != buff_B[ j * cs_B + i * rs_B ].real ||
               buff_A[ j * cs_A + i * rs_A ].imag != buff_B[ j * cs_B + i * rs_B ].imag )
          {
            return FALSE;
          }
 
      break;
    }
  }
 
  return TRUE;
}

References FLA_Check_error_level(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_equals_check(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_width(), i, imag, scomplex::imag, dcomplex::imag, scomplex::real, and dcomplex::real.

Referenced by FLA_Apply_H2_UT_l_opt_var1(), FLA_Apply_H2_UT_l_unb_var1(), FLA_Apply_H2_UT_r_opt_var1(), FLA_Apply_H2_UT_r_unb_var1(), FLA_Axpy_internal(), FLA_Axpyt_internal(), FLA_Check_divide_by_zero(), FLA_Hevd_lv_unb_var1(), FLA_Hevd_lv_unb_var2(), FLA_Inv_scal_external(), FLA_Inv_scalc_external(), FLA_LU_find_zero_on_diagonal(), FLA_Scal_external(), FLA_Scal_external_gpu(), FLA_Scal_internal(), FLA_Scalc_external(), FLA_Scalr_external_gpu(), FLA_Scalr_internal(), FLA_Svd_uv_unb_var1(), and FLA_Svd_uv_unb_var2().

◆ FLA_Obj_equals_check()

FLA_Error FLA_Obj_equals_check	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_consistent_object_datatype( A, B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_conformal_dims( FLA_NO_TRANSPOSE, A, B );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_conformal_dims(), FLA_Check_consistent_object_datatype(), and FLA_Check_valid_object_datatype().

Referenced by FLA_Obj_equals().

◆ FLA_Obj_extract_complex_scalar()

void FLA_Obj_extract_complex_scalar	(	FLA_Obj	alpha,
		dcomplex *	alpha_value
	)

{
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_extract_complex_scalar_check( alpha, alpha_value );
 
  if ( FLA_Obj_is_single_precision( alpha ) )
  {
    scomplex temp = *FLA_COMPLEX_PTR( alpha );
    alpha_value->real = ( double ) temp.real;
    alpha_value->imag = ( double ) temp.imag;
  }
  else
    *alpha_value = *FLA_DOUBLE_COMPLEX_PTR( alpha );
}

References FLA_Check_error_level(), FLA_Obj_extract_complex_scalar_check(), FLA_Obj_is_single_precision(), dcomplex::imag, dcomplex::real, and temp.

◆ FLA_Obj_extract_complex_scalar_check()

FLA_Error FLA_Obj_extract_complex_scalar_check	(	FLA_Obj	alpha,
		dcomplex *	alpha_value
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_complex_object( alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( alpha_value );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_complex_object(), FLA_Check_if_scalar(), and FLA_Check_null_pointer().

Referenced by FLA_Obj_extract_complex_scalar().

◆ FLA_Obj_extract_imag_part()

void FLA_Obj_extract_imag_part	(	FLA_Obj	alpha,
		FLA_Obj	beta
	)

{
  FLA_Datatype datatype;
  int          m, inc_a, inc_b;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_extract_imag_part_check( a, b );
 
  datatype = FLA_Obj_datatype( a );
 
  m        = FLA_Obj_vector_dim( a );
  inc_a    = FLA_Obj_vector_inc( a );
  inc_b    = FLA_Obj_vector_inc( b );
 
  switch ( datatype )
  {
  case FLA_FLOAT:
    {
      float* buff_b = FLA_FLOAT_PTR( b );
      float* buff_0 = FLA_FLOAT_PTR( FLA_ZERO );
      bl1_ssetv( m,
                 buff_0,
                 buff_b, inc_b );
      break;
    }
  case FLA_DOUBLE: 
    {
      double* buff_b = FLA_DOUBLE_PTR( b );
      double* buff_0 = FLA_DOUBLE_PTR( FLA_ZERO );
      bl1_dsetv( m,
                 buff_0,
                 buff_b, inc_b );
      break;
    }
  case FLA_COMPLEX: 
    {
      float* buff_a = FLA_FLOAT_PTR( a ); 
      float* buff_b = FLA_FLOAT_PTR( b );
      bl1_scopy( m, 
                 ++buff_a, inc_a*2, 
                 buff_b, inc_b );        
      break;
    }
  case FLA_DOUBLE_COMPLEX: 
    {
      double* buff_a = FLA_DOUBLE_PTR( a );
      double* buff_b = FLA_DOUBLE_PTR( b );
      bl1_dcopy( m, 
                 ++buff_a, inc_a*2, 
                 buff_b, inc_b );        
      break;
    }
  }
}

References bl1_dcopy(), bl1_dsetv(), bl1_scopy(), bl1_ssetv(), FLA_Check_error_level(), FLA_Obj_datatype(), FLA_Obj_extract_imag_part_check(), FLA_Obj_vector_dim(), FLA_Obj_vector_inc(), and FLA_ZERO.

◆ FLA_Obj_extract_imag_part_check()

FLA_Error FLA_Obj_extract_imag_part_check	(	FLA_Obj	alpha,
		FLA_Obj	beta
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_floating_object( a );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_real_object( b );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( b );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_identical_object_precision( a, b );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_vector_dim( a, FLA_Obj_vector_dim( b ) );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_floating_object(), FLA_Check_identical_object_precision(), FLA_Check_nonconstant_object(), FLA_Check_real_object(), FLA_Check_vector_dim(), and FLA_Obj_vector_dim().

Referenced by FLA_Obj_extract_imag_part().

◆ FLA_Obj_extract_real_part()

void FLA_Obj_extract_real_part	(	FLA_Obj	alpha,
		FLA_Obj	beta
	)

{
  FLA_Datatype datatype;
  int          m, inc_a, inc_b;
  
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_extract_real_part_check( a, b );
 
  datatype = FLA_Obj_datatype( a );
 
  m        = FLA_Obj_vector_dim( a );
  inc_a    = FLA_Obj_vector_inc( a );
  inc_b    = FLA_Obj_vector_inc( b );
 
  switch ( datatype )
  {
  case FLA_FLOAT:
    {
      float* buff_a = FLA_FLOAT_PTR( a );
      float* buff_b = FLA_FLOAT_PTR( b );
      bl1_scopy( m, 
                 buff_a, inc_a, 
                 buff_b, inc_b );        
      break;
    }
  case FLA_DOUBLE: 
    {
      double* buff_a = FLA_DOUBLE_PTR( a );
      double* buff_b = FLA_DOUBLE_PTR( b );
      bl1_dcopy( m, 
                 buff_a, inc_a, 
                 buff_b, inc_b );        
      break;
    }
  case FLA_COMPLEX: 
    {
      float* buff_a = FLA_FLOAT_PTR( a ); 
      float* buff_b = FLA_FLOAT_PTR( b );
      bl1_scopy( m, 
                 buff_a, inc_a*2, 
                 buff_b, inc_b );        
      break;
    }
  case FLA_DOUBLE_COMPLEX: 
    {
      double* buff_a = FLA_DOUBLE_PTR( a );
      double* buff_b = FLA_DOUBLE_PTR( b );
      bl1_dcopy( m, 
                 buff_a, inc_a*2, 
                 buff_b, inc_b );        
      break;
    }
  }
}

References bl1_dcopy(), bl1_scopy(), FLA_Check_error_level(), FLA_Obj_datatype(), FLA_Obj_extract_real_part_check(), FLA_Obj_vector_dim(), and FLA_Obj_vector_inc().

Referenced by FLA_QR_UT_piv_colnorm().

◆ FLA_Obj_extract_real_part_check()

FLA_Error FLA_Obj_extract_real_part_check	(	FLA_Obj	alpha,
		FLA_Obj	beta
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_floating_object( a );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_real_object( b );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( b );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_identical_object_precision( a, b );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_vector_dim( a, FLA_Obj_vector_dim( b ) );
  FLA_Check_error_code( e_val );  
 
  return FLA_SUCCESS;
}

References FLA_Check_floating_object(), FLA_Check_identical_object_precision(), FLA_Check_nonconstant_object(), FLA_Check_real_object(), FLA_Check_vector_dim(), and FLA_Obj_vector_dim().

Referenced by FLA_Obj_extract_real_part().

◆ FLA_Obj_extract_real_scalar()

void FLA_Obj_extract_real_scalar	(	FLA_Obj	alpha,
		double *	alpha_value
	)

{
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_extract_real_scalar_check( alpha, alpha_value );
 
  if ( FLA_Obj_is_single_precision( alpha ) )
    *alpha_value = ( double ) *FLA_FLOAT_PTR( alpha );
  else
    *alpha_value = *FLA_DOUBLE_PTR( alpha );
}

References FLA_Check_error_level(), FLA_Obj_extract_real_scalar_check(), and FLA_Obj_is_single_precision().

◆ FLA_Obj_extract_real_scalar_check()

FLA_Error FLA_Obj_extract_real_scalar_check	(	FLA_Obj	alpha,
		double *	alpha_value
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_real_object( alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( alpha_value );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_if_scalar(), FLA_Check_null_pointer(), and FLA_Check_real_object().

Referenced by FLA_Obj_extract_real_scalar().

◆ FLA_Obj_flip_base()

FLA_Error FLA_Obj_flip_base ( FLA_Obj * obj )

{
  FLA_Error e_val;
  dim_t temp;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
  {
    e_val = FLA_Check_null_pointer( obj );
    FLA_Check_error_code( e_val );
    
    e_val = FLA_Check_null_pointer( obj->base );
    FLA_Check_error_code( e_val );
  }
 
  exchange( obj->base->m,       obj->base->n,       temp );
  exchange( obj->base->cs,      obj->base->rs,      temp );
  exchange( obj->base->m_inner, obj->base->n_inner, temp );
  exchange( obj->base->m_index, obj->base->n_index, temp );
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Obj_struct::cs, FLA_Check_error_level(), FLA_Check_null_pointer(), FLA_Obj_struct::m, FLA_Obj_struct::m_index, FLA_Obj_struct::m_inner, FLA_Obj_struct::n, FLA_Obj_struct::n_index, FLA_Obj_struct::n_inner, FLA_Obj_struct::rs, and temp.

Referenced by FLA_Bidiag_UT_form_U_ext(), FLA_Bidiag_UT_form_V_ext(), FLA_Bidiag_UT_internal(), FLA_LQ_UT_form_Q(), FLA_Svd(), FLA_Svd_ext(), and FLA_Svd_ext_u_unb_var1().

◆ FLA_Obj_flip_view()

FLA_Error FLA_Obj_flip_view ( FLA_Obj * obj )

{
  FLA_Error e_val;
  dim_t temp;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
  {
    e_val = FLA_Check_null_pointer( obj );
    FLA_Check_error_code( e_val );
  }
 
  exchange( obj->offm,    obj->offn,    temp );
  exchange( obj->m,       obj->n,       temp );
  exchange( obj->m_inner, obj->n_inner, temp );
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_Check_null_pointer(), FLA_Obj_view::m, FLA_Obj_view::m_inner, FLA_Obj_view::n, FLA_Obj_view::n_inner, FLA_Obj_view::offm, FLA_Obj_view::offn, and temp.

Referenced by FLA_Bidiag_UT_form_U_ext(), FLA_Bidiag_UT_form_V_ext(), FLA_Bidiag_UT_internal(), FLA_LQ_UT_form_Q(), FLA_Svd(), FLA_Svd_ext(), and FLA_Svd_ext_u_unb_var1().

◆ FLA_Obj_free()

FLA_Error FLA_Obj_free ( FLA_Obj * obj )

{
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_free_check( obj );
 
  if ( obj->base != NULL ) 
  {
#ifdef FLA_ENABLE_SCC
    ( FLA_Obj_elemtype( *obj ) == FLA_MATRIX ? FLA_free( obj->base->buffer ) : FLA_shfree( obj->base->buffer ) );
#else
    //printf( "freeing buff %p\n", obj->base->buffer ); fflush( stdout );
    FLA_free( obj->base->buffer );
#endif
    //printf( "freeing base %p\n", obj->base ); fflush( stdout );
    FLA_free( ( void * ) obj->base );
  }
 
  obj->offm = 0;
  obj->offn = 0;
  obj->m    = 0;
  obj->n    = 0;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Obj_struct::buffer, FLA_Check_error_level(), FLA_free(), FLA_Obj_elemtype(), FLA_Obj_free_check(), FLA_shfree(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Obj_free_buffer()

FLA_Error FLA_Obj_free_buffer ( FLA_Obj * obj )

{
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_free_buffer_check( obj );
 
#ifdef FLA_ENABLE_SCC
  ( FLA_Obj_elemtype( *obj ) == FLA_MATRIX ? FLA_free( obj->base->buffer ) : FLA_shfree( obj->base->buffer ) );
#else
  FLA_free( obj->base->buffer );
#endif
  obj->base->buffer = NULL;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Obj_struct::buffer, FLA_Check_error_level(), FLA_free(), FLA_Obj_elemtype(), FLA_Obj_free_buffer_check(), and FLA_shfree().

Referenced by FLA_Obj_free_buffer_task().

◆ FLA_Obj_free_buffer_check()

FLA_Error FLA_Obj_free_buffer_check ( FLA_Obj * obj )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( obj->base );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, and FLA_Check_null_pointer().

Referenced by FLA_Obj_free_buffer().

◆ FLA_Obj_free_buffer_task()

FLA_Error FLA_Obj_free_buffer_task	(	FLA_Obj	obj,
		void *	cntl
	)

{
  return FLA_Obj_free_buffer( &obj );
}

References FLA_Obj_free_buffer().

Referenced by FLASH_Queue_exec_task(), and FLASH_Queue_init_tasks().

◆ FLA_Obj_free_check()

FLA_Error FLA_Obj_free_check ( FLA_Obj * obj )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  // FLA_Free check base pointer; thus, this is not necessary.
  //e_val = FLA_Check_null_pointer( obj->base );
  //FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer().

Referenced by FLA_Obj_free().

◆ FLA_Obj_free_without_buffer()

FLA_Error FLA_Obj_free_without_buffer ( FLA_Obj * obj )

{
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_free_without_buffer_check( obj );
 
  FLA_free( ( void * ) obj->base );
 
  obj->offm = 0;
  obj->offn = 0;
  obj->m    = 0;
  obj->n    = 0;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_free(), FLA_Obj_free_without_buffer_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

Referenced by FLA_Axpy_buffer_to_object(), FLA_Axpy_object_to_buffer(), FLA_Copy_buffer_to_object(), FLA_Copy_object_to_buffer(), FLASH_Axpy_buffer_to_hier(), FLASH_Axpy_hier_to_buffer(), FLASH_Copy_buffer_to_hier(), FLASH_Copy_hier_to_buffer(), FLASH_Obj_attach_buffer(), FLASH_Obj_create_helper(), FLASH_Obj_create_hierarchy(), FLASH_Obj_free_hierarchy(), and FLASH_Obj_free_without_buffer().

◆ FLA_Obj_free_without_buffer_check()

FLA_Error FLA_Obj_free_without_buffer_check ( FLA_Obj * obj )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( obj );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( obj->base );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, and FLA_Check_null_pointer().

Referenced by FLA_Obj_free_without_buffer().

◆ FLA_Obj_fshow()

FLA_Error FLA_Obj_fshow	(	FILE *	file,
		char *	s1,
		FLA_Obj	A,
		char *	format,
		char *	s2
	)

{
  FLA_Datatype datatype;
  dim_t        i, j, m, n;
  dim_t        rs, cs;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_fshow_check( file, s1, A, format, s2 );
 
  datatype = FLA_Obj_datatype( A );
  m        = FLA_Obj_length( A );
  n        = FLA_Obj_width( A );
  rs       = FLA_Obj_row_stride( A );
  cs       = FLA_Obj_col_stride( A );
 
  fprintf( file, "%s\n", s1 );
 
  switch ( datatype ){
 
  case FLA_CONSTANT:
  {
    int*      consti = FLA_INT_PTR( A );
    float*    consts = FLA_FLOAT_PTR( A );
    double*   constd = FLA_DOUBLE_PTR( A );
    scomplex* constc = FLA_COMPLEX_PTR( A );
    dcomplex* constz = FLA_DOUBLE_COMPLEX_PTR( A );
 
    fprintf( file, "int      = %d\n", *consti );
    fprintf( file, "float    = %e\n", *consts );
    fprintf( file, "double   = %e\n", *constd );
    fprintf( file, "scomplex = %e + %e\n", constc->real, constc->imag );
    fprintf( file, "dcomplex = %e + %e\n", constz->real, constc->imag );
 
    break;
  }
 
  case FLA_FLOAT:
  {
    float *buffer = ( float * ) FLA_FLOAT_PTR( A );
 
    for ( i = 0; i < m; i++ )
    {
      for ( j = 0; j < n; j++ )
      {
        fprintf( file, format, buffer[ j*cs + i*rs ] );
        fprintf( file, " " );
      }
      fprintf( file, "\n" );
    }
 
    break;
  }
 
  case FLA_DOUBLE:
  {
    double *buffer = ( double * ) FLA_DOUBLE_PTR( A );
 
    for ( i = 0; i < m; i++ )
    {
      for ( j = 0; j < n; j++ )
      {
        fprintf( file, format, buffer[ j*cs + i*rs ] );
        fprintf( file, " " );
      }
      fprintf( file, "\n" );
    }
 
    break;
  }
 
  case FLA_COMPLEX:
  {
    scomplex *buffer = ( scomplex * ) FLA_COMPLEX_PTR( A );
 
    for ( i = 0; i < m; i++ )
    {
      for ( j = 0; j < n; j++ )
      {
        //fprintf( file, format, buffer[ j*cs + i*rs ].real, buffer[ j*cs + i*rs ].imag );
        //fprintf( file, " " );
        fprintf( file, format, buffer[ j*cs + i*rs ].real );
        fprintf( file, " + i * " );
        fprintf( file, format, buffer[ j*cs + i*rs ].imag );
        fprintf( file, "  " );
      }
      fprintf( file, "\n" );
    }
 
    break;
  }
 
  case FLA_DOUBLE_COMPLEX:
  {
    dcomplex *buffer = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
 
    for ( i = 0; i < m; i++ )
    {
      for ( j = 0; j < n; j++ )
      {
        //fprintf( file, format, buffer[ j*cs + i*rs ].real, buffer[ j*cs + i*rs ].imag );
        //fprintf( file, " " );
        fprintf( file, format, buffer[ j*cs + i*rs ].real );
        fprintf( file, " + i * " );
        fprintf( file, format, buffer[ j*cs + i*rs ].imag );
        fprintf( file, "  " );
      }
      fprintf( file, "\n" );
    }
 
    break;
  }
 
  case FLA_INT:
  {
    int *buffer = ( int * ) FLA_INT_PTR( A );
 
    for ( i = 0; i < m; i++ )
    {
      for ( j = 0; j < n; j++ )
      {
        fprintf( file, format, buffer[ j*cs + i*rs ] );
        fprintf( file, " " );
      }
      fprintf( file, "\n" );
    }
 
    break;
  }
 
  }
 
  fprintf( file, "%s\n", s2 );
 
  return FLA_SUCCESS;
}

References FLA_Check_error_level(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_fshow_check(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_width(), i, imag, scomplex::imag, scomplex::real, and dcomplex::real.

Referenced by FLA_Obj_show().

◆ FLA_Obj_fshow_check()

FLA_Error FLA_Obj_fshow_check	(	FILE *	file,
		char *	s1,
		FLA_Obj	obj,
		char *	format,
		char *	s2
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( file );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( s1 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_object_scalar_elemtype( obj );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( obj );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( format );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( s2 );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), FLA_Check_object_scalar_elemtype(), and FLA_Check_valid_object_datatype().

Referenced by FLA_Obj_fshow().

◆ FLA_Obj_ge()

FLA_Bool FLA_Obj_ge	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Datatype datatype_A;
  FLA_Datatype datatype_B;
  FLA_Datatype datatype;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_ge_check( A, B );
 
  datatype_A = FLA_Obj_datatype( A );
  datatype_B = FLA_Obj_datatype( B );
 
  if ( datatype_A != FLA_CONSTANT ) datatype = datatype_A;
  else                              datatype = datatype_B;
 
  switch ( datatype )
  {
    case FLA_CONSTANT:
    {
      // We require ALL floating-point fields to be the same.
      float*    buffs_A = ( float    * ) FLA_FLOAT_PTR( A );
      float*    buffs_B = ( float    * ) FLA_FLOAT_PTR( B );
      double*   buffd_A = ( double   * ) FLA_DOUBLE_PTR( A );
      double*   buffd_B = ( double   * ) FLA_DOUBLE_PTR( B );
      scomplex* buffc_A = ( scomplex * ) FLA_COMPLEX_PTR( A );
      scomplex* buffc_B = ( scomplex * ) FLA_COMPLEX_PTR( B );
      dcomplex* buffz_A = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
      dcomplex* buffz_B = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( B );
 
      if ( !( *buffs_A      >= *buffs_B      &&
              *buffd_A      >= *buffd_B      &&
              buffc_A->real >= buffc_B->real &&
              buffc_A->imag >= buffc_B->imag &&
              buffz_A->real >= buffz_B->real &&
              buffz_A->imag >= buffz_B->imag ) )
      {
        return FALSE;
      }
 
      break;
    }
 
    case FLA_INT:
    {
      int *buff_A = ( int * ) FLA_INT_PTR( A );
      int *buff_B = ( int * ) FLA_INT_PTR( B );
 
      if ( !( *buff_A >= *buff_B ) ) return FALSE;
 
      break;
    }
 
    case FLA_FLOAT:
    {
      float *buff_A = ( float * ) FLA_FLOAT_PTR( A );
      float *buff_B = ( float * ) FLA_FLOAT_PTR( B );
 
      if ( !( *buff_A >= *buff_B ) ) return FALSE;
 
      break;
    }
 
    case FLA_DOUBLE:
    {
      double *buff_A = ( double * ) FLA_DOUBLE_PTR( A );
      double *buff_B = ( double * ) FLA_DOUBLE_PTR( B );
 
      if ( !( *buff_A >= *buff_B ) ) return FALSE;
 
      break;
    }
 
  }
 
  return TRUE;
}

References FLA_Check_error_level(), FLA_Obj_datatype(), FLA_Obj_ge_check(), scomplex::imag, dcomplex::imag, scomplex::real, and dcomplex::real.

◆ FLA_Obj_ge_check()

FLA_Bool FLA_Obj_ge_check	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_comparable_object( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_consistent_object_datatype( A, B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( B );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_comparable_object(), FLA_Check_consistent_object_datatype(), and FLA_Check_if_scalar().

Referenced by FLA_Obj_ge().

◆ FLA_Obj_gt()

FLA_Bool FLA_Obj_gt	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Datatype datatype_A;
  FLA_Datatype datatype_B;
  FLA_Datatype datatype;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_gt_check( A, B );
 
  datatype_A = FLA_Obj_datatype( A );
  datatype_B = FLA_Obj_datatype( B );
 
  if ( datatype_A != FLA_CONSTANT ) datatype = datatype_A;
  else                              datatype = datatype_B;
 
  switch ( datatype )
  {
    case FLA_CONSTANT:
    {
      // We require ALL floating-point fields to be the same.
      float*    buffs_A = ( float    * ) FLA_FLOAT_PTR( A );
      float*    buffs_B = ( float    * ) FLA_FLOAT_PTR( B );
      double*   buffd_A = ( double   * ) FLA_DOUBLE_PTR( A );
      double*   buffd_B = ( double   * ) FLA_DOUBLE_PTR( B );
      scomplex* buffc_A = ( scomplex * ) FLA_COMPLEX_PTR( A );
      scomplex* buffc_B = ( scomplex * ) FLA_COMPLEX_PTR( B );
      dcomplex* buffz_A = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
      dcomplex* buffz_B = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( B );
 
      if ( !( *buffs_A      > *buffs_B      &&
              *buffd_A      > *buffd_B      &&
              buffc_A->real > buffc_B->real &&
              buffc_A->imag > buffc_B->imag &&
              buffz_A->real > buffz_B->real &&
              buffz_A->imag > buffz_B->imag ) )
      {
        return FALSE;
      }
 
      break;
    }
 
    case FLA_INT:
    {
      int *buff_A = ( int * ) FLA_INT_PTR( A );
      int *buff_B = ( int * ) FLA_INT_PTR( B );
 
      if ( !( *buff_A > *buff_B ) ) return FALSE;
 
      break;
    }
 
    case FLA_FLOAT:
    {
      float *buff_A = ( float * ) FLA_FLOAT_PTR( A );
      float *buff_B = ( float * ) FLA_FLOAT_PTR( B );
 
      if ( !( *buff_A > *buff_B ) ) return FALSE;
 
      break;
    }
 
    case FLA_DOUBLE:
    {
      double *buff_A = ( double * ) FLA_DOUBLE_PTR( A );
      double *buff_B = ( double * ) FLA_DOUBLE_PTR( B );
 
      if ( !( *buff_A > *buff_B ) ) return FALSE;
 
      break;
    }
 
  }
 
  return TRUE;
}

References FLA_Check_error_level(), FLA_Obj_datatype(), FLA_Obj_gt_check(), scomplex::imag, dcomplex::imag, scomplex::real, and dcomplex::real.

Referenced by FLA_Hevd_compute_scaling(), FLA_Svd_compute_scaling(), and FLA_Svd_ext_u_unb_var1().

◆ FLA_Obj_gt_check()

FLA_Bool FLA_Obj_gt_check	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_comparable_object( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_consistent_object_datatype( A, B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( B );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_comparable_object(), FLA_Check_consistent_object_datatype(), and FLA_Check_if_scalar().

Referenced by FLA_Obj_gt().

◆ FLA_Obj_has_nan()

FLA_Bool FLA_Obj_has_nan ( FLA_Obj A )

{
  FLA_Datatype datatype;
  dim_t        i, j, m, n, cs, rs;
  
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_has_nan_check( A );
 
  datatype = FLA_Obj_datatype( A );
  m        = FLA_Obj_length( A );
  n        = FLA_Obj_width( A );
  cs       = FLA_Obj_col_stride( A );
  rs       = FLA_Obj_row_stride( A );
 
  switch ( datatype )
  {
    case FLA_FLOAT:
    {
      float *buff = ( float * ) FLA_FLOAT_PTR( A );
 
      for ( j=0; j<n; ++j )
        for ( i=0; i<m; ++i ) 
        {
          float val = buff[i*cs + j*rs];
          if ( val != val ) return TRUE;
        }
      break;
    }
    case FLA_DOUBLE:
    {
      double *buff = ( double * ) FLA_DOUBLE_PTR( A );
 
      for ( j=0; j<n; ++j )
        for ( i=0; i<m; ++i ) 
        {
          double val = buff[i*cs + j*rs];
          if ( val != val ) return TRUE;
        }
      break;
    }
    case FLA_COMPLEX:
    {
      scomplex *buff = ( scomplex * ) FLA_COMPLEX_PTR( A );
 
      for ( j=0; j<n; ++j )
        for ( i=0; i<m; ++i ) 
        {
          scomplex val = buff[i*cs + j*rs];
          if ( val.real != val.real || val.imag != val.imag ) return TRUE;
        }
      break;
    }
    case FLA_DOUBLE_COMPLEX:
    {
      dcomplex *buff = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
 
      for ( j=0; j<n; ++j )
        for ( i=0; i<m; ++i ) 
        {
          dcomplex val = buff[i*cs + j*rs];
          if ( val.real != val.real || val.imag != val.imag ) return TRUE;
        }
      break;
    }
  }
 
  return FALSE;
}

References FLA_Check_error_level(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_has_nan_check(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_width(), i, scomplex::imag, dcomplex::imag, scomplex::real, and dcomplex::real.

◆ FLA_Obj_has_nan_check()

FLA_Error FLA_Obj_has_nan_check ( FLA_Obj A )

{
  FLA_Error e_val;
 
  e_val = FLA_Check_floating_object( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( A );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_floating_object(), and FLA_Check_nonconstant_object().

Referenced by FLA_Obj_has_nan().

◆ FLA_Obj_has_zero_dim()

FLA_Bool FLA_Obj_has_zero_dim ( FLA_Obj A )

{
  FLA_Bool r_val = FALSE;
 
  if ( FLA_Obj_length( A ) == 0 || FLA_Obj_width( A ) == 0 )
    r_val = TRUE;
 
  return r_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

◆ FLA_Obj_is()

FLA_Bool FLA_Obj_is	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Bool r_val = FALSE;
 
  if ( A.base == B.base )
    r_val = TRUE;
 
  return r_val;
}

References FLA_Obj_view::base.

Referenced by FLA_Bidiag_UT_form_U_ext(), FLA_Bidiag_UT_form_V_ext(), FLA_Check_valid_isgn_value(), FLA_LQ_UT_form_Q(), and FLA_Tridiag_UT_form_Q().

◆ FLA_Obj_is_col_major()

FLA_Bool FLA_Obj_is_col_major ( FLA_Obj A )

{
  FLA_Bool r_val = FALSE;
 
  // A row stride of 1 indicates column-major storage.
  if ( FLA_Obj_row_stride( A ) == 1 )
    r_val = TRUE;
 
  return r_val;
}

References FLA_Obj_row_stride().

◆ FLA_Obj_is_complex()

FLA_Bool FLA_Obj_is_complex ( FLA_Obj A )

{
  FLA_Datatype datatype;
  FLA_Bool     r_val;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( datatype == FLA_CONSTANT || datatype == FLA_COMPLEX || datatype == FLA_DOUBLE_COMPLEX )
    r_val = TRUE;
  else
    r_val = FALSE;
 
  return r_val;
}

References FLA_Obj_datatype().

Referenced by FLA_Bidiag_UT_internal(), FLA_Check_conj1_trans_and_datatype(), FLA_Check_conj_and_datatype(), FLA_Check_identical_object_precision(), FLA_Hevdd_external(), FLA_Hevdr_external(), FLA_LQ_UT_form_Q(), FLA_Obj_set_imag_part(), FLA_Obj_set_real_part(), FLA_Svd(), FLA_Svd_ext(), FLA_Svd_ext_u_unb_var1(), FLA_Svd_external(), FLA_Svdd_external(), and FLA_Tevdd_external().

◆ FLA_Obj_is_conformal_to()

FLA_Bool FLA_Obj_is_conformal_to	(	FLA_Trans	trans,
		FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Bool r_val = TRUE;
 
  if ( trans == FLA_NO_TRANSPOSE || trans == FLA_CONJ_NO_TRANSPOSE )
  {
    if ( FLA_Obj_length( A ) != FLA_Obj_length( B ) ||
         FLA_Obj_width( A )  != FLA_Obj_width( B ) )
      r_val = FALSE;
  }
  else
  {
    if ( FLA_Obj_width( A )  != FLA_Obj_length( B ) ||
         FLA_Obj_length( A ) != FLA_Obj_width( B ) )
      r_val = FALSE;
  }
 
  return r_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

Referenced by FLA_Axpy_external(), FLA_Copy_external(), and FLA_Swap_external().

◆ FLA_Obj_is_constant()

FLA_Bool FLA_Obj_is_constant ( FLA_Obj A )

{
  FLA_Datatype datatype;
  FLA_Bool     r_val;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( datatype == FLA_CONSTANT )
    r_val = TRUE;
  else
    r_val = FALSE;
 
  return r_val;
}

References FLA_Obj_datatype().

Referenced by FLA_Inv_scal_external(), FLA_Inv_scalc_external(), FLA_Scal_external(), FLA_Scalc_external(), and FLA_Scalr_external().

◆ FLA_Obj_is_double_precision()

FLA_Bool FLA_Obj_is_double_precision ( FLA_Obj A )

{
  FLA_Datatype datatype;
  FLA_Bool     r_val;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( datatype == FLA_CONSTANT || datatype == FLA_DOUBLE || datatype == FLA_DOUBLE_COMPLEX )
    r_val = TRUE;
  else
    r_val = FALSE;
 
  return r_val;
}

References FLA_Obj_datatype().

Referenced by FLA_Bidiag_UT(), and FLA_Tridiag_UT().

◆ FLA_Obj_is_floating_point()

FLA_Bool FLA_Obj_is_floating_point ( FLA_Obj A )

{
  FLA_Datatype datatype;
  FLA_Bool     r_val;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( datatype == FLA_FLOAT || datatype == FLA_COMPLEX ||
       datatype == FLA_DOUBLE || datatype == FLA_DOUBLE_COMPLEX )
    r_val = TRUE;
  else
    r_val = FALSE;
 
  return r_val;
}

References FLA_Obj_datatype().

◆ FLA_Obj_is_identical()

FLA_Bool FLA_Obj_is_identical	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Bool r_val = FALSE;
 
  // For LU_piv, if A and B are identical, we do not need copy.
  // Elemtype should be checked as they can have the same buffer pointer
  // but elemtype can be either scalar or matrix.
  if ( A.base != NULL && A.base != NULL )
    if ( ( A.base == B.base ) || 
         ( A.base->elemtype == B.base->elemtype  && 
           A.base->datatype == B.base->datatype ) )
      if ( FLA_Obj_buffer_at_view( A ) == FLA_Obj_buffer_at_view( B ) )
        if ( A.m == B.m && A.n == B.n )
          r_val = TRUE;
  
  return r_val;
}

References FLA_Obj_view::base, FLA_Obj_struct::datatype, FLA_Obj_struct::elemtype, FLA_Obj_buffer_at_view(), FLA_Obj_view::m, and FLA_Obj_view::n.

Referenced by FLA_Chol_solve(), FLA_LU_nopiv_solve(), and FLA_LU_piv_solve().

◆ FLA_Obj_is_int()

FLA_Bool FLA_Obj_is_int ( FLA_Obj A )

{
  FLA_Datatype datatype;
  FLA_Bool     r_val;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( datatype == FLA_INT )
    r_val = TRUE;
  else
    r_val = FALSE;
 
  return r_val;
}

References FLA_Obj_datatype().

◆ FLA_Obj_is_overlapped()

FLA_Bool FLA_Obj_is_overlapped	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Bool r_val = FALSE;
 
  // For form_Q, if A and B are not overlapped, we do not use in-place forming Q.
  if ( A.base != NULL && A.base != NULL )
    if ( ( A.base == B.base ) || 
         ( A.base->elemtype == B.base->elemtype && 
           A.base->datatype == B.base->datatype ) )
      if ( FLA_Obj_buffer_at_view( A ) == FLA_Obj_buffer_at_view( B ) )
        if ( ( ( A.offm <= B.offm && B.offm < ( A.offm + A.m ) ) &&
               ( A.offn <= B.offn && B.offn < ( A.offn + A.n ) ) ) ||
             ( ( B.offm <= A.offm && A.offm < ( B.offm + B.m ) ) &&
               ( B.offn <= A.offn && A.offn < ( B.offn + B.n ) ) ) )
          r_val = TRUE;
  
  return r_val;
}

References FLA_Obj_view::base, FLA_Obj_struct::datatype, FLA_Obj_struct::elemtype, FLA_Obj_buffer_at_view(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

Referenced by FLA_QR_UT_form_Q().

◆ FLA_Obj_is_real()

FLA_Bool FLA_Obj_is_real ( FLA_Obj A )

{
  FLA_Datatype datatype;
  FLA_Bool     r_val;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( datatype == FLA_CONSTANT || datatype == FLA_FLOAT || datatype == FLA_DOUBLE )
    r_val = TRUE;
  else
    r_val = FALSE;
 
  return r_val;
}

References FLA_Obj_datatype().

Referenced by FLA_Apply_Q_check(), FLA_Bidiag_apply_U_external(), FLA_Bidiag_apply_V_external(), FLA_Bidiag_UT_realify(), FLA_Conjugate(), FLA_Conjugate_r(), FLA_Inv_scal_check(), FLA_Inv_scalc_check(), FLA_Scal_check(), FLA_Scalc_check(), FLA_Scale_diag_check(), FLA_Scalr_check(), FLA_Shift_diag_check(), FLA_Tridiag_apply_Q_check(), and FLA_Tridiag_UT_realify().

◆ FLA_Obj_is_row_major()

FLA_Bool FLA_Obj_is_row_major ( FLA_Obj A )

{
  FLA_Bool r_val = FALSE;
 
  // A column stride of 1 indicates row-major storage.
  if ( FLA_Obj_col_stride( A ) == 1 )
    r_val = TRUE;
 
  return r_val;
}

References FLA_Obj_col_stride().

◆ FLA_Obj_is_scalar()

FLA_Bool FLA_Obj_is_scalar ( FLA_Obj A )

{
  FLA_Bool r_val = FALSE;
 
  if ( FLA_Obj_length( A ) == 1 &&
       FLA_Obj_width( A ) == 1 )
    r_val = TRUE;
 
  return r_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

◆ FLA_Obj_is_single_precision()

FLA_Bool FLA_Obj_is_single_precision ( FLA_Obj A )

{
  FLA_Datatype datatype;
  FLA_Bool     r_val;
 
  datatype = FLA_Obj_datatype( A );
 
  if ( datatype == FLA_CONSTANT || datatype == FLA_FLOAT || datatype == FLA_COMPLEX )
    r_val = TRUE;
  else
    r_val = FALSE;
 
  return r_val;
}

References FLA_Obj_datatype().

Referenced by FLA_Obj_datatype_proj_to_complex(), FLA_Obj_datatype_proj_to_real(), FLA_Obj_extract_complex_scalar(), and FLA_Obj_extract_real_scalar().

◆ FLA_Obj_is_vector()

FLA_Bool FLA_Obj_is_vector ( FLA_Obj A )

{
  FLA_Bool r_val = FALSE;
 
  if ( FLA_Obj_length( A ) == 1 || FLA_Obj_width( A ) == 1 )
    r_val = TRUE;
 
  return r_val;
}

References FLA_Obj_length(), and FLA_Obj_width().

Referenced by FLA_Axpy_check(), FLA_Copy_check(), and FLA_Swap_check().

◆ FLA_Obj_le()

FLA_Bool FLA_Obj_le	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Datatype datatype_A;
  FLA_Datatype datatype_B;
  FLA_Datatype datatype;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_le_check( A, B );
 
  datatype_A = FLA_Obj_datatype( A );
  datatype_B = FLA_Obj_datatype( B );
 
  if ( datatype_A != FLA_CONSTANT ) datatype = datatype_A;
  else                              datatype = datatype_B;
 
  switch ( datatype )
  {
    case FLA_CONSTANT:
    {
      // We require ALL floating-point fields to be the same.
      float*    buffs_A = ( float    * ) FLA_FLOAT_PTR( A );
      float*    buffs_B = ( float    * ) FLA_FLOAT_PTR( B );
      double*   buffd_A = ( double   * ) FLA_DOUBLE_PTR( A );
      double*   buffd_B = ( double   * ) FLA_DOUBLE_PTR( B );
      scomplex* buffc_A = ( scomplex * ) FLA_COMPLEX_PTR( A );
      scomplex* buffc_B = ( scomplex * ) FLA_COMPLEX_PTR( B );
      dcomplex* buffz_A = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
      dcomplex* buffz_B = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( B );
 
      if ( !( *buffs_A      <= *buffs_B      &&
              *buffd_A      <= *buffd_B      &&
              buffc_A->real <= buffc_B->real &&
              buffc_A->imag <= buffc_B->imag &&
              buffz_A->real <= buffz_B->real &&
              buffz_A->imag <= buffz_B->imag ) )
      {
        return FALSE;
      }
 
      break;
    }
 
    case FLA_INT:
    {
      int *buff_A = ( int * ) FLA_INT_PTR( A );
      int *buff_B = ( int * ) FLA_INT_PTR( B );
 
      if ( !( *buff_A <= *buff_B ) ) return FALSE;
 
      break;
    }
 
    case FLA_FLOAT:
    {
      float *buff_A = ( float * ) FLA_FLOAT_PTR( A );
      float *buff_B = ( float * ) FLA_FLOAT_PTR( B );
 
      if ( !( *buff_A <= *buff_B ) ) return FALSE;
 
      break;
    }
 
    case FLA_DOUBLE:
    {
      double *buff_A = ( double * ) FLA_DOUBLE_PTR( A );
      double *buff_B = ( double * ) FLA_DOUBLE_PTR( B );
 
      if ( !( *buff_A <= *buff_B ) ) return FALSE;
 
      break;
    }
 
  }
 
  return TRUE;
}

References FLA_Check_error_level(), FLA_Obj_datatype(), FLA_Obj_le_check(), scomplex::imag, dcomplex::imag, scomplex::real, and dcomplex::real.

Referenced by FLA_QR_UT_piv_unb_var1().

◆ FLA_Obj_le_check()

FLA_Bool FLA_Obj_le_check	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_comparable_object( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_consistent_object_datatype( A, B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( B );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_comparable_object(), FLA_Check_consistent_object_datatype(), and FLA_Check_if_scalar().

Referenced by FLA_Obj_le().

◆ FLA_Obj_length()

dim_t FLA_Obj_length ( FLA_Obj obj )

{
  return obj.m;
}

References FLA_Obj_view::m.

◆ FLA_Obj_lt()

FLA_Bool FLA_Obj_lt	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Datatype datatype_A;
  FLA_Datatype datatype_B;
  FLA_Datatype datatype;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_lt_check( A, B );
 
  datatype_A = FLA_Obj_datatype( A );
  datatype_B = FLA_Obj_datatype( B );
 
  if ( datatype_A != FLA_CONSTANT ) datatype = datatype_A;
  else                              datatype = datatype_B;
 
  switch ( datatype )
  {
    case FLA_CONSTANT:
    {
      // We require ALL floating-point fields to be the same.
      float*    buffs_A = ( float    * ) FLA_FLOAT_PTR( A );
      float*    buffs_B = ( float    * ) FLA_FLOAT_PTR( B );
      double*   buffd_A = ( double   * ) FLA_DOUBLE_PTR( A );
      double*   buffd_B = ( double   * ) FLA_DOUBLE_PTR( B );
      scomplex* buffc_A = ( scomplex * ) FLA_COMPLEX_PTR( A );
      scomplex* buffc_B = ( scomplex * ) FLA_COMPLEX_PTR( B );
      dcomplex* buffz_A = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
      dcomplex* buffz_B = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( B );
 
      if ( !( *buffs_A      < *buffs_B      &&
              *buffd_A      < *buffd_B      &&
              buffc_A->real < buffc_B->real &&
              buffc_A->imag < buffc_B->imag &&
              buffz_A->real < buffz_B->real &&
              buffz_A->imag < buffz_B->imag ) )
      {
        return FALSE;
      }
 
      break;
    }
 
    case FLA_INT:
    {
      int *buff_A = ( int * ) FLA_INT_PTR( A );
      int *buff_B = ( int * ) FLA_INT_PTR( B );
 
      if ( !( *buff_A < *buff_B ) ) return FALSE;
 
      break;
    }
 
    case FLA_FLOAT:
    {
      float *buff_A = ( float * ) FLA_FLOAT_PTR( A );
      float *buff_B = ( float * ) FLA_FLOAT_PTR( B );
 
      if ( !( *buff_A < *buff_B ) ) return FALSE;
 
      break;
    }
 
    case FLA_DOUBLE:
    {
      double *buff_A = ( double * ) FLA_DOUBLE_PTR( A );
      double *buff_B = ( double * ) FLA_DOUBLE_PTR( B );
 
      if ( !( *buff_A < *buff_B ) ) return FALSE;
 
      break;
    }
 
  }
 
  return TRUE;
}

References FLA_Check_error_level(), FLA_Obj_datatype(), FLA_Obj_lt_check(), scomplex::imag, dcomplex::imag, scomplex::real, and dcomplex::real.

Referenced by FLA_Hevd_compute_scaling(), FLA_QR_UT_piv_unb_var2(), FLA_Svd_compute_scaling(), and FLA_Svd_ext_u_unb_var1().

◆ FLA_Obj_lt_check()

FLA_Bool FLA_Obj_lt_check	(	FLA_Obj	A,
		FLA_Obj	B
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_comparable_object( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_consistent_object_datatype( A, B );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( B );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_comparable_object(), FLA_Check_consistent_object_datatype(), and FLA_Check_if_scalar().

Referenced by FLA_Obj_lt().

◆ FLA_Obj_max_dim()

dim_t FLA_Obj_max_dim ( FLA_Obj obj )

{
  return max( obj.m, obj.n );
}

References FLA_Obj_view::m, and FLA_Obj_view::n.

Referenced by FLA_Apply_Q_UT_create_workspace(), FLA_Apply_Q_UT_create_workspace_side(), FLA_Bidiag_blk_external(), and FLA_Bidiag_unb_external().

◆ FLA_Obj_min_dim()

dim_t FLA_Obj_min_dim ( FLA_Obj obj )

{
  return min( obj.m, obj.n );
}

References FLA_Obj_view::m, and FLA_Obj_view::n.

◆ FLA_Obj_nullify()

FLA_Error FLA_Obj_nullify ( FLA_Obj * obj )

{
  // Nullify the fields in the view object.
  obj->m       = 0;
  obj->n       = 0;
  obj->offm    = 0;
  obj->offn    = 0;
  obj->m_inner = 0;
  obj->n_inner = 0;
  obj->base    = NULL;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Obj_view::m, FLA_Obj_view::m_inner, FLA_Obj_view::n, FLA_Obj_view::n_inner, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Obj_num_elem_alloc()

dim_t FLA_Obj_num_elem_alloc ( FLA_Obj obj )

{
  return (obj.base)->n_elem_alloc;
}

References FLA_Obj_view::base.

Referenced by FLASH_Obj_free_hierarchy().

◆ FLA_Obj_row_offset()

dim_t FLA_Obj_row_offset ( FLA_Obj obj )

{
    return obj.offm;
}

References FLA_Obj_view::offm.

Referenced by FLASH_Obj_adjust_views_hierarchy(), FLASH_Obj_scalar_row_offset(), and FLASH_Obj_show_hierarchy().

◆ FLA_Obj_row_stride()

dim_t FLA_Obj_row_stride ( FLA_Obj obj )

{
  return (obj.base)->rs;
}

References FLA_Obj_view::base.

Referenced by FLA_Accum_T_UT_fc_opt_var1(), FLA_Accum_T_UT_fr_opt_var1(), FLA_Add_to_diag(), FLA_Apply_diag_matrix(), FLA_Apply_G_lf_blk_var3(), FLA_Apply_G_lf_opt_var1(), FLA_Apply_G_rf_asm_var1(), FLA_Apply_G_rf_asm_var2(), FLA_Apply_G_rf_asm_var3(), FLA_Apply_G_rf_asm_var3b(), FLA_Apply_G_rf_asm_var6(), FLA_Apply_G_rf_asm_var6b(), FLA_Apply_G_rf_asm_var9(), FLA_Apply_G_rf_asm_var9b(), FLA_Apply_G_rf_blk_var1(), FLA_Apply_G_rf_blk_var2(), FLA_Apply_G_rf_blk_var3(), FLA_Apply_G_rf_blk_var3b(), FLA_Apply_G_rf_blk_var6(), FLA_Apply_G_rf_blk_var6b(), FLA_Apply_G_rf_blk_var9(), FLA_Apply_G_rf_blk_var9b(), FLA_Apply_G_rf_opt_var1(), FLA_Apply_G_rf_opt_var2(), FLA_Apply_G_rf_opt_var3(), FLA_Apply_G_rf_opt_var6(), FLA_Apply_G_rf_opt_var9(), FLA_Apply_H2_UT_l_opt_var1(), FLA_Apply_H2_UT_r_opt_var1(), FLA_Apply_HUD_UT_l_opt_var1(), FLA_Apply_pivots_ln_opt_var1(), FLA_Apply_pivots_lt_opt_var1(), FLA_Apply_pivots_rn_opt_var1(), FLA_Apply_pivots_rt_opt_var1(), FLA_Axpy_external(), FLA_Axpyrt_external(), FLA_Axpys_external(), FLA_Axpyt_external(), FLA_Bidiag_UT(), FLA_Bidiag_UT_create_T(), FLA_Bidiag_UT_l_extract_diagonals(), FLA_Bidiag_UT_l_extract_real_diagonals(), FLA_Bidiag_UT_l_realify_opt(), FLA_Bidiag_UT_l_scale_diagonals(), FLA_Bidiag_UT_u_extract_diagonals(), FLA_Bidiag_UT_u_extract_real_diagonals(), FLA_Bidiag_UT_u_realify_opt(), FLA_Bidiag_UT_u_scale_diagonals(), FLA_Bidiag_UT_u_step_ofu_var2(), FLA_Bidiag_UT_u_step_ofu_var3(), FLA_Bidiag_UT_u_step_ofu_var4(), FLA_Bidiag_UT_u_step_opt_var1(), FLA_Bidiag_UT_u_step_opt_var2(), FLA_Bidiag_UT_u_step_opt_var3(), FLA_Bidiag_UT_u_step_opt_var4(), FLA_Bidiag_UT_u_step_opt_var5(), FLA_Bsvd_ext_opt_var1(), FLA_Bsvd_sinval_v_opt_var1(), FLA_Bsvd_v_opt_var1(), FLA_Bsvd_v_opt_var2(), FLA_CAQR2_UT_opt_var1(), FLA_CAQR_UT_inc_init_structure(), FLA_Check_col_storage(), FLA_Chol_l_opt_var1(), FLA_Chol_l_opt_var2(), FLA_Chol_l_opt_var3(), FLA_Chol_u_opt_var1(), FLA_Chol_u_opt_var2(), FLA_Chol_u_opt_var3(), FLA_Conjugate(), FLA_Conjugate_r(), FLA_Copy_external(), FLA_Copyr_external(), FLA_Copyrt_external(), FLA_Copyt_external(), FLA_Eig_gest_il_opt_var1(), FLA_Eig_gest_il_opt_var2(), FLA_Eig_gest_il_opt_var3(), FLA_Eig_gest_il_opt_var4(), FLA_Eig_gest_il_opt_var5(), FLA_Eig_gest_iu_opt_var1(), FLA_Eig_gest_iu_opt_var2(), FLA_Eig_gest_iu_opt_var3(), FLA_Eig_gest_iu_opt_var4(), FLA_Eig_gest_iu_opt_var5(), FLA_Eig_gest_nl_opt_var1(), FLA_Eig_gest_nl_opt_var2(), FLA_Eig_gest_nl_opt_var4(), FLA_Eig_gest_nl_opt_var5(), FLA_Eig_gest_nu_opt_var1(), FLA_Eig_gest_nu_opt_var2(), FLA_Eig_gest_nu_opt_var4(), FLA_Eig_gest_nu_opt_var5(), FLA_Fused_Ahx_Ax_opt_var1(), FLA_Fused_Ahx_Axpy_Ax_opt_var1(), FLA_Fused_Gerc2_Ahx_Ax_opt_var1(), FLA_Fused_Gerc2_Ahx_Axpy_Ax_opt_var1(), FLA_Fused_Gerc2_opt_var1(), FLA_Fused_Her2_Ax_l_opt_var1(), FLA_Fused_Uhu_Yhu_Zhu_opt_var1(), FLA_Fused_UYx_ZVx_opt_var1(), FLA_Fused_UZhu_ZUhu_opt_var1(), FLA_Gemm_external(), FLA_Gemv_external(), FLA_Gemvc_external(), FLA_Ger_external(), FLA_Gerc_external(), FLA_Hemm_external(), FLA_Hemv_external(), FLA_Hemvc_external(), FLA_Her2_external(), FLA_Her2c_external(), FLA_Her2k_external(), FLA_Her_external(), FLA_Herc_external(), FLA_Herk_external(), FLA_Hermitianize(), FLA_Hess_UT_create_T(), FLA_Hess_UT_step_ofu_var2(), FLA_Hess_UT_step_ofu_var3(), FLA_Hess_UT_step_ofu_var4(), FLA_Hess_UT_step_opt_var1(), FLA_Hess_UT_step_opt_var2(), FLA_Hess_UT_step_opt_var3(), FLA_Hess_UT_step_opt_var4(), FLA_Hess_UT_step_opt_var5(), FLA_Hevd_lv_unb_var1(), FLA_Inv_scal_elemwise(), FLA_Inv_scal_external(), FLA_Inv_scalc_external(), FLA_LQ_UT_create_T(), FLA_LQ_UT_opt_var1(), FLA_LQ_UT_opt_var2(), FLA_LU_nopiv_opt_var1(), FLA_LU_nopiv_opt_var2(), FLA_LU_nopiv_opt_var3(), FLA_LU_nopiv_opt_var4(), FLA_LU_nopiv_opt_var5(), FLA_LU_piv_opt_var3(), FLA_LU_piv_opt_var4(), FLA_LU_piv_opt_var5(), FLA_Lyap_h_opt_var1(), FLA_Lyap_h_opt_var2(), FLA_Lyap_h_opt_var3(), FLA_Lyap_h_opt_var4(), FLA_Lyap_n_opt_var1(), FLA_Lyap_n_opt_var2(), FLA_Lyap_n_opt_var3(), FLA_Lyap_n_opt_var4(), FLA_Max_abs_value(), FLA_Max_abs_value_herm(), FLA_Max_elemwise_diff(), FLA_Norm_frob(), FLA_Obj_buffer_at_view(), FLA_Obj_create_conf_to(), FLA_Obj_equals(), FLA_Obj_fshow(), FLA_Obj_has_nan(), FLA_Obj_is_col_major(), FLA_Obj_set_imag_part(), FLA_Obj_set_real_part(), FLA_QR2_UT_opt_var1(), FLA_QR_UT_create_T(), FLA_QR_UT_form_Q_opt_var1(), FLA_QR_UT_opt_var1(), FLA_QR_UT_opt_var2(), FLA_Random_matrix(), FLA_Random_tri_matrix(), FLA_SA_LU_unb(), FLA_Scal_elemwise(), FLA_Scal_external(), FLA_Scalc_external(), FLA_Scale_diag(), FLA_Scalr_external(), FLA_Set(), FLA_Set_diag(), FLA_Set_diagonal_matrix(), FLA_Set_diagonal_vector(), FLA_Set_offdiag(), FLA_Setr(), FLA_Shift_diag(), FLA_Sort_evd(), FLA_Sort_svd(), FLA_Swap_external(), FLA_Swapt_external(), FLA_Sylv_hh_opt_var1(), FLA_Sylv_hn_opt_var1(), FLA_Sylv_nh_opt_var1(), FLA_Sylv_nn_opt_var1(), FLA_Symm_external(), FLA_Symmetrize(), FLA_Symv_external(), FLA_Syr2_external(), FLA_Syr2k_external(), FLA_Syr_external(), FLA_Syrk_external(), FLA_Tevd_eigval_v_opt_var1(), FLA_Tevd_n_opt_var1(), FLA_Tevd_v_opt_var1(), FLA_Tevd_v_opt_var2(), FLA_Triangularize(), FLA_Tridiag_UT(), FLA_Tridiag_UT_create_T(), FLA_Tridiag_UT_l_realify_opt(), FLA_Tridiag_UT_l_step_ofu_var2(), FLA_Tridiag_UT_l_step_ofu_var3(), FLA_Tridiag_UT_l_step_opt_var1(), FLA_Tridiag_UT_l_step_opt_var2(), FLA_Tridiag_UT_l_step_opt_var3(), FLA_Tridiag_UT_shift_U(), FLA_Tridiag_UT_u_realify_opt(), FLA_Trinv_ln_opt_var1(), FLA_Trinv_ln_opt_var2(), FLA_Trinv_ln_opt_var3(), FLA_Trinv_ln_opt_var4(), FLA_Trinv_lu_opt_var1(), FLA_Trinv_lu_opt_var2(), FLA_Trinv_lu_opt_var3(), FLA_Trinv_lu_opt_var4(), FLA_Trinv_un_opt_var1(), FLA_Trinv_un_opt_var2(), FLA_Trinv_un_opt_var3(), FLA_Trinv_un_opt_var4(), FLA_Trinv_uu_opt_var1(), FLA_Trinv_uu_opt_var2(), FLA_Trinv_uu_opt_var3(), FLA_Trinv_uu_opt_var4(), FLA_Trmm_external(), FLA_Trmmsx_external(), FLA_Trmv_external(), FLA_Trsm_external(), FLA_Trsmsx_external(), FLA_Trsv_external(), FLA_Ttmm_l_opt_var1(), FLA_Ttmm_l_opt_var2(), FLA_Ttmm_l_opt_var3(), FLA_Ttmm_u_opt_var1(), FLA_Ttmm_u_opt_var2(), FLA_Ttmm_u_opt_var3(), FLA_UDdate_UT_create_T(), FLA_UDdate_UT_opt_var1(), FLASH_Obj_attach_buffer_hierarchy(), FLASH_Obj_base_scalar_length(), FLASH_Obj_base_scalar_width(), FLASH_Obj_show_hierarchy(), FLASH_print_struct(), and FLASH_print_struct_helper().

◆ FLA_Obj_set_imag_part()

void FLA_Obj_set_imag_part	(	FLA_Obj	alpha,
		FLA_Obj	beta
	)

{
  dim_t m_B;
  dim_t n_B;
  dim_t rs_B;
  dim_t cs_B;
  dim_t i, j;
 
  m_B  = FLA_Obj_length( B );
  n_B  = FLA_Obj_width( B );
  rs_B = FLA_Obj_row_stride( B );
  cs_B = FLA_Obj_col_stride( B );
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_set_imag_part_check( alpha, B );
 
  if ( FLA_Obj_is_complex( B ) )
  {
    if      ( FLA_Obj_datatype( B ) == FLA_COMPLEX )
    {
      float*    buff_alpha = FLA_FLOAT_PTR( alpha );
      scomplex* buff_B     = FLA_COMPLEX_PTR( B );
 
      for ( j = 0; j < n_B; ++j )
      {
        for ( i = 0; i < m_B; ++i )
        {
          scomplex* beta11 = buff_B + rs_B * i + cs_B * j;
 
          beta11->imag = *buff_alpha;
        }
      }
    }
    else if ( FLA_Obj_datatype( B ) == FLA_DOUBLE_COMPLEX )
    {
      double*   buff_alpha = FLA_DOUBLE_PTR( alpha );
      dcomplex* buff_B     = FLA_DOUBLE_COMPLEX_PTR( B );
 
      for ( j = 0; j < n_B; ++j )
      {
        for ( i = 0; i < m_B; ++i )
        {
          dcomplex* beta11 = buff_B + rs_B * i + cs_B * j;
 
          beta11->imag = *buff_alpha;
        }
      }
    }
  }
}

References FLA_Check_error_level(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_is_complex(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_set_imag_part_check(), FLA_Obj_width(), i, scomplex::imag, and dcomplex::imag.

Referenced by FLA_Bidiag_UT_l_realify_unb(), and FLA_Bidiag_UT_u_realify_unb().

◆ FLA_Obj_set_imag_part_check()

FLA_Error FLA_Obj_set_imag_part_check	(	FLA_Obj	alpha,
		FLA_Obj	beta
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_real_object( alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_floating_object( beta );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( beta );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_identical_object_precision( alpha, beta );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( alpha );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_floating_object(), FLA_Check_identical_object_precision(), FLA_Check_if_scalar(), FLA_Check_nonconstant_object(), and FLA_Check_real_object().

Referenced by FLA_Obj_set_imag_part().

◆ FLA_Obj_set_real_part()

void FLA_Obj_set_real_part	(	FLA_Obj	alpha,
		FLA_Obj	beta
	)

{
  dim_t m_B;
  dim_t n_B;
  dim_t rs_B;
  dim_t cs_B;
  dim_t i, j;
 
  m_B  = FLA_Obj_length( B );
  n_B  = FLA_Obj_width( B );
  rs_B = FLA_Obj_row_stride( B );
  cs_B = FLA_Obj_col_stride( B );
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_set_real_part_check( alpha, B );
 
  if ( FLA_Obj_is_complex( B ) )
  {
    if      ( FLA_Obj_datatype( B ) == FLA_COMPLEX )
    {
      float*    buff_alpha = FLA_FLOAT_PTR( alpha );
      scomplex* buff_B     = FLA_COMPLEX_PTR( B );
 
      for ( j = 0; j < n_B; ++j )
      {
        for ( i = 0; i < m_B; ++i )
        {
          scomplex* beta11 = buff_B + rs_B * i + cs_B * j;
 
          beta11->real = *buff_alpha;
        }
      }
    }
    else if ( FLA_Obj_datatype( B ) == FLA_DOUBLE_COMPLEX )
    {
      double*   buff_alpha = FLA_DOUBLE_PTR( alpha );
      dcomplex* buff_B     = FLA_DOUBLE_COMPLEX_PTR( B );
 
      for ( j = 0; j < n_B; ++j )
      {
        for ( i = 0; i < m_B; ++i )
        {
          dcomplex* beta11 = buff_B + rs_B * i + cs_B * j;
 
          beta11->real = *buff_alpha;
        }
      }
    }
  }
}

References FLA_Check_error_level(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_is_complex(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_set_real_part_check(), FLA_Obj_width(), i, scomplex::real, and dcomplex::real.

◆ FLA_Obj_set_real_part_check()

FLA_Error FLA_Obj_set_real_part_check	(	FLA_Obj	alpha,
		FLA_Obj	beta
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_real_object( alpha );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_floating_object( beta );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_nonconstant_object( beta );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_identical_object_precision( alpha, beta );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_if_scalar( alpha );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_floating_object(), FLA_Check_identical_object_precision(), FLA_Check_if_scalar(), FLA_Check_nonconstant_object(), and FLA_Check_real_object().

Referenced by FLA_Obj_set_real_part().

◆ FLA_Obj_show()

FLA_Error FLA_Obj_show	(	char *	s1,
		FLA_Obj	A,
		char *	format,
		char *	s2
	)

{
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Obj_show_check( s1, A, format, s2 );
 
  return FLA_Obj_fshow( stdout, s1, A, format, s2 );
}

References FLA_Check_error_level(), FLA_Obj_fshow(), and FLA_Obj_show_check().

Referenced by FLASH_Obj_show().

◆ FLA_Obj_show_check()

FLA_Error FLA_Obj_show_check	(	char *	s1,
		FLA_Obj	obj,
		char *	format,
		char *	s2
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_null_pointer( s1 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_object_scalar_elemtype( obj );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( obj );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( format );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( s2 );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), FLA_Check_object_scalar_elemtype(), and FLA_Check_valid_object_datatype().

Referenced by FLA_Obj_show().

◆ FLA_Obj_structure()

FLA_Uplo FLA_Obj_structure ( FLA_Obj obj )

{
  return obj.base->uplo;
}

References FLA_Obj_view::base, and FLA_Obj_struct::uplo.

Referenced by FLA_Apply_CAQ2_UT_internal(), and FLA_CAQR2_UT_internal().

◆ FLA_Obj_vector_dim()

dim_t FLA_Obj_vector_dim ( FLA_Obj obj )

{
  return ( obj.m == 1 ? obj.n
                      : obj.m );
}

References FLA_Obj_view::m, and FLA_Obj_view::n.

Referenced by FLA_Accum_T_UT_fc_opt_var1(), FLA_Accum_T_UT_fr_opt_var1(), FLA_Amax_external(), FLA_Apply_diag_matrix_check(), FLA_Apply_H2_UT_check(), FLA_Apply_pivots_ln_opt_var1(), FLA_Apply_pivots_lt_opt_var1(), FLA_Apply_pivots_rn_opt_var1(), FLA_Apply_pivots_rt_opt_var1(), FLA_Apply_pivots_unb_external(), FLA_Apply_Q_blk_external(), FLA_Asum_external(), FLA_Bidiag_apply_U_external(), FLA_Bidiag_apply_V_external(), FLA_Bidiag_form_U_external(), FLA_Bidiag_form_V_external(), FLA_Bidiag_UT_realify_diagonals_check(), FLA_Bidiag_UT_realify_diagonals_opt(), FLA_Bidiag_UT_recover_tau_check(), FLA_Bsvd(), FLA_Bsvd_check(), FLA_Bsvd_compute_shift(), FLA_Bsvd_compute_tol_thresh(), FLA_Bsvd_create_workspace(), FLA_Bsvd_ext(), FLA_Bsvd_ext_opt_var1(), FLA_Bsvd_external(), FLA_Bsvd_find_converged(), FLA_Bsvd_find_max(), FLA_Bsvd_francis_v_opt_var1(), FLA_Bsvd_sinval_v_opt_var1(), FLA_Bsvdd_external(), FLA_Check_equal_vector_dims(), FLA_Check_matrix_vector_dims(), FLA_Check_vector_dim(), FLA_Check_vector_dim_min(), FLA_Dot2cs_external(), FLA_Dot2s_external(), FLA_Dot_external(), FLA_Dotc_external(), FLA_Dotcs_external(), FLA_Dots_external(), FLA_Fill_with_cluster_dist(), FLA_Fill_with_geometric_dist(), FLA_Fill_with_inverse_dist(), FLA_Fill_with_linear_dist(), FLA_Fill_with_logarithmic_dist(), FLA_Fill_with_random_dist(), FLA_Hess_UT_recover_tau_check(), FLA_Househ2_UT(), FLA_Househ2s_UT(), FLA_Househ3UD_UT(), FLA_Invert(), FLA_Norm1_tridiag(), FLA_Nrm2_external(), FLA_Obj_extract_imag_part(), FLA_Obj_extract_imag_part_check(), FLA_Obj_extract_real_part(), FLA_Obj_extract_real_part_check(), FLA_QR_form_Q_external(), FLA_Sort(), FLA_Sort_bsvd_ext(), FLA_Sort_evd_check(), FLA_Tevd_eigval_n_opt_var1(), FLA_Tevd_eigval_v_opt_var1(), FLA_Tevd_external(), FLA_Tevd_francis_n_opt_var1(), FLA_Tevd_francis_v_opt_var1(), FLA_Tevd_n_opt_var1(), FLA_Tevd_v_opt_var1(), FLA_Tevd_v_opt_var2(), FLA_Tridiag_apply_Q_external(), FLA_Tridiag_UT_realify_check(), FLA_Tridiag_UT_realify_subdiagonal_check(), FLA_Tridiag_UT_realify_subdiagonal_opt(), and FLA_Tridiag_UT_recover_tau_check().

◆ FLA_Obj_vector_inc()

dim_t FLA_Obj_vector_inc ( FLA_Obj obj )

{
  return ( obj.m == 1 ? (obj.base)->cs
                      : (obj.base)->rs );
}

References FLA_Obj_view::base, and FLA_Obj_view::m.

◆ FLA_Obj_width()

dim_t FLA_Obj_width ( FLA_Obj obj )

{
  return obj.n;
}

References FLA_Obj_view::n.

◆ FLA_Param_map_blis_to_flame_diag()

void FLA_Param_map_blis_to_flame_diag	(	diag1_t	diag,
		FLA_Diag *	flame_diag
	)

{
    if      ( bl1_is_nonunit_diag( diag ) )
        *flame_diag = FLA_NONUNIT_DIAG;
    else if ( bl1_is_unit_diag( diag ) )
        *flame_diag = FLA_UNIT_DIAG;
    else if ( bl1_is_zero_diag( diag ) )
        *flame_diag = FLA_ZERO_DIAG;
    else
        FLA_Check_error_code( FLA_INVALID_DIAG );
}

References bl1_is_nonunit_diag(), bl1_is_unit_diag(), and bl1_is_zero_diag().

◆ FLA_Param_map_blis_to_flame_side()

void FLA_Param_map_blis_to_flame_side	(	side1_t	side,
		FLA_Side *	flame_side
	)

{
    if      ( bl1_is_left( side ) )
        *flame_side = FLA_LEFT;
    else if ( bl1_is_right( side ) )
        *flame_side = FLA_RIGHT;
    else
        FLA_Check_error_code( FLA_INVALID_SIDE );
}

References bl1_is_left(), and bl1_is_right().

◆ FLA_Param_map_blis_to_flame_trans()

void FLA_Param_map_blis_to_flame_trans	(	trans1_t	trans,
		FLA_Trans *	flame_trans
	)

{
    if      ( bl1_is_notrans( trans ) )
        *flame_trans = FLA_NO_TRANSPOSE;
    else if ( bl1_is_trans( trans ) )
        *flame_trans = FLA_TRANSPOSE;
    else if ( bl1_is_conjnotrans( trans ) )
        *flame_trans = FLA_CONJ_NO_TRANSPOSE;
    else if ( bl1_is_conjtrans( trans ) )
        *flame_trans = FLA_CONJ_TRANSPOSE;
    else
        FLA_Check_error_code( FLA_INVALID_TRANS );
}

References bl1_is_conjnotrans(), bl1_is_conjtrans(), bl1_is_notrans(), and bl1_is_trans().

◆ FLA_Param_map_blis_to_flame_uplo()

void FLA_Param_map_blis_to_flame_uplo	(	uplo1_t	uplo,
		FLA_Uplo *	flame_uplo
	)

{
    if      ( bl1_is_lower( uplo ) )
        *flame_uplo = FLA_LOWER_TRIANGULAR;
    else if ( bl1_is_upper( uplo ) )
        *flame_uplo = FLA_UPPER_TRIANGULAR;
    else
        FLA_Check_error_code( FLA_INVALID_UPLO );
}

References bl1_is_lower(), and bl1_is_upper().

◆ FLA_Param_map_char_to_flame_diag()

void FLA_Param_map_char_to_flame_diag	(	char *	diag,
		FLA_Diag *	flame_diag
	)

{
    if      ( *diag == 'n' || *diag == 'N' )
        *flame_diag = FLA_NONUNIT_DIAG;
    else if ( *diag == 'u' || *diag == 'U' )
        *flame_diag = FLA_UNIT_DIAG;
    else
        FLA_Check_error_code( FLA_INVALID_DIAG );
}

◆ FLA_Param_map_char_to_flame_direct()

void FLA_Param_map_char_to_flame_direct	(	char *	direct,
		FLA_Direct *	flame_direct
	)

{
    if      ( *direct == 'b' || *direct == 'B' )
        *flame_direct = FLA_BACKWARD;
    else if ( *direct == 'f' || *direct == 'F' )
        *flame_direct = FLA_FORWARD;
    else
        FLA_Check_error_code( FLA_INVALID_DIRECT );
}

◆ FLA_Param_map_char_to_flame_inv()

void FLA_Param_map_char_to_flame_inv	(	char *	inv,
		FLA_Inv *	flame_inv
	)

{
    if      ( *inv == 'i' || *inv == 'I' )
        *flame_inv = FLA_INVERSE;
    else if ( *inv == 'n' || *inv == 'N' )
        *flame_inv = FLA_NO_INVERSE;
    else
        FLA_Check_error_code( FLA_INVALID_INVERSE );
}

◆ FLA_Param_map_char_to_flame_side()

void FLA_Param_map_char_to_flame_side	(	char *	side,
		FLA_Side *	flame_side
	)

{
    if      ( *side == 'l' || *side == 'L' )
        *flame_side = FLA_LEFT;
    else if ( *side == 'r' || *side == 'R' )
        *flame_side = FLA_RIGHT;
    else
        FLA_Check_error_code( FLA_INVALID_SIDE );
}

◆ FLA_Param_map_char_to_flame_storev()

void FLA_Param_map_char_to_flame_storev	(	char *	storev,
		FLA_Direct *	flame_storev
	)

{
    if      ( *storev == 'c' || *storev == 'C' )
        *flame_storev = FLA_COLUMNWISE;
    else if ( *storev == 'r' || *storev == 'R' )
        *flame_storev = FLA_ROWWISE;
    else
        FLA_Check_error_code( FLA_INVALID_STOREV );
}

◆ FLA_Param_map_char_to_flame_trans()

void FLA_Param_map_char_to_flame_trans	(	char *	trans,
		FLA_Trans *	flame_trans
	)

{
    if      ( *trans == 'n' || *trans == 'N' )
        *flame_trans = FLA_NO_TRANSPOSE;
    else if ( *trans == 't' || *trans == 'T' )
        *flame_trans = FLA_TRANSPOSE;
    else if ( *trans == 'c' || *trans == 'C' )
        *flame_trans = FLA_CONJ_NO_TRANSPOSE;
    else if ( *trans == 'h' || *trans == 'H' )
        *flame_trans = FLA_CONJ_TRANSPOSE;
    else
        FLA_Check_error_code( FLA_INVALID_TRANS );
}

◆ FLA_Param_map_char_to_flame_uplo()

void FLA_Param_map_char_to_flame_uplo	(	char *	uplo,
		FLA_Uplo *	flame_uplo
	)

{
    if      ( *uplo == 'l' || *uplo == 'L' )
        *flame_uplo = FLA_LOWER_TRIANGULAR;
    else if ( *uplo == 'u' || *uplo == 'U' )
        *flame_uplo = FLA_UPPER_TRIANGULAR;
    else
        FLA_Check_error_code( FLA_INVALID_UPLO );
}

◆ FLA_Param_map_flame_to_blis_conj()

void FLA_Param_map_flame_to_blis_conj	(	FLA_Conj	conj,
		conj1_t *	blis_conj
	)

{
    if ( conj == FLA_NO_CONJUGATE )
    {
        *blis_conj = BLIS1_NO_CONJUGATE;
    }
    else if ( conj == FLA_CONJUGATE )
    {
        *blis_conj = BLIS1_CONJUGATE;
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_CONJ );
    }
}

References BLIS1_CONJUGATE, and BLIS1_NO_CONJUGATE.

Referenced by FLA_Apply_diag_matrix(), FLA_Dot2cs_external(), FLA_Dot2s_external(), FLA_Dot_external(), FLA_Dotc_external(), FLA_Dotcs_external(), FLA_Dots_external(), FLA_Gemv_external(), FLA_Gemvc_external(), FLA_Ger_external(), FLA_Gerc_external(), FLA_Hemv_external(), FLA_Hemvc_external(), FLA_Her2_external(), FLA_Her2c_external(), FLA_Her_external(), FLA_Herc_external(), FLA_Hermitianize(), FLA_Inv_scal_external(), FLA_Inv_scalc_external(), FLA_Invert(), FLA_Scal_external(), FLA_Scalc_external(), FLA_Scale_diag(), FLA_Shift_diag(), and FLA_Symmetrize().

◆ FLA_Param_map_flame_to_blis_diag()

void FLA_Param_map_flame_to_blis_diag	(	FLA_Diag	diag,
		diag1_t *	blis_diag
	)

{
    if ( diag == FLA_NONUNIT_DIAG )
    {
        *blis_diag = BLIS1_NONUNIT_DIAG;
    }
    else if ( diag == FLA_UNIT_DIAG )
    {
        *blis_diag = BLIS1_UNIT_DIAG;
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_DIAG );
    }
}

References BLIS1_NONUNIT_DIAG, and BLIS1_UNIT_DIAG.

Referenced by FLA_Random_tri_matrix(), FLA_Trmm_external(), FLA_Trmmsx_external(), FLA_Trmv_external(), FLA_Trsm_external(), FLA_Trsmsx_external(), and FLA_Trsv_external().

◆ FLA_Param_map_flame_to_blis_side()

void FLA_Param_map_flame_to_blis_side	(	FLA_Uplo	side,
		side1_t *	blis_side
	)

{
    if ( side == FLA_LEFT )
    {
        *blis_side = BLIS1_LEFT;
    }
    else if ( side == FLA_RIGHT )
    {
        *blis_side = BLIS1_RIGHT;
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_SIDE );
    }
}

References BLIS1_LEFT, and BLIS1_RIGHT.

Referenced by FLA_Apply_diag_matrix(), FLA_Hemm_external(), FLA_Symm_external(), FLA_Trmm_external(), FLA_Trmmsx_external(), FLA_Trsm_external(), and FLA_Trsmsx_external().

◆ FLA_Param_map_flame_to_blis_trans()

void FLA_Param_map_flame_to_blis_trans	(	FLA_Trans	trans,
		trans1_t *	blis_trans
	)

{
    if ( trans == FLA_NO_TRANSPOSE )
    {
        *blis_trans = BLIS1_NO_TRANSPOSE;
    }
    else if ( trans == FLA_TRANSPOSE )
    {
        *blis_trans = BLIS1_TRANSPOSE;
    }
    else if ( trans == FLA_CONJ_NO_TRANSPOSE )
    {
        *blis_trans = BLIS1_CONJ_NO_TRANSPOSE;
    }
    else if ( trans == FLA_CONJ_TRANSPOSE )
    {
        *blis_trans = BLIS1_CONJ_TRANSPOSE;
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_TRANS );
    }
}

References BLIS1_CONJ_NO_TRANSPOSE, BLIS1_CONJ_TRANSPOSE, BLIS1_NO_TRANSPOSE, and BLIS1_TRANSPOSE.

Referenced by FLA_Axpy_external(), FLA_Axpyrt_external(), FLA_Axpys_external(), FLA_Axpyt_external(), FLA_Copy_external(), FLA_Copyrt_external(), FLA_Copyt_external(), FLA_Gemm_external(), FLA_Gemv_external(), FLA_Gemvc_external(), FLA_Her2k_external(), FLA_Herk_external(), FLA_Inv_scal_elemwise(), FLA_Scal_elemwise(), FLA_Swap_external(), FLA_Swapt_external(), FLA_Syr2k_external(), FLA_Syrk_external(), FLA_Trmm_external(), FLA_Trmmsx_external(), FLA_Trmv_external(), FLA_Trsm_external(), FLA_Trsmsx_external(), and FLA_Trsv_external().

◆ FLA_Param_map_flame_to_blis_uplo()

void FLA_Param_map_flame_to_blis_uplo	(	FLA_Uplo	uplo,
		uplo1_t *	blis_uplo
	)

{
    if ( uplo == FLA_LOWER_TRIANGULAR )
    {
        *blis_uplo = BLIS1_LOWER_TRIANGULAR;
    }
    else if ( uplo == FLA_UPPER_TRIANGULAR )
    {
        *blis_uplo = BLIS1_UPPER_TRIANGULAR;
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_UPLO );
    }
}

References BLIS1_LOWER_TRIANGULAR, and BLIS1_UPPER_TRIANGULAR.

Referenced by FLA_Axpyrt_external(), FLA_Conjugate_r(), FLA_Copyr_external(), FLA_Copyrt_external(), FLA_Hemm_external(), FLA_Hemv_external(), FLA_Hemvc_external(), FLA_Her2_external(), FLA_Her2c_external(), FLA_Her2k_external(), FLA_Her_external(), FLA_Herc_external(), FLA_Herk_external(), FLA_Hermitianize(), FLA_Max_abs_value_herm(), FLA_Random_tri_matrix(), FLA_Scalr_external(), FLA_Setr(), FLA_Symm_external(), FLA_Symmetrize(), FLA_Symv_external(), FLA_Syr2_external(), FLA_Syr2k_external(), FLA_Syr_external(), FLA_Syrk_external(), FLA_Triangularize(), FLA_Trmm_external(), FLA_Trmmsx_external(), FLA_Trmv_external(), FLA_Trsm_external(), FLA_Trsmsx_external(), and FLA_Trsv_external().

◆ FLA_Param_map_flame_to_netlib_diag()

void FLA_Param_map_flame_to_netlib_diag	(	FLA_Diag	diag,
		void *	blas_diag
	)

{
    if ( diag == FLA_NONUNIT_DIAG )
    {
#ifdef FLA_ENABLE_CBLAS_INTERFACES
        *( ( enum CBLAS_DIAG* ) blas_diag ) = CblasNonUnit;
#else
        *( ( char*            ) blas_diag ) = 'N';
#endif
    }
    else if ( diag == FLA_UNIT_DIAG )
    {
#ifdef FLA_ENABLE_CBLAS_INTERFACES
        *( ( enum CBLAS_DIAG* ) blas_diag ) = CblasUnit;
#else
        *( ( char*            ) blas_diag ) = 'U';
#endif
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_DIAG );
    }
}

References CblasNonUnit, and CblasUnit.

Referenced by FLA_Trinv_blk_external(), FLA_Trinv_unb_external(), FLA_Trmm_external_gpu(), FLA_Trsm_external_gpu(), and FLA_Trsv_external_gpu().

◆ FLA_Param_map_flame_to_netlib_direct()

void FLA_Param_map_flame_to_netlib_direct	(	FLA_Direct	direct,
		void *	lapack_direct
	)

{
    if ( direct == FLA_FORWARD )
    {
        *( ( char* ) lapack_direct ) = 'F';
    }
    else if ( direct == FLA_BACKWARD )
    {
        *( ( char* ) lapack_direct ) = 'B';
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_DIRECT );
    }
}

◆ FLA_Param_map_flame_to_netlib_evd_type()

void FLA_Param_map_flame_to_netlib_evd_type	(	FLA_Evd_type	evd_type,
		void *	lapack_evd_type
	)

{
    if ( evd_type == FLA_EVD_WITHOUT_VECTORS )
    {
        *( ( char* ) lapack_evd_type ) = 'N';
    }
    else if ( evd_type == FLA_EVD_WITH_VECTORS )
    {
        *( ( char* ) lapack_evd_type ) = 'V';
    }
    else if ( evd_type == FLA_EVD_OF_TRIDIAG_WITH_VECTORS )
    {
        *( ( char* ) lapack_evd_type ) = 'I';
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_EVD_TYPE );
    }
}

Referenced by FLA_Hevd_external(), FLA_Hevdd_external(), FLA_Hevdr_external(), FLA_Tevd_external(), FLA_Tevdd_external(), and FLA_Tevdr_external().

◆ FLA_Param_map_flame_to_netlib_machval()

void FLA_Param_map_flame_to_netlib_machval	(	FLA_Machval	machval,
		void *	blas_machval
	)

{
    if      ( machval == FLA_MACH_EPS )
    {
        *( ( char* ) blas_machval ) = 'E';
    }
    else if ( machval == FLA_MACH_SFMIN )
    {
        *( ( char* ) blas_machval ) = 'S';
    }
    else if ( machval == FLA_MACH_BASE )
    {
        *( ( char* ) blas_machval ) = 'B';
    }
    else if ( machval == FLA_MACH_PREC )
    {
        *( ( char* ) blas_machval ) = 'P';
    }
    else if ( machval == FLA_MACH_NDIGMANT )
    {
        *( ( char* ) blas_machval ) = 'N';
    }
    else if ( machval == FLA_MACH_RND )
    {
        *( ( char* ) blas_machval ) = 'R';
    }
    else if ( machval == FLA_MACH_EMIN )
    {
        *( ( char* ) blas_machval ) = 'M';
    }
    else if ( machval == FLA_MACH_RMIN )
    {
        *( ( char* ) blas_machval ) = 'U';
    }
    else if ( machval == FLA_MACH_EMAX )
    {
        *( ( char* ) blas_machval ) = 'L';
    }
    else if ( machval == FLA_MACH_RMAX )
    {
        *( ( char* ) blas_machval ) = 'O';
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_MACHVAL );
    }
}

Referenced by FLA_Mach_params_opd(), and FLA_Mach_params_ops().

◆ FLA_Param_map_flame_to_netlib_side()

void FLA_Param_map_flame_to_netlib_side	(	FLA_Uplo	side,
		void *	blas_side
	)

{
    if ( side == FLA_LEFT )
    {
#ifdef FLA_ENABLE_CBLAS_INTERFACES
        *( ( enum CBLAS_SIDE* ) blas_side ) = CblasLeft;
#else
        *( ( char*            ) blas_side ) = 'L';
#endif
    }
    else if ( side == FLA_RIGHT )
    {
#ifdef FLA_ENABLE_CBLAS_INTERFACES
        *( ( enum CBLAS_SIDE* ) blas_side ) = CblasRight;
#else
        *( ( char*            ) blas_side ) = 'R';
#endif
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_SIDE );
    }
}

References CblasLeft, and CblasRight.

Referenced by FLA_Apply_Q_blk_external(), FLA_Bidiag_apply_U_external(), FLA_Bidiag_apply_V_external(), FLA_Hemm_external_gpu(), FLA_Symm_external_gpu(), FLA_Tridiag_apply_Q_external(), FLA_Trmm_external_gpu(), and FLA_Trsm_external_gpu().

◆ FLA_Param_map_flame_to_netlib_storev()

void FLA_Param_map_flame_to_netlib_storev	(	FLA_Store	storev,
		void *	lapack_storev
	)

{
    if ( storev == FLA_COLUMNWISE )
    {
        *( ( char* ) lapack_storev ) = 'C';
    }
    else if ( storev == FLA_ROWWISE )
    {
        *( ( char* ) lapack_storev ) = 'R';
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_STOREV );
    }
}

◆ FLA_Param_map_flame_to_netlib_svd_type()

void FLA_Param_map_flame_to_netlib_svd_type	(	FLA_Svd_type	svd_type,
		void *	lapack_svd_type
	)

{
    if      ( svd_type == FLA_SVD_VECTORS_ALL )
    {
        *( ( char* ) lapack_svd_type ) = 'A';
    }
    else if ( svd_type == FLA_SVD_VECTORS_MIN_COPY )
    {
        *( ( char* ) lapack_svd_type ) = 'S';
    }
    else if ( svd_type == FLA_SVD_VECTORS_MIN_OVERWRITE )
    {
        *( ( char* ) lapack_svd_type ) = 'O';
    }
    else if ( svd_type == FLA_SVD_VECTORS_NONE )
    {
        *( ( char* ) lapack_svd_type ) = 'N';
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_SVD_TYPE );
    }
}

Referenced by FLA_Svd_external(), and FLA_Svdd_external().

◆ FLA_Param_map_flame_to_netlib_trans()

void FLA_Param_map_flame_to_netlib_trans	(	FLA_Trans	trans,
		void *	blas_trans
	)

{
    if ( trans == FLA_NO_TRANSPOSE )
    {
#ifdef FLA_ENABLE_CBLAS_INTERFACES
        *( ( enum CBLAS_TRANSPOSE* ) blas_trans ) = CblasNoTrans;
#else
        *( ( char*                 ) blas_trans ) = 'N';
#endif
    }
    else if ( trans == FLA_TRANSPOSE )
    {
#ifdef FLA_ENABLE_CBLAS_INTERFACES
        *( ( enum CBLAS_TRANSPOSE* ) blas_trans ) = CblasTrans;
#else
        *( ( char*                 ) blas_trans ) = 'T';
#endif
    }
    else if ( trans == FLA_CONJ_TRANSPOSE )
    {
#ifdef FLA_ENABLE_CBLAS_INTERFACES
        *( ( enum CBLAS_TRANSPOSE* ) blas_trans ) = CblasConjTrans;
#else
        *( ( char*                 ) blas_trans ) = 'C';
#endif
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_TRANS );
    }
}

References CblasConjTrans, CblasNoTrans, and CblasTrans.

Referenced by FLA_Apply_Q_blk_external(), FLA_Bidiag_apply_U_external(), FLA_Bidiag_apply_V_external(), FLA_Gemm_external_gpu(), FLA_Gemv_external_gpu(), FLA_Her2k_external_gpu(), FLA_Herk_external_gpu(), FLA_Sylv_unb_external(), FLA_Syr2k_external_gpu(), FLA_Syrk_external_gpu(), FLA_Tridiag_apply_Q_external(), FLA_Trmm_external_gpu(), FLA_Trsm_external_gpu(), and FLA_Trsv_external_gpu().

◆ FLA_Param_map_flame_to_netlib_uplo()

void FLA_Param_map_flame_to_netlib_uplo	(	FLA_Uplo	uplo,
		void *	blas_uplo
	)

{
    if ( uplo == FLA_LOWER_TRIANGULAR )
    {
#ifdef FLA_ENABLE_CBLAS_INTERFACES
        *( ( enum CBLAS_UPLO* ) blas_uplo ) = CblasLower;
#else
        *( ( char*            ) blas_uplo ) = 'L';
#endif
    }
    else if ( uplo == FLA_UPPER_TRIANGULAR )
    {
#ifdef FLA_ENABLE_CBLAS_INTERFACES
        *( ( enum CBLAS_UPLO* ) blas_uplo ) = CblasUpper;
#else
        *( ( char*            ) blas_uplo ) = 'U';
#endif
    }
    else
    {
        FLA_Check_error_code( FLA_INVALID_UPLO );
    }
}

References CblasLower, and CblasUpper.

Referenced by FLA_Bsvd_external(), FLA_Bsvdd_external(), FLA_Chol_blk_external(), FLA_Chol_unb_external(), FLA_Eig_gest_blk_external(), FLA_Eig_gest_unb_external(), FLA_Hemm_external_gpu(), FLA_Her2k_external_gpu(), FLA_Herk_external_gpu(), FLA_Hevd_external(), FLA_Hevdd_external(), FLA_Hevdr_external(), FLA_Symm_external_gpu(), FLA_Syr2k_external_gpu(), FLA_Syrk_external_gpu(), FLA_Tridiag_apply_Q_external(), FLA_Tridiag_blk_external(), FLA_Tridiag_form_Q_external(), FLA_Tridiag_unb_external(), FLA_Trinv_blk_external(), FLA_Trinv_unb_external(), FLA_Trmm_external_gpu(), FLA_Trsm_external_gpu(), FLA_Trsv_external_gpu(), FLA_Ttmm_blk_external(), and FLA_Ttmm_unb_external().

◆ FLA_Param_map_netlib_to_flame_diag()

void FLA_Param_map_netlib_to_flame_diag	(	char *	diag,
		FLA_Diag *	flame_diag
	)

{
    if      ( *diag == 'n' || *diag == 'N' )
        *flame_diag = FLA_NONUNIT_DIAG;
    else if ( *diag == 'u' || *diag == 'U' )
        *flame_diag = FLA_UNIT_DIAG;
    else
        FLA_Check_error_code( FLA_INVALID_DIAG );
}

◆ FLA_Param_map_netlib_to_flame_inv()

void FLA_Param_map_netlib_to_flame_inv	(	int *	itype,
		FLA_Inv *	flame_inv
	)

{
    if      ( *itype == 1 )
        *flame_inv = FLA_INVERSE;
    else if ( *itype == 2 || *itype == 3 )
        *flame_inv = FLA_NO_INVERSE;
    else
        FLA_Check_error_code( FLA_INVALID_INVERSE );
}

◆ FLA_Param_map_netlib_to_flame_side()

void FLA_Param_map_netlib_to_flame_side	(	char *	side,
		FLA_Side *	flame_side
	)

{
    if      ( *side == 'l' || *side == 'L' )
        *flame_side = FLA_LEFT;
    else if ( *side == 'r' || *side == 'R' )
        *flame_side = FLA_RIGHT;
    else
        FLA_Check_error_code( FLA_INVALID_SIDE );
}

◆ FLA_Param_map_netlib_to_flame_svd_type()

void FLA_Param_map_netlib_to_flame_svd_type	(	char *	svd,
		FLA_Svd_type *	flame_svd
	)

{
        if      ( *svd == 'A' || *svd == 'a' ) 
                *flame_svd = FLA_SVD_VECTORS_ALL;
    else if ( *svd == 'S' || *svd == 's' ) 
                *flame_svd = FLA_SVD_VECTORS_MIN_COPY;
    else if ( *svd == 'O' || *svd == 'o' ) 
                *flame_svd = FLA_SVD_VECTORS_MIN_OVERWRITE;
    else if ( *svd == 'N' || *svd == 'n' ) 
                *flame_svd = FLA_SVD_VECTORS_NONE;
    else
        FLA_Check_error_code( FLA_INVALID_SVD_TYPE );
}

◆ FLA_Param_map_netlib_to_flame_trans()

void FLA_Param_map_netlib_to_flame_trans	(	char *	trans,
		FLA_Trans *	flame_trans
	)

{
    if      ( *trans == 'n' || *trans == 'N' )
        *flame_trans = FLA_NO_TRANSPOSE;
    else if ( *trans == 't' || *trans == 'T' )
        *flame_trans = FLA_TRANSPOSE;
    else if ( *trans == 'c' || *trans == 'C' )
        *flame_trans = FLA_CONJ_TRANSPOSE;
    else
        FLA_Check_error_code( FLA_INVALID_TRANS );
}

◆ FLA_Param_map_netlib_to_flame_uplo()

void FLA_Param_map_netlib_to_flame_uplo	(	char *	uplo,
		FLA_Uplo *	flame_uplo
	)

{
    if      ( *uplo == 'l' || *uplo == 'L' )
        *flame_uplo = FLA_LOWER_TRIANGULAR;
    else if ( *uplo == 'u' || *uplo == 'U' )
        *flame_uplo = FLA_UPPER_TRIANGULAR;
    else
        FLA_Check_error_code( FLA_INVALID_UPLO );
}

◆ FLA_Part_1x2()

FLA_Error FLA_Part_1x2	(	FLA_Obj	A,
		FLA_Obj *	A1,
		FLA_Obj *	A2,
		dim_t	nb,
		FLA_Side	side
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Part_1x2_check( A,    A1,  A2,      nb, side );
 
  // Safeguard: if nb > n, reduce nb to n.
  if ( nb > A.n ) nb = A.n;
 
  // Set nb to be the dimension of A1.
  if ( side == FLA_RIGHT ) nb = A.n - nb;
 
  A1->m    = A.m;
  A1->n    = nb;
  A1->offm = A.offm;
  A1->offn = A.offn;
  A1->base = A.base;
 
  A2->m    = A.m;
  A2->n    = A.n - nb;
  A2->offm = A.offm;
  A2->offn = A.offn + nb;
  A2->base = A.base;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Part_1x2_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Part_1x2_check()

FLA_Error FLA_Part_1x2_check	(	FLA_Obj	A,
		FLA_Obj *	A1,
		FLA_Obj *	A2,
		dim_t	nb,
		FLA_Side	side
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A1 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A2 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_leftright_side( side );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), FLA_Check_valid_leftright_side(), and FLA_Check_valid_object_datatype().

Referenced by FLA_Part_1x2(), and FLASH_Part_create_1x2().

◆ FLA_Part_2x1()

FLA_Error FLA_Part_2x1	(	FLA_Obj	A,
		FLA_Obj *	A1,
		FLA_Obj *	A2,
		dim_t	mb,
		FLA_Side	side
	)

{ 
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Part_2x1_check( A,    A1,
                              A2,     mb, side );
 
  // Safeguard: if mb > m, reduce mb to m.
  if ( mb > A.m ) mb = A.m;
 
  // Set mb to be the dimension of A1.
  if ( side == FLA_BOTTOM ) mb = A.m - mb;
 
  A1->m    = mb;
  A1->n    = A.n;
  A1->offm = A.offm;
  A1->offn = A.offn;
  A1->base = A.base;
 
  A2->m    = A.m - mb;
  A2->n    = A.n;
  A2->offm = A.offm + mb;
  A2->offn = A.offn;
  A2->base = A.base;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Part_2x1_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Part_2x1_check()

FLA_Error FLA_Part_2x1_check	(	FLA_Obj	A,
		FLA_Obj *	A1,
		FLA_Obj *	A2,
		dim_t	mb,
		FLA_Side	side
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A1 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A2 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_topbottom_side( side );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), FLA_Check_valid_object_datatype(), and FLA_Check_valid_topbottom_side().

Referenced by FLA_Part_2x1(), and FLASH_Part_create_2x1().

◆ FLA_Part_2x2()

FLA_Error FLA_Part_2x2	(	FLA_Obj	A,
		FLA_Obj *	A11,
		FLA_Obj *	A12,
		FLA_Obj *	A21,
		FLA_Obj *	A22,
		dim_t	mb,
		dim_t	nb,
		FLA_Quadrant	quadrant
	)

{
  FLA_Base_obj *base;
  dim_t         m, n, offm, offn;
 
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Part_2x2_check( A,    A11, A12,
                              A21, A22,    mb, nb, quadrant );
 
  // Safeguard: if mb > m, reduce mb to m.
  if ( mb > A.m ) mb = A.m;
 
  // Safeguard: if nb > n, reduce nb to n.
  if ( nb > A.n ) nb = A.n;
 
  m        = A.m;
  n        = A.n;
  offm     = A.offm;
  offn     = A.offn;
  base     = A.base;
 
  // Set mb and nb to be the dimensions of A11.
  if ( quadrant == FLA_BL || quadrant == FLA_BR ) mb = m - mb;
  if ( quadrant == FLA_TR || quadrant == FLA_BR ) nb = n - nb;
 
  A11->m    = mb;
  A11->n    = nb;
  A11->offm = offm;
  A11->offn = offn;
  A11->base = base;
 
  A21->m    = m-mb;
  A21->n    = nb;
  A21->offm = offm + mb;
  A21->offn = offn;
  A21->base = base;
 
  A12->m    = mb;
  A12->n    = n-nb;
  A12->offm = offm;
  A12->offn = offn + nb;
  A12->base = base;
 
  A22->m    = m-mb;
  A22->n    = n-nb;
  A22->offm = offm + mb;
  A22->offn = offn + nb;
  A22->base = base;
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Part_2x2_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Part_2x2_check()

FLA_Error FLA_Part_2x2_check	(	FLA_Obj	A,
		FLA_Obj *	A11,
		FLA_Obj *	A12,
		FLA_Obj *	A21,
		FLA_Obj *	A22,
		dim_t	mb,
		dim_t	nb,
		FLA_Quadrant	quadrant
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( A );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A11 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A12 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A21 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A22 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_quadrant( quadrant );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), FLA_Check_valid_object_datatype(), and FLA_Check_valid_quadrant().

Referenced by FLA_Part_2x2(), and FLASH_Part_create_2x2().

◆ FLA_Print_message()

void FLA_Print_message	(	char *	str,
		char *	file,
		int	line
	)

{
    fprintf( stderr, "\n" );
    fprintf( stderr, "libflame: %s (line %d):\n", file, line );
    fprintf( stderr, "libflame: %s\n", str );
    fflush( stderr );
}

Referenced by FLA_Check_error_code_helper(), FLASH_Apply_CAQ_UT_inc_create_workspace(), FLASH_Apply_pivots(), FLASH_Apply_Q_UT(), FLASH_Apply_Q_UT_create_workspace(), FLASH_Apply_Q_UT_inc_create_workspace(), FLASH_Apply_QUD_UT_inc_create_workspace(), FLASH_CAQR_UT_inc_create_hier_matrices(), FLASH_Eig_gest(), FLASH_FS_incpiv(), FLASH_LQ_UT(), FLASH_LQ_UT_create_hier_matrices(), FLASH_LU_incpiv(), FLASH_LU_incpiv_create_hier_matrices(), FLASH_LU_piv(), FLASH_QR_UT(), FLASH_QR_UT_create_hier_matrices(), FLASH_QR_UT_inc_create_hier_matrices(), and FLASH_UDdate_UT_inc_create_hier_matrices().

◆ FLA_Query_blocksize()

dim_t FLA_Query_blocksize	(	FLA_Datatype	dt,
		FLA_Dimension	dim
	)

{
    dim_t b_val = 0;
 
#ifdef FLA_ENABLE_GOTO_INTERFACES
 
    int dt_index;
    int dim_index;
 
    if ( first_time )
    {
        long sgemm_min, dgemm_min, cgemm_min, zgemm_min;
        
        // Find the blocksizes associated with FLA_DIMENSION_MIN.
        sgemm_min = min( sgemm_p, sgemm_q );
        dgemm_min = min( dgemm_p, dgemm_q );
        cgemm_min = min( cgemm_p, cgemm_q );
        zgemm_min = min( zgemm_p, zgemm_q );
 
        // Set the values for each datatype and dimension constant.
        fla_goto_gemm_blocksize[FLA_S_INDEX][FLA_DIM_M_INDEX]   = sgemm_p;
        fla_goto_gemm_blocksize[FLA_S_INDEX][FLA_DIM_K_INDEX]   = sgemm_q;
        fla_goto_gemm_blocksize[FLA_S_INDEX][FLA_DIM_N_INDEX]   = sgemm_r;
        fla_goto_gemm_blocksize[FLA_S_INDEX][FLA_DIM_MIN_INDEX] = sgemm_min;
 
        fla_goto_gemm_blocksize[FLA_D_INDEX][FLA_DIM_M_INDEX]   = dgemm_p;
        fla_goto_gemm_blocksize[FLA_D_INDEX][FLA_DIM_K_INDEX]   = dgemm_q;
        fla_goto_gemm_blocksize[FLA_D_INDEX][FLA_DIM_N_INDEX]   = dgemm_r;
        fla_goto_gemm_blocksize[FLA_D_INDEX][FLA_DIM_MIN_INDEX] = dgemm_min;
 
        fla_goto_gemm_blocksize[FLA_C_INDEX][FLA_DIM_M_INDEX]   = cgemm_p;
        fla_goto_gemm_blocksize[FLA_C_INDEX][FLA_DIM_K_INDEX]   = cgemm_q;
        fla_goto_gemm_blocksize[FLA_C_INDEX][FLA_DIM_N_INDEX]   = cgemm_r;
        fla_goto_gemm_blocksize[FLA_C_INDEX][FLA_DIM_MIN_INDEX] = cgemm_min;
 
        fla_goto_gemm_blocksize[FLA_Z_INDEX][FLA_DIM_M_INDEX]   = zgemm_p;
        fla_goto_gemm_blocksize[FLA_Z_INDEX][FLA_DIM_K_INDEX]   = zgemm_q;
        fla_goto_gemm_blocksize[FLA_Z_INDEX][FLA_DIM_N_INDEX]   = zgemm_r;
        fla_goto_gemm_blocksize[FLA_Z_INDEX][FLA_DIM_MIN_INDEX] = zgemm_min;
 
        first_time = FALSE;
    }
 
    // Compute the index of the requested datatype.
    dt_index  = dt  & FLA_DTYPE_INDEX_MASK;
    dim_index = dim & FLA_DIM_INDEX_MASK;
 
    // Index into the array and choose the appropriate blocksize.
    b_val = ( dim_t ) fla_goto_gemm_blocksize[dt_index][dim_index];
 
#else
 
    // Assign the return value to a default sane blocksize in case
    // we cannot access the libgoto symbols.
    if      ( dim == FLA_DIMENSION_M )
        b_val = FLA_DEFAULT_M_BLOCKSIZE;
    else if ( dim == FLA_DIMENSION_K )
        b_val = FLA_DEFAULT_K_BLOCKSIZE;
    else if ( dim == FLA_DIMENSION_N )
        b_val = FLA_DEFAULT_N_BLOCKSIZE;
    else if ( dim == FLA_DIMENSION_MIN )
    {
        b_val = min( FLA_DEFAULT_M_BLOCKSIZE, FLA_DEFAULT_K_BLOCKSIZE );
        b_val = min( b_val, FLA_DEFAULT_N_BLOCKSIZE );
    }
 
#endif
 
    // Return the blocksize.
    return b_val;
}

References cgemm_p, cgemm_q, cgemm_r, dgemm_p, dgemm_q, dgemm_r, fla_goto_gemm_blocksize, sgemm_p, sgemm_q, sgemm_r, zgemm_p, zgemm_q, and zgemm_r.

Referenced by FLA_Apply_Q_blk_external(), FLA_Bidiag_blk_external(), FLA_Bidiag_UT_create_T(), FLA_Check_householder_panel_dims(), FLA_Hess_blk_external(), FLA_Hess_UT_create_T(), FLA_LQ_blk_external(), FLA_LQ_UT_create_T(), FLA_QR_blk_external(), FLA_QR_UT_create_T(), FLA_Query_blocksizes(), FLA_Tridiag_blk_external(), FLA_Tridiag_form_Q_external(), FLA_Tridiag_UT_create_T(), and FLA_UDdate_UT_create_T().

◆ FLA_Query_blocksizes()

fla_blocksize_t * FLA_Query_blocksizes ( FLA_Dimension dim )

{
    fla_blocksize_t* bp;
    
    // Create an FLA_Blocksize_t object.
    bp = FLA_Blocksize_create( 0, 0, 0, 0 );
    
    // Query the requested blocksize (m, k, or n dimension) for all of the
    // datatypes and package the results in an FLA_Blocksize_t structure.
    bp->s = FLA_Query_blocksize( FLA_FLOAT, dim );
    bp->d = FLA_Query_blocksize( FLA_DOUBLE, dim );
    bp->c = FLA_Query_blocksize( FLA_COMPLEX, dim );
    bp->z = FLA_Query_blocksize( FLA_DOUBLE_COMPLEX, dim );
    
    // Return a pointer to the structure.
    return bp;
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_Blocksize_create(), FLA_Query_blocksize(), FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

◆ FLA_realloc()

void * FLA_realloc	(	void *	old_ptr,
		size_t	size
	)

{
  FLA_Error e_val;
  void*     new_ptr;
 
  // We can't do much if size is zero. To emulate realloc(), we must
  // return a NULL pointer, regardless of the value of old_ptr.
  if ( size == 0 )
  {
    // If the pointer is valid, free() it.
    if ( old_ptr != NULL )
      FLA_free( old_ptr );
 
    // If size is zero, we should return a NULL pointer.
    new_ptr = NULL;
  }
  else
  {
    // If old_ptr is NULL, allocate size bytes as if it were a first-time
    // FLA_malloc() request. Otherwise, proceed to realloc() the memory.
    if ( old_ptr == NULL )
    {
      new_ptr = FLA_malloc( size );
    }
    else
    {
      // At this point, we know that size is non-zero and old_ptr is valid.
 
      // Since we may need aligned addresses, we don't really want to call
      // realloc(), since it does not guarantee arbitrary aligned pointers.
      // But we can't implement it ourselves either, because we don't know
      // how large the original buffer is, therefor we don't know how much
      // to copy over after the new buffer is allocated. So we're stuck with
      // the system implementation.
      new_ptr = realloc( old_ptr, size );
 
      if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
      {
        e_val = FLA_Check_malloc_pointer( new_ptr );
        FLA_Check_error_code( e_val );
      }
    }
  }
 
  // Return the pointer (either NULL, or the return value from FLA_malloc()
  // or realloc()).
  return new_ptr;
}

References FLA_Check_error_level(), FLA_Check_malloc_pointer(), FLA_free(), and FLA_malloc().

◆ FLA_Repart_1x2_to_1x3()

FLA_Error FLA_Repart_1x2_to_1x3	(	FLA_Obj	AL,
		FLA_Obj	AR,
		FLA_Obj *	A0,
		FLA_Obj *	A1,
		FLA_Obj *	A2,
		dim_t	nb,
		FLA_Side	side
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Repart_1x2_to_1x3_check( AL, AR,        A0, A1, A2,
                                 nb, side );
 
  if ( side == FLA_LEFT )
  {
    FLA_Part_1x2( AL,    A0, A1,    nb, FLA_RIGHT );
 
    A2->m    = AR.m;
    A2->n    = AR.n;
    A2->offm = AR.offm;
    A2->offn = AR.offn;
    A2->base = AR.base;
  }
  else
  {
    A0->m    = AL.m;
    A0->n    = AL.n;
    A0->offm = AL.offm;
    A0->offn = AL.offn;
    A0->base = AL.base;
 
    FLA_Part_1x2( AR,    A1, A2,    nb, FLA_LEFT );
  }
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Part_1x2(), FLA_Repart_1x2_to_1x3_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Repart_1x2_to_1x3_check()

FLA_Error FLA_Repart_1x2_to_1x3_check	(	FLA_Obj	AL,
		FLA_Obj	AR,
		FLA_Obj *	A0,
		FLA_Obj *	A1,
		FLA_Obj *	A2,
		dim_t	nb,
		FLA_Side	side
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( AL );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( AR );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A0 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A1 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A2 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_leftright_side( side );
  FLA_Check_error_code( e_val );
 
  if      ( side == FLA_LEFT )
  {
    e_val = FLA_Check_attempted_repart_1x2( AL, nb );
    FLA_Check_error_code( e_val );
  }
  else if ( side == FLA_RIGHT )
  {
    e_val = FLA_Check_attempted_repart_1x2( AR, nb );
    FLA_Check_error_code( e_val );
  }
 
  // Needed: check for adjacency, similar to those in FLA_Merge_*().
 
  return FLA_SUCCESS;
}

References FLA_Check_attempted_repart_1x2(), FLA_Check_null_pointer(), FLA_Check_valid_leftright_side(), and FLA_Check_valid_object_datatype().

Referenced by FLA_Repart_1x2_to_1x3().

◆ FLA_Repart_2x1_to_3x1()

FLA_Error FLA_Repart_2x1_to_3x1	(	FLA_Obj	AT,
		FLA_Obj *	A0,
		FLA_Obj *	A1,
		FLA_Obj	AB,
		FLA_Obj *	A2,
		dim_t	mb,
		FLA_Side	side
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Repart_2x1_to_3x1_check( AT,     A0, 
                                         A1, 
                                 AB,     A2,     mb, side );
 
  if ( side == FLA_TOP )
  {
    FLA_Part_2x1 ( AT,    A0, 
                          A1,    mb, FLA_BOTTOM );
 
    A2->m    = AB.m;
    A2->n    = AB.n;
    A2->offm = AB.offm;
    A2->offn = AB.offn;
    A2->base = AB.base;
  }
  else
  {
    A0->m    = AT.m;
    A0->n    = AT.n;
    A0->offm = AT.offm;
    A0->offn = AT.offn;
    A0->base = AT.base;
 
    FLA_Part_2x1 ( AB,    A1, 
                          A2,    mb, FLA_TOP );
  }
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Part_2x1(), FLA_Repart_2x1_to_3x1_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Repart_2x1_to_3x1_check()

FLA_Error FLA_Repart_2x1_to_3x1_check	(	FLA_Obj	AT,
		FLA_Obj *	A0,
		FLA_Obj *	A1,
		FLA_Obj	AB,
		FLA_Obj *	A2,
		dim_t	mb,
		FLA_Side	side
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( AT );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( AB );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A0 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A1 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A2 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_topbottom_side( side );
  FLA_Check_error_code( e_val );
 
  if      ( side == FLA_TOP )
  {
    e_val = FLA_Check_attempted_repart_2x1( AT, mb );
    FLA_Check_error_code( e_val );
  }
  else if ( side == FLA_BOTTOM )
  {
    e_val = FLA_Check_attempted_repart_2x1( AB, mb );
    FLA_Check_error_code( e_val );
  }
 
  // Needed: check for adjacency, similar to those in FLA_Merge_*().
 
  return FLA_SUCCESS;
}

References FLA_Check_attempted_repart_2x1(), FLA_Check_null_pointer(), FLA_Check_valid_object_datatype(), and FLA_Check_valid_topbottom_side().

Referenced by FLA_Repart_2x1_to_3x1().

◆ FLA_Repart_2x2_to_3x3()

FLA_Error FLA_Repart_2x2_to_3x3	(	FLA_Obj	ATL,
		FLA_Obj	ATR,
		FLA_Obj *	A00,
		FLA_Obj *	A01,
		FLA_Obj *	A02,
		FLA_Obj *	A10,
		FLA_Obj *	A11,
		FLA_Obj *	A12,
		FLA_Obj	ABL,
		FLA_Obj	ABR,
		FLA_Obj *	A20,
		FLA_Obj *	A21,
		FLA_Obj *	A22,
		dim_t	mb,
		dim_t	nb,
		FLA_Quadrant	quadrant
	)

{
  if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
    FLA_Repart_2x2_to_3x3_check( ATL, ATR,       A00, A01, A02,
                                                 A10, A11, A12,
                                 ABL, ABR,       A20, A21, A22,
                                 mb, nb, quadrant );
 
  if ( quadrant == FLA_BR )
  { 
    FLA_Part_2x2( ABR,    A11, A12,
                          A21, A22,    mb, nb, FLA_TL );
 
    FLA_Part_1x2( ATR,    A01, A02,    nb, FLA_LEFT );
 
    FLA_Part_2x1( ABL,    A10, 
                          A20,         mb, FLA_TOP );
 
    A00->m    = ATL.m;
    A00->n    = ATL.n;
    A00->offm = ATL.offm;
    A00->offn = ATL.offn;
    A00->base = ATL.base;
  }
  else if ( quadrant == FLA_BL )
  {
    FLA_Part_2x2( ABL,    A10, A11,
                          A20, A21,    mb, nb, FLA_TR );
 
    FLA_Part_1x2( ATL,    A00, A01,    nb, FLA_RIGHT );
 
    FLA_Part_2x1( ABR,    A12, 
                          A22,         mb, FLA_TOP );
 
    A02->m    = ATR.m;
    A02->n    = ATR.n;
    A02->offm = ATR.offm;
    A02->offn = ATR.offn;
    A02->base = ATR.base;
  }
  else if ( quadrant == FLA_TL )
  {
    FLA_Part_2x2( ATL,    A00, A01,
                          A10, A11,    mb, nb, FLA_BR );
 
    FLA_Part_1x2( ABL,    A20, A21,    nb, FLA_RIGHT );
 
    FLA_Part_2x1( ATR,    A02, 
                          A12,         mb, FLA_BOTTOM );
 
    A22->m    = ABR.m;
    A22->n    = ABR.n;
    A22->offm = ABR.offm;
    A22->offn = ABR.offn;
    A22->base = ABR.base;
  }
  else if ( quadrant == FLA_TR )
  {
    FLA_Part_2x2( ATR,    A01, A02,
                          A11, A12,    mb, nb, FLA_BL );
 
    FLA_Part_1x2( ABR,    A21, A22,    nb, FLA_LEFT );
 
    FLA_Part_2x1( ATL,    A00,
                          A10,         mb, FLA_BOTTOM );
 
    A20->m    = ABL.m;
    A20->n    = ABL.n;
    A20->offm = ABL.offm;
    A20->offn = ABL.offn;
    A20->base = ABL.base;
  }
 
  return FLA_SUCCESS;
}

References FLA_Obj_view::base, FLA_Check_error_level(), FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_Repart_2x2_to_3x3_check(), FLA_Obj_view::m, FLA_Obj_view::n, FLA_Obj_view::offm, and FLA_Obj_view::offn.

◆ FLA_Repart_2x2_to_3x3_check()

FLA_Error FLA_Repart_2x2_to_3x3_check	(	FLA_Obj	ATL,
		FLA_Obj	ATR,
		FLA_Obj *	A00,
		FLA_Obj *	A01,
		FLA_Obj *	A02,
		FLA_Obj *	A10,
		FLA_Obj *	A11,
		FLA_Obj *	A12,
		FLA_Obj	ABL,
		FLA_Obj	ABR,
		FLA_Obj *	A20,
		FLA_Obj *	A21,
		FLA_Obj *	A22,
		dim_t	mb,
		dim_t	nb,
		FLA_Quadrant	quadrant
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_object_datatype( ATL );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( ABL );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( ATR );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_object_datatype( ABR );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A00 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A10 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A20 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A01 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A11 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A21 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A02 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A12 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( A22 );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_valid_quadrant( quadrant );
  FLA_Check_error_code( e_val );
 
  if      ( quadrant == FLA_TL )
  {
    e_val = FLA_Check_attempted_repart_2x2( ATL, mb, nb );
    FLA_Check_error_code( e_val );
  }
  else if ( quadrant == FLA_TR )
  {
    e_val = FLA_Check_attempted_repart_2x2( ATR, mb, nb );
    FLA_Check_error_code( e_val );
  }
  else if ( quadrant == FLA_BL )
  {
    e_val = FLA_Check_attempted_repart_2x2( ABL, mb, nb );
    FLA_Check_error_code( e_val );
  }
  else if ( quadrant == FLA_BR )
  {
    e_val = FLA_Check_attempted_repart_2x2( ABR, mb, nb );
    FLA_Check_error_code( e_val );
  }
 
  // Needed: check for adjacency, similar to those in FLA_Merge_*().
 
  return FLA_SUCCESS;
}

References FLA_Check_attempted_repart_2x2(), FLA_Check_null_pointer(), FLA_Check_valid_object_datatype(), and FLA_Check_valid_quadrant().

Referenced by FLA_Repart_2x2_to_3x3().

◆ FLA_Repart_3x3_to_5x5()

FLA_Error FLA_Repart_3x3_to_5x5	(	FLA_Obj	ATL,
		FLA_Obj	ATM,
		FLA_Obj	ATR,
		FLA_Obj	AML,
		FLA_Obj	AMM,
		FLA_Obj	AMR,
		FLA_Obj	ABL,
		FLA_Obj	ABM,
		FLA_Obj	ABR,
		FLA_Obj *	A00,
		FLA_Obj *	A01,
		FLA_Obj *	A02,
		FLA_Obj *	A03,
		FLA_Obj *	A04,
		FLA_Obj *	A10,
		FLA_Obj *	A11,
		FLA_Obj *	A12,
		FLA_Obj *	A13,
		FLA_Obj *	A14,
		FLA_Obj *	A20,
		FLA_Obj *	A21,
		FLA_Obj *	A22,
		FLA_Obj *	A23,
		FLA_Obj *	A24,
		FLA_Obj *	A30,
		FLA_Obj *	A31,
		FLA_Obj *	A32,
		FLA_Obj *	A33,
		FLA_Obj *	A34,
		FLA_Obj *	A40,
		FLA_Obj *	A41,
		FLA_Obj *	A42,
		FLA_Obj *	A43,
		FLA_Obj *	A44,
		dim_t	b,
		FLA_Quadrant	quadrant
	)

◆ FLA_shfree()

void FLA_shfree ( void * ptr )

{
  RCCE_shfree( ( t_vcharp ) ptr );
}

References RCCE_shfree().

Referenced by FLA_Obj_free(), FLA_Obj_free_buffer(), FLASH_Obj_free(), and FLASH_Queue_exec().

◆ FLA_shmalloc()

void * FLA_shmalloc ( size_t size )

{
  return ( void * ) RCCE_shmalloc( size );
}

References RCCE_shmalloc().

Referenced by FLA_Obj_create_buffer(), FLA_Obj_create_ext(), and FLASH_Queue_exec().

◆ FLA_Submatrix_at()

void * FLA_Submatrix_at	(	FLA_Datatype	datatype,
		void *	buffer,
		dim_t	i,
		dim_t	j,
		dim_t	rs,
		dim_t	cs
	)

{
  void* r_val = buffer;
 
  if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    FLA_Submatrix_at_check( datatype, buffer, i, j, rs, cs );
 
  switch( datatype )
  {
    case FLA_INT:
      r_val = ( void* ) ( (      ( int* ) buffer ) + i * rs + j * cs );
      break;
 
    case FLA_FLOAT:
      r_val = ( void* ) ( (    ( float* ) buffer ) + i * rs + j * cs );
      break;
 
    case FLA_DOUBLE:
      r_val = ( void* ) ( (   ( double* ) buffer ) + i * rs + j * cs );
      break;
 
    case FLA_COMPLEX:
      r_val = ( void* ) ( ( ( scomplex* ) buffer ) + i * rs + j * cs );
      break;
 
    case FLA_DOUBLE_COMPLEX:
      r_val = ( void* ) ( ( ( dcomplex* ) buffer ) + i * rs + j * cs );
      break;
  }
 
  return r_val;
}

References FLA_Check_error_level(), FLA_Submatrix_at_check(), and i.

◆ FLA_Submatrix_at_check()

FLA_Error FLA_Submatrix_at_check	(	FLA_Datatype	datatype,
		void *	buffer,
		dim_t	i,
		dim_t	j,
		dim_t	rs,
		dim_t	cs
	)

{
  FLA_Error e_val;
 
  e_val = FLA_Check_valid_datatype( datatype );
  FLA_Check_error_code( e_val );
 
  e_val = FLA_Check_null_pointer( buffer );
  FLA_Check_error_code( e_val );
 
  return FLA_SUCCESS;
}

References FLA_Check_null_pointer(), and FLA_Check_valid_datatype().

Referenced by FLA_Submatrix_at().

(r)

Functions

Function Documentation

◆ FLA_Abort()

◆ FLA_adjust_strides()

◆ FLA_align_ldim()

◆ FLA_Axpy_buffer_to_object()

◆ FLA_Axpy_buffer_to_object_check()

◆ FLA_Axpy_object_to_buffer()

◆ FLA_Axpy_object_to_buffer_check()

◆ FLA_Blocksize_create()

◆ FLA_Blocksize_create_copy()

◆ FLA_Blocksize_extract()

◆ FLA_Blocksize_free()

◆ FLA_Blocksize_scale()

◆ FLA_Blocksize_set()

◆ FLA_Check_adjacent_objects_1x2()

◆ FLA_Check_adjacent_objects_2x1()

◆ FLA_Check_adjacent_objects_2x2()

◆ FLA_Check_attempted_repart_1x2()

◆ FLA_Check_attempted_repart_2x1()

◆ FLA_Check_attempted_repart_2x2()

◆ FLA_Check_base_buffer_mismatch()

◆ FLA_Check_blocksize_object()

◆ FLA_Check_blocksize_value()

◆ FLA_Check_chol_failure()

◆ FLA_Check_close_result()

◆ FLA_Check_col_storage()

◆ FLA_Check_col_vector()

◆ FLA_Check_comparable_object()

◆ FLA_Check_complex_datatype()

◆ FLA_Check_complex_object()

◆ FLA_Check_conformal_dims()

◆ FLA_Check_conj1_trans_and_datatype()

◆ FLA_Check_conj_and_datatype()

◆ FLA_Check_consistent_datatype()

◆ FLA_Check_consistent_object_datatype()

◆ FLA_Check_divide_by_zero()

◆ FLA_Check_equal_vector_dims()

◆ FLA_Check_error_code_helper()

◆ FLA_Check_error_level()

◆ FLA_Check_error_level_set()

◆ FLA_Check_file_descriptor()

◆ FLA_Check_floating_datatype()

◆ FLA_Check_floating_object()

◆ FLA_Check_hess_indices()

◆ FLA_Check_householder_panel_dims()

◆ FLA_Check_identical_object_datatype()

◆ FLA_Check_identical_object_elemtype()

◆ FLA_Check_identical_object_precision()

◆ FLA_Check_if_scalar()

◆ FLA_Check_if_vector()

◆ FLA_Check_int_datatype()

◆ FLA_Check_int_object()

◆ FLA_Check_lseek_result()

◆ FLA_Check_malloc_pointer()

◆ FLA_Check_matrix_matrix_dims()

◆ FLA_Check_matrix_strides()

◆ FLA_Check_matrix_vector_dims()

◆ FLA_Check_nonconstant_datatype()

◆ FLA_Check_nonconstant_object()

◆ FLA_Check_null_pointer()

◆ FLA_Check_num_threads()

◆ FLA_Check_object_dims()

◆ FLA_Check_object_length_equals()

◆ FLA_Check_object_length_min()

◆ FLA_Check_object_matrix_elemtype()

◆ FLA_Check_object_scalar_elemtype()

◆ FLA_Check_object_width_equals()

◆ FLA_Check_object_width_min()

◆ FLA_Check_pivot_index_range()

◆ FLA_Check_posix_memalign_failure()

◆ FLA_Check_pthread_create_result()

◆ FLA_Check_pthread_join_result()

◆ FLA_Check_read_result()

◆ FLA_Check_real_datatype()

◆ FLA_Check_real_object()

◆ FLA_Check_row_storage()

◆ FLA_Check_row_vector()

◆ FLA_Check_square()