spmatrix_complex_long_double.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2010, 2011, 2012, 2019, 2020, 2021 John D Lamb
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
#ifndef CCGSL_SPMATRIX_HPP
#define CCGSL_SPMATRIX_HPP
 
#include<cstddef>
#include<gsl/gsl_spmatrix.h>
#include<new>
 
#include"exception.hpp"
#include"vector_complex_long_double.hpp"
#include"matrix_complex_long_double.hpp"
 
namespace gsl {
  class spmatrix_complex_long_double {
  public:
    enum {
      COO = GSL_SPMATRIX_COO,
      CSC = GSL_SPMATRIX_CSC,
      CSR = GSL_SPMATRIX_CSR,
      TRIPLET = GSL_SPMATRIX_TRIPLET,
      CCS = GSL_SPMATRIX_CCS,
      CRS = GSL_SPMATRIX_CRS
    };
    spmatrix_complex_long_double(){
      ccgsl_pointer = 0;
      count = 0; // initially nullptr will do
    }
    // Refines random access container
    // Refines assignable
    explicit spmatrix_complex_long_double( size_t const n1, size_t const n2 ){
      if( n1 > 0 and n2 > 0 ) ccgsl_pointer = gsl_spmatrix_complex_long_double_alloc( n1, n2 );
      else { ccgsl_pointer = new gsl_spmatrix_complex_long_double; ccgsl_pointer->size1 = n1;
    ccgsl_pointer->size2 = n2; ccgsl_pointer->data = 0; }
      // just plausibly we could allocate spmatrix_complex_long_double but not count
      try { count = new size_t; } catch( std::bad_alloc& e ){
    // try to tidy up before rethrowing
    if( n1 > 0 and n2 > 0 ) gsl_spmatrix_complex_long_double_free( ccgsl_pointer );
    else delete ccgsl_pointer;
    throw e;
      }
      *count = 1; // initially there is just one reference to ccgsl_pointer
    }
    explicit spmatrix_complex_long_double( size_t const n1, size_t const n2, size_t nzmax, size_t sptype ){
      if( n1 > 0 and n2 > 0 )
    ccgsl_pointer = gsl_spmatrix_complex_long_double_alloc_nzmax( n1, n2, nzmax, sptype );
      else { ccgsl_pointer = new gsl_spmatrix_complex_long_double; ccgsl_pointer->size1 = n1;
    ccgsl_pointer->size2 = n2; ccgsl_pointer->data = 0; }
      // just plausibly we could allocate spmatrix_complex_long_double but not count
      try { count = new size_t; } catch( std::bad_alloc& e ){
    // try to tidy up before rethrowing
    if( n1 > 0 and n2 > 0 ) gsl_spmatrix_complex_long_double_free( ccgsl_pointer );
    else delete ccgsl_pointer;
    throw e;
      }
      *count = 1; // initially there is just one reference to ccgsl_pointer
    }
    explicit spmatrix_complex_long_double( gsl_spmatrix_complex_long_double* v ){
      ccgsl_pointer = v;
      // just plausibly we could fail to allocate count: no further action needed.
      count = new size_t;
      *count = 1; // initially there is just one reference to ccgsl_pointer
    }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    spmatrix_complex_long_double( std::initializer_list<std::initializer_list<complex_long_double> > initializer_list ){
      size_t const n1 = initializer_list.size();
      size_t const n2 = initializer_list.begin()->size();
      for( auto l : initializer_list ){
    if( l.size() != n2 ){
      gsl::exception e( "matrix_complex_long_double rows have unequal sizes", __FILE__, __LINE__,
                exception::GSL_EBADLEN );
      throw( e );
    }
      }
      ccgsl_pointer = gsl_spmatrix_complex_long_double_alloc( n1, n2 );
      // just plausibly we could allocate spmatrix_complex_long_double but not count
      try { count = new size_t; } catch( std::bad_alloc& e ){
    // try to tidy up before rethrowing
    if( n1 > 0 and n2 > 0 ) gsl_spmatrix_complex_long_double_free( ccgsl_pointer );
    else delete ccgsl_pointer;
    throw e;
      }
      *count = 1; // initially there is just one reference to ccgsl_pointer
      // now copy
      int r = 0;
      for( auto row : initializer_list ){
    size_t c = 0;
    for( auto x : row ){ set( r, c, x ); ++c; }
    ++r;
      }
    }
#endif
    // copy constructor
    spmatrix_complex_long_double( spmatrix_complex_long_double const& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( v.count ){
      if( count != 0 ) ++*count; // spmatrix_complex_long_double is now shared.
    }
    // assignment operator
    spmatrix_complex_long_double& operator=( spmatrix_complex_long_double const& v ){
      // first, possibly delete anything pointed to by this
      if( count == 0 or --*count == 0 ){
    if( ccgsl_pointer != 0 and ccgsl_pointer->size1 > 0
        and ccgsl_pointer->size2 > 0 ) gsl_spmatrix_complex_long_double_free( ccgsl_pointer );
    else delete ccgsl_pointer;
    delete count;
      }
      // Then copy
      ccgsl_pointer = v.ccgsl_pointer;
      count = v.count;
      if( count != 0 ) ++*count; // block is now shared.
      return *this;
    }
    // clone()
    spmatrix_complex_long_double clone() const {
      spmatrix_complex_long_double copy( get()->size1, get()->size2 );
      // Now copy
      gsl_spmatrix_complex_long_double_memcpy( copy.get(), get() );
      // return new object
      return copy;
    }
    // destructor
    ~spmatrix_complex_long_double(){
      if( count != 0 and --*count == 0 ){
    // could have allocated null pointer
    if( ccgsl_pointer != 0 ){
      if( ccgsl_pointer->size1 > 0 and ccgsl_pointer->size2 > 0 )
        gsl_spmatrix_complex_long_double_free( ccgsl_pointer );
      else delete ccgsl_pointer; }
    delete count;
      }
    }
    // Allow possibility of assigning from gsl_spmatrix_complex_long_double without sharing
    void wrap_gsl_spmatrix_complex_long_double_without_ownership( gsl_spmatrix_complex_long_double* v ){
      if( count != 0 and --*count == 0 ){
    // could have allocated null pointer
    if( ccgsl_pointer != 0 ){
      if( ccgsl_pointer->size1 != 0 and ccgsl_pointer->size1 != 0 )
        gsl_spmatrix_complex_long_double_free( ccgsl_pointer );
      else delete ccgsl_pointer; }
      }
      ccgsl_pointer = v;
      if(0 == count) count = new size_t;
      *count = 2; // should never be able to delete ccgsl_pointer
    }
    void reset(){ spmatrix_complex_long_double().swap( *this ); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    spmatrix_complex_long_double( spmatrix_complex_long_double&& v ) : ccgsl_pointer( v.ccgsl_pointer ), count( nullptr ){
      std::swap( count, v.count );
      v.ccgsl_pointer = nullptr;
    }
    spmatrix_complex_long_double& operator=( spmatrix_complex_long_double&& v ){
      spmatrix_complex_long_double( std::move( v ) ).swap( *this );
      return *this;
    }
#endif
  public:
    // Sizes
    size_t size1() const { return ccgsl_pointer == 0 ? 0 : ccgsl_pointer->size1; }
    size_t size2() const { return ccgsl_pointer == 0 ? 0 : ccgsl_pointer->size2; }
    size_t nzmax() const { return ccgsl_pointer == 0 ? 0 : ccgsl_pointer->nzmax; }
    int sptype() const { return ccgsl_pointer == 0 ? 0 : ccgsl_pointer->sptype; }
    long double* data() { 
      if( ccgsl_pointer == 0 ) gsl_error( "null vector_complex_long_double", __FILE__, __LINE__, GSL_EFAULT );
      return ccgsl_pointer->data; }
    long double const* data() const {
      if( ccgsl_pointer == 0 ) gsl_error( "null vector_complex_long_double", __FILE__, __LINE__, GSL_EFAULT );
      return ccgsl_pointer->data; }
    void swap( spmatrix_complex_long_double& m ){
      std::swap( ccgsl_pointer, m.ccgsl_pointer );
      std::swap( count, m.count );
    }
    int realloc( size_t const nzmax ){ return gsl_spmatrix_complex_long_double_realloc( nzmax, get() ); }
    size_t nnz() const { return gsl_spmatrix_complex_long_double_nnz( get() ); }  
    char const* type() const { return gsl_spmatrix_complex_long_double_type( get() ); }
    int set_zero(){ return gsl_spmatrix_complex_long_double_set_zero( get() ); }
    int tree_rebuild(){ return gsl_spmatrix_complex_long_double_tree_rebuild( get() ); }
    spmatrix_complex_long_double csc() const {
      spmatrix_complex_long_double dest { size1(), size2() }; 
      gsl_spmatrix_complex_long_double_csc( dest.get(), get() );
      return dest;
    }
    spmatrix_complex_long_double csr() const {
      spmatrix_complex_long_double dest { size1(), size2() }; 
      gsl_spmatrix_complex_long_double_csr( dest.get(), get() );
      return dest;
    }
    spmatrix_complex_long_double compress( int const sptype ) const {
      spmatrix_complex_long_double dest { gsl_spmatrix_complex_long_double_compress( get(), sptype ) };
      return dest; }
    spmatrix_complex_long_double compcol() const {
      spmatrix_complex_long_double dest { gsl_spmatrix_complex_long_double_compcol( get() ) };
      return dest; }
    spmatrix_complex_long_double ccs() const {
      spmatrix_complex_long_double dest { gsl_spmatrix_complex_long_double_ccs( get() ) };
      return dest; }
    spmatrix_complex_long_double crs() const {
      spmatrix_complex_long_double dest { gsl_spmatrix_complex_long_double_crs( get() ) };
      return dest; }
    int memcpy( spmatrix_complex_long_double& dest ) const { return gsl_spmatrix_complex_long_double_memcpy( dest.get(), get() ); }
    int fprintf( FILE* stream, char const* format ) const {
      return gsl_spmatrix_complex_long_double_fprintf( stream, get(), format ); }
    int fwrite( FILE* stream ) const {
      return gsl_spmatrix_complex_long_double_fwrite( stream, get() ); }
    int fread( FILE* stream ){
      return gsl_spmatrix_complex_long_double_fread( stream, get() ); }
    complex_long_double get( size_t const i, size_t const j ) const {
      return gsl_spmatrix_complex_long_double_get( get(), i, j ); }
    int set( size_t const i, size_t const j, complex_long_double const x ){
      return gsl_spmatrix_complex_long_double_set( get(), i, j, x ); }
    gsl_complex_long_double* ptr( size_t const i, size_t const j ) const {
      return gsl_spmatrix_complex_long_double_ptr( get(), i, j ); }
    // END REAL ONLY
    int scale( complex_long_double const x ){ return gsl_spmatrix_complex_long_double_scale( get(), x ); }
    int scale_columns( gsl::vector_complex_long_double const& x ){
      return gsl_spmatrix_complex_long_double_scale_columns( get(), x.get() ); }
    int scale_rows( gsl::vector_complex_long_double const& x ){
      return gsl_spmatrix_complex_long_double_scale_rows( get(), x.get() ); }
    int equal( spmatrix_complex_long_double const& b ) const { return gsl_spmatrix_complex_long_double_equal( get(), b.get() ); }
    int transpose(){ return gsl_spmatrix_complex_long_double_transpose( get() ); }
    int transpose2(){ return gsl_spmatrix_complex_long_double_transpose2( get() ); }
    // Now the static functions
    static int realloc( size_t const nzmax, gsl::spmatrix_complex_long_double& spMatrix ){
      return gsl_spmatrix_complex_long_double_realloc( nzmax, spMatrix.get() ); }
    static size_t nnz( spmatrix_complex_long_double const& spMatrix ){
      return gsl_spmatrix_complex_long_double_nnz( spMatrix.get() ); }  
    static char const* type( spmatrix_complex_long_double const& spMatrix ){
      return gsl_spmatrix_complex_long_double_type( spMatrix.get() ); }
    static int set_zero( spmatrix_complex_long_double& spMatrix ){
      return gsl_spmatrix_complex_long_double_set_zero( spMatrix.get() ); }
    static int tree_rebuild( spmatrix_complex_long_double& spMatrix ){
      return gsl_spmatrix_complex_long_double_tree_rebuild( spMatrix.get() ); }
    static spmatrix_complex_long_double csc( spmatrix_complex_long_double const& spMatrix ){
      spmatrix_complex_long_double dest { spMatrix.size1(), spMatrix.size2() }; 
      gsl_spmatrix_complex_long_double_csc( dest.get(), spMatrix.get() );
      return dest; }
    static spmatrix_complex_long_double csr( spmatrix_complex_long_double const& spMatrix ){
      spmatrix_complex_long_double dest { spMatrix.size1(), spMatrix.size2() }; 
      gsl_spmatrix_complex_long_double_csr( dest.get(), spMatrix.get() );
      return dest; }
    static spmatrix_complex_long_double compress( spmatrix_complex_long_double const& spMatrix, int const sptype ){
      spmatrix_complex_long_double dest { gsl_spmatrix_complex_long_double_compress( spMatrix.get(), sptype ) };
      return dest; }
    static spmatrix_complex_long_double compcol( spmatrix_complex_long_double const& spMatrix ){
      spmatrix_complex_long_double dest { gsl_spmatrix_complex_long_double_compcol( spMatrix.get() ) };
      return dest; }
    static spmatrix_complex_long_double ccs( spmatrix_complex_long_double const& spMatrix ){
      spmatrix_complex_long_double dest { gsl_spmatrix_complex_long_double_ccs( spMatrix.get() ) };
      return dest; }
    static spmatrix_complex_long_double crs( spmatrix_complex_long_double const& spMatrix ){
      spmatrix_complex_long_double dest { gsl_spmatrix_complex_long_double_crs( spMatrix.get() ) };
      return dest; }
    static int memcpy( spmatrix_complex_long_double& dest, spmatrix_complex_long_double const& src ){
      return gsl_spmatrix_complex_long_double_memcpy( dest.get(), src.get() ); }
    static int fprintf( FILE* stream, spmatrix_complex_long_double const& spMatrix, char const* format ){
      return gsl_spmatrix_complex_long_double_fprintf( stream, spMatrix.get(), format ); }
    static spmatrix_complex_long_double fscanf( FILE* stream ){
      return spmatrix_complex_long_double { gsl_spmatrix_complex_long_double_fscanf( stream ) }; }
    static int fwrite( FILE* stream, spmatrix_complex_long_double& spMatrix ){
      return gsl_spmatrix_complex_long_double_fwrite( stream, spMatrix.get() ); }
    static int fread( FILE* stream, spmatrix_complex_long_double& spMatrix ){
      return gsl_spmatrix_complex_long_double_fread( stream, spMatrix.get() ); }
    static int add( spmatrix_complex_long_double& c, spmatrix_complex_long_double const& a, spmatrix_complex_long_double const& b ){
      return gsl_spmatrix_complex_long_double_add( c.get(), a.get(), b.get() ); }
    static spmatrix_complex_long_double add( spmatrix_complex_long_double const& a, spmatrix_complex_long_double const& b ){
      spmatrix_complex_long_double c { a.size1(), a.size2() };
      gsl_spmatrix_complex_long_double_add( c.get(), a.get(), b.get() );
      return c;
    }
#ifndef GSL_DISABLE_DEPRECATED
    static int add_to_dense( gsl::matrix_complex_long_double& a, spmatrix_complex_long_double const&b ){
      return gsl_spmatrix_complex_long_double_add_to_dense( a.get(), b.get() ); }
#endif
    static int dense_add( gsl::matrix_complex_long_double& a, spmatrix_complex_long_double const&b ){
      return gsl_spmatrix_complex_long_double_dense_add( a.get(), b.get() ); }
    static int dense_sub( gsl::matrix_complex_long_double& a, spmatrix_complex_long_double const&b ){
      return gsl_spmatrix_complex_long_double_dense_sub( a.get(), b.get() ); }
    static int d2sp( gsl::spmatrix_complex_long_double& S, gsl::matrix_complex_long_double const& A ){
      return gsl_spmatrix_complex_long_double_d2sp( S.get(), A.get() ); }
    static int sp2d( gsl::matrix_complex_long_double& A, spmatrix_complex_long_double const& S ){
      return gsl_spmatrix_complex_long_double_sp2d( A.get(), S.get() ); }
    static int equal( spmatrix_complex_long_double const& a, spmatrix_complex_long_double const& b ){
      return gsl_spmatrix_complex_long_double_equal( a.get(), b.get() ); }
    static int transpose( spmatrix_complex_long_double& a ){ return gsl_spmatrix_complex_long_double_transpose( a.get() ); }
    static int transpose2( spmatrix_complex_long_double& a ){ return gsl_spmatrix_complex_long_double_transpose2( a.get() ); }
    static int transpose_memcpy( spmatrix_complex_long_double& dest, spmatrix_complex_long_double const& src ){
      return gsl_spmatrix_complex_long_double_transpose_memcpy( dest.get(), src.get() ); }
  private:
    gsl_spmatrix_complex_long_double* ccgsl_pointer;
    size_t* count;
  public:
    // shared reference functions
    gsl_spmatrix_complex_long_double* get(){ return ccgsl_pointer; }
    gsl_spmatrix_complex_long_double const* get() const { return ccgsl_pointer; }
    bool unique() const { return count != 0 and *count == 1; }
    size_t use_count() const { return count == 0 ? 0 : *count; }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    explicit
#endif
    operator bool() const { return ccgsl_pointer != 0; }
  };
}
#endif