texout.hpp

Go to the documentation of this file.

/*****************************************************************************
    
    texout.hpp -- routines for output in LaTeX.

    This file is a part of the Arageli library.

    Copyright (C) Nikolai Yu. Zolotykh, 1999--2006
    Copyright (C) Sergey S. Lyalin, 2005
    University of Nizhni Novgorod, Russia

*****************************************************************************/

#ifndef _ARAGELI_texout_hpp_
#define _ARAGELI_texout_hpp_

#include "config.hpp"

#include <cstddef>
#include <iostream>
#include <sstream>

#include "big_int.hpp"
#include "rational.hpp"
#include "vector.hpp"
#include "matrix.hpp"
#include "sparse_polynom.hpp"

#include "std_import.hpp"


namespace Arageli
{


enum ex_environ_priority
{
    eep_alone,  
    eep_add,    
    eep_mul     
};


template <typename Out, typename T>
inline void output_latex_verb
(
    Out& out,
    const T& x,
    bool in_math = false,
    ex_environ_priority eep = eep_alone
)
{ out << "\\verb\"" << x << '"'; }


template <typename Out, typename T>
inline void output_latex
(
    Out& out,
    const T& x,
    bool in_math = false,
    ex_environ_priority eep = eep_alone
)
{ output_latex_verb(out, x, in_math, eep); }


template <typename Out, typename T>
inline void output_latex_math
(
    Out& out,
    const T& x,
    bool in_math = false,
    ex_environ_priority eep = eep_alone
)
{
    if(!in_math)out << '$' << x << '$';
    else out << x;
}


#define ARAGELI_TEXOUT_NUMBER(TYPE)                 \
    template <typename Out>                         \
    inline void output_latex                        \
    (                                               \
        Out& out,                                   \
        const TYPE& x,                              \
        bool in_math = false,                       \
        ex_environ_priority eep = eep_alone         \
    )                                               \
    { output_latex_math(out, x, in_math, eep); }



ARAGELI_TEXOUT_NUMBER(signed int)
ARAGELI_TEXOUT_NUMBER(unsigned int)
ARAGELI_TEXOUT_NUMBER(signed short int)
ARAGELI_TEXOUT_NUMBER(unsigned short int)
ARAGELI_TEXOUT_NUMBER(signed long int)
ARAGELI_TEXOUT_NUMBER(unsigned long int)
ARAGELI_TEXOUT_NUMBER(float)
ARAGELI_TEXOUT_NUMBER(double)
ARAGELI_TEXOUT_NUMBER(long double)
ARAGELI_TEXOUT_NUMBER(big_int)

#ifdef ARAGELI_INT64_SUPPORT
    ARAGELI_TEXOUT_NUMBER(signed __int64)
    ARAGELI_TEXOUT_NUMBER(unsigned __int64)
#endif

#ifdef ARAGELI_LONG_LONG_SUPPORT
    ARAGELI_TEXOUT_NUMBER(signed long long)
    ARAGELI_TEXOUT_NUMBER(unsigned long long)
#endif


#undef ARAGELI_TEXOUT_NUMBER



template <typename Out, typename T>
void output_latex
(
    Out& out,
    const rational<T>& x,
    bool in_math,
    ex_environ_priority eep,
    std::size_t minlensimple,
    bool externsign = true
);

template <typename Out, typename T>
inline void output_latex
(
    Out& out,
    const rational<T>& x,
    bool in_math,
    ex_environ_priority eep
)
{ return output_latex(out, x, in_math, eep, 3, true); }

template <typename Out, typename T>
inline void output_latex
(
    Out& out,
    const rational<T>& x,
    bool in_math
)
{ return output_latex(out, x, in_math, eep_alone, 3, true); }

template <typename Out, typename T>
inline void output_latex
(
    Out& out,
    const rational<T>& x
)
{ return output_latex(out, x, false, eep_alone, 3, true); }

template <typename Out, typename T, bool REFCNT>
void output_latex
(
    Out& out,
    const vector<T, REFCNT>& x,
    bool in_math,
    ex_environ_priority eep,
    bool hor,   // if true, the function produces horizontal output, otherwise is vertical
    const char* first_bracket = "(",
    const char* second_bracket = ")",
    const char* delim = ","
);

template <typename Out, typename T, bool REFCNT>
inline void output_latex
(
    Out& out,
    const vector<T, REFCNT>& x,
    bool in_math,
    ex_environ_priority eep
)
{
    // WARNING! See the default arguments in original function.
    output_latex(out, x, in_math, eep, true, "(", ")", ",");
}

template <typename Out, typename T, bool REFCNT>
inline void output_latex
(
    Out& out,
    const vector<T, REFCNT>& x,
    bool in_math
)
{
    // WARNING! See the default arguments in original function.
    output_latex(out, x, in_math, eep_alone, true, "(", ")", ",");
}

template <typename Out, typename T, bool REFCNT>
inline void output_latex
(
    Out& out,
    const vector<T, REFCNT>& x
)
{
    // WARNING! See the default arguments in original function.
    output_latex(out, x, false, eep_alone, true, "(", ")", ",");
}

template <typename Out, typename T, bool REFCNT>
void output_latex
(
    Out& out,
    const matrix<T, REFCNT>& x,
    bool in_math,
    ex_environ_priority eep,
    bool transposed,
    const char* first_bracket = "(",
    const char* second_bracket = ")"
);


template <typename Out, typename T, bool REFCNT>
inline void output_latex
(
    Out& out,
    const matrix<T, REFCNT>& x
)
{
    // WARNING! See the default values for brackets in main function.
    output_latex(out, x, false, eep_alone, false, "(", ")");
}


template <typename Out, typename T, bool REFCNT>
inline void output_latex
(
    Out& out,
    const matrix<T, REFCNT>& x,
    bool in_math
)
{
    // WARNING! See the default values for brackets in main function.
    output_latex(out, x, in_math, eep_alone, false, "(", ")");
}


template <typename Out, typename T, bool REFCNT>
inline void output_latex
(
    Out& out,
    const matrix<T, REFCNT>& x,
    bool in_math,
    ex_environ_priority eep
)
{
    // WARNING! See the default values for brackets in main function.
    output_latex(out, x, in_math, eep, false, "(", ")");
}


template <typename Out, typename F, typename I>
void output_latex
(
    Out& out,
    const monom<F, I>& x,
    bool in_math,
    ex_environ_priority eep,
    bool first,
    const char* var = "x"
);

template <typename Out, typename F, typename I>
inline void output_latex
(
    Out& out,
    const monom<F, I>& x,
    bool in_math,
    ex_environ_priority eep
)
{ return output_latex(out, x, in_math, eep, true, "x"); }

template <typename Out, typename F, typename I>
inline void output_latex
(
    Out& out,
    const monom<F, I>& x,
    bool in_math
)
{ return output_latex(out, x, in_math, eep_alone, true, "x"); }

template <typename Out, typename F, typename I>
inline void output_latex
(
    Out& out,
    const monom<F, I>& x
)
{ return output_latex(out, x, false, eep_alone, true, "x"); }

template <typename Out, typename F, typename I, bool REFCNT>
void output_latex
(
    Out& out,
    const sparse_polynom<F, I, REFCNT>& x,
    bool in_math,
    ex_environ_priority eep,
    const char* var
);

template <typename Out, typename F, typename I, bool REFCNT>
inline void output_latex
(
    Out& out,
    const sparse_polynom<F, I, REFCNT>& x,
    bool in_math,
    ex_environ_priority eep
)
{ return output_latex(out, x, in_math, eep, "x"); }

template <typename Out, typename F, typename I, bool REFCNT>
inline void output_latex
(
    Out& out,
    const sparse_polynom<F, I, REFCNT>& x,
    bool in_math
)
{ return output_latex(out, x, in_math, eep_alone, "x"); }

template <typename Out, typename F, typename I, bool REFCNT>
inline void output_latex
(
    Out& out,
    const sparse_polynom<F, I, REFCNT>& x
)
{ return output_latex(out, x, false, eep_alone, "x"); }


// -------------------------------

enum matrix_line_type
{
    mlt_solid,  
    mlt_dot,    
    mlt_hatch,  
    mlt_chain   
};


struct matrix_line
{
    matrix_line () {}
    
    matrix_line (std::size_t pos_a, matrix_line_type mlt_a = mlt_solid)
    : pos(pos_a), mlt(mlt_a) {}

    std::size_t pos;    
    matrix_line_type mlt;   
};



struct matrix_box
{
    matrix_box () {}
    
    matrix_box (std::size_t row_a, std::size_t col_a, matrix_line_type mlt_a = mlt_solid)
    : row(row_a), col(col_a), mlt(mlt_a) {}

    std::size_t
        row,    
        col;    
    matrix_line_type mlt;   
};


template
<
    typename In_hor = const matrix_line*,
    typename In_ver = const matrix_line*,
    typename In_box = const matrix_box*
>
struct matrix_frames
{
    matrix_frames
    (
        In_hor hf = 0, In_hor hl = 0,
        In_ver vf = 0, In_ver vl = 0,
        In_box bf = 0, In_box bl = 0
    )
    :   hors_first(hf), hors_last(hl),
        vers_first(vf), vers_last(vl),
        boxes_first(bf), boxes_last(bl)
    {}
    
    In_hor
        hors_first, 
        hors_last;  
    In_ver
        vers_first, 
        vers_last;  
    In_box
        boxes_first,    
        boxes_last; 
};



// @{

template <typename In_hor, typename In_ver, typename In_box>
inline matrix_frames<In_hor, In_ver, In_box> make_matrix_frames
(
    In_hor hf, In_hor hl,
    In_ver vf, In_ver vl,
    In_box bf, In_box bl
)
{ return matrix_frames<In_hor, In_ver, In_box>(hf, hl, vf, vl, bf, bl); }


template <typename In_hor, typename In_ver>
inline matrix_frames<In_hor, In_ver> make_matrix_frames
(
    In_hor hf, In_hor hl,
    In_ver vf, In_ver vl
)
{ return matrix_frames<In_hor, In_ver>(hf, hl, vf, vl); }


template <typename In_hor>
inline matrix_frames<In_hor> make_matrix_frames
(
    In_hor hf, In_hor hl
)
{ return matrix_frames<In_hor>(hf, hl); }


inline matrix_frames<> make_matrix_frames ()
{ return matrix_frames<>(); }


template <typename In_ver>
inline matrix_frames<const matrix_line*, In_ver> make_matrix_vers
(
    In_ver vf, In_ver vl
)
{ return matrix_frames<const matrix_line*, In_ver>(0, 0, vf, vl); }


template <typename In_box>
inline matrix_frames<const matrix_line*, const matrix_line*, In_box>
make_matrix_boxes
(
    In_box bf, In_box bl
)
{
    return matrix_frames<const matrix_line*, const matrix_line*, In_box>
        (0, 0, 0, 0, bf, bl);
}


template <typename In_ver, typename In_box>
inline matrix_frames<const matrix_line*, In_ver, In_box> make_matrix_vers_boxes
(
    In_ver vf, In_ver vl,
    In_box bf, In_box bl
)
{
    return matrix_frames<const matrix_line*, In_ver, In_box>
        (0, 0, vf, vl, bf, bl);

}



template
<
    typename T, bool REFCNT, typename Ch, typename ChT,
    typename In_hor, typename In_ver, typename In_box
>
void output_latex_matrix_frames
(
    std::basic_ostream<Ch, ChT>& out,
    const matrix<T, REFCNT>& x,
    const matrix_frames<In_hor, In_ver, In_box>& mf,
    bool in_math = false,
    bool transposed = false,
    const char* first_bracket = "(",
    const char* second_bracket = ")"
);

}


#ifdef ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE
    #define ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_TEXOUT
    #include "texout.cpp"
    #undef  ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_TEXOUT
#endif


#endif  //  #ifndef _ARAGELI_texout_hpp_

---