Permutation.h

Go to the documentation of this file.

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

#ifndef MYRAMATH_SPARSE_PERMUTATION_H
#define MYRAMATH_SPARSE_PERMUTATION_H

#include <myramath/utility/detail/LIBPUBLIC.h>

#include <myramath/utility/Number.h>

#include <vector>
#include <iosfwd>

namespace myra {

// Forward declarations.
class Permutation;
class InputStream;
class OutputStream;
class intCRange;
class intRange;
template<class Number> class VectorRange;
template<class Number> class MatrixRange;
template<class Number> class SparseMatrix;

class LIBPUBLIC Permutation
  {
  public:

    // ------------------------------------ Construction, serialization, value semantics.

    Permutation();


    // Tags for upcoming constructors. Since all of these inputs are the same type (range of int), specify which is intended by using a Tag.
    class  permTag{};
    class ipermTag{};
    class swapsTag{};

    explicit Permutation(const intCRange&  perm, const  permTag&);
    explicit Permutation(const intCRange& iperm, const ipermTag&);
    explicit Permutation(const intCRange& swaps, const swapsTag&);
    
    Permutation(const Permutation& that);

    void swap(Permutation& that);

#ifdef MYRAMATH_ENABLE_CPP11
    Permutation(Permutation&& that);
#endif
    
    Permutation& operator= (Permutation that);

    explicit Permutation(InputStream& in);

    void write(OutputStream& out) const;

   ~Permutation();

    // ------------------------------------ Presentation API.

    int size() const;

    const intCRange perm() const;
    int perm(int n) const;

    const intCRange iperm() const;
    int iperm(int n) const;

    const intCRange swaps() const;
    int swaps(int n) const;

    template<class Number> SparseMatrix<Number> make_SparseMatrix() const;

    void verify() const;   

    // ------------------------------------ Static generators.

    static Permutation identity(int N);

    static Permutation random(int N);

    static Permutation from_perm(const intCRange& perm);
    static Permutation from_iperm(const intCRange& iperm);
    static Permutation from_swaps(const intCRange& swaps);

  private:

    // Internal contents.
    int N;
    std::vector<int> contents;

    // Mutable ranges, used internally.
    const intRange perm();
    const intRange iperm();
    const intRange swaps();
    
  };

std::ostream& operator << (std::ostream& out, const Permutation& P);

// Specializations of Permutation::make_SparseMatrix()
template<> LIBPUBLIC SparseMatrix<NumberS> Permutation::make_SparseMatrix<NumberS>() const;
template<> LIBPUBLIC SparseMatrix<NumberD> Permutation::make_SparseMatrix<NumberD>() const;
template<> LIBPUBLIC SparseMatrix<NumberC> Permutation::make_SparseMatrix<NumberC>() const;
template<> LIBPUBLIC SparseMatrix<NumberZ> Permutation::make_SparseMatrix<NumberZ>() const;

// Rarely needed, note P can present/apply it's own inverse already.
LIBPUBLIC Permutation inverse(const Permutation& P);

LIBPUBLIC void gemm_inplace(const Permutation& P, char op, const MatrixRange<NumberS>& X);
LIBPUBLIC void gemm_inplace(const Permutation& P, char op, const MatrixRange<NumberD>& X);
LIBPUBLIC void gemm_inplace(const Permutation& P, char op, const MatrixRange<NumberC>& X);
LIBPUBLIC void gemm_inplace(const Permutation& P, char op, const MatrixRange<NumberZ>& X);

LIBPUBLIC void gemm_inplace(const Permutation& P, const MatrixRange<NumberS>& X);
LIBPUBLIC void gemm_inplace(const Permutation& P, const MatrixRange<NumberD>& X);
LIBPUBLIC void gemm_inplace(const Permutation& P, const MatrixRange<NumberC>& X);
LIBPUBLIC void gemm_inplace(const Permutation& P, const MatrixRange<NumberZ>& X);

LIBPUBLIC void gemm_inplace(const MatrixRange<NumberS>& X, const Permutation& P, char op);
LIBPUBLIC void gemm_inplace(const MatrixRange<NumberD>& X, const Permutation& P, char op);
LIBPUBLIC void gemm_inplace(const MatrixRange<NumberC>& X, const Permutation& P, char op);
LIBPUBLIC void gemm_inplace(const MatrixRange<NumberZ>& X, const Permutation& P, char op);

LIBPUBLIC void gemm_inplace(const MatrixRange<NumberS>& X, const Permutation& P);
LIBPUBLIC void gemm_inplace(const MatrixRange<NumberD>& X, const Permutation& P);
LIBPUBLIC void gemm_inplace(const MatrixRange<NumberC>& X, const Permutation& P);
LIBPUBLIC void gemm_inplace(const MatrixRange<NumberZ>& X, const Permutation& P);

LIBPUBLIC void gemv_inplace(const Permutation& P, char op, const VectorRange<NumberS>& x);
LIBPUBLIC void gemv_inplace(const Permutation& P, char op, const VectorRange<NumberD>& x);
LIBPUBLIC void gemv_inplace(const Permutation& P, char op, const VectorRange<NumberC>& x);
LIBPUBLIC void gemv_inplace(const Permutation& P, char op, const VectorRange<NumberZ>& x);

LIBPUBLIC void gemv_inplace(const Permutation& P, const VectorRange<NumberS>& x);
LIBPUBLIC void gemv_inplace(const Permutation& P, const VectorRange<NumberD>& x);
LIBPUBLIC void gemv_inplace(const Permutation& P, const VectorRange<NumberC>& x);
LIBPUBLIC void gemv_inplace(const Permutation& P, const VectorRange<NumberZ>& x);

LIBPUBLIC Permutation multiply (const Permutation& P, const Permutation& Q);
LIBPUBLIC Permutation operator* (const Permutation& P, const Permutation& Q);

} // namespace myra

#endif