libsingular4-dev-common 1:4.1.0-p3+ds-2build1 / usr / include / singular / singular / kernel / spectrum / npolygon.h

This file is indexed.

/usr/include/singular/singular/kernel/spectrum/npolygon.h is in libsingular4-dev-common 1:4.1.0-p3+ds-2build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
// ----------------------------------------------------------------------------
//  npolygon.h
//  begin of file
//  Stephan Endrass, endrass@mathematik.uni-mainz.de
//  23.7.99
// ----------------------------------------------------------------------------

#ifndef NPOLYGON_H
#define NPOLYGON_H

#include <kernel/spectrum/GMPrat.h>

// ----------------------------------------------------------------------------
//  Class representing a linear form QQ^N-->QQ
// ----------------------------------------------------------------------------

class linearForm
{

private:

    Rational    *c;                   // the coefficients
    int         N;                    // number of coefficients

public:

    linearForm( );
    linearForm( const linearForm& );
    ~linearForm( );

    linearForm & operator = ( const linearForm& );

    friend  int     operator == ( const linearForm&,const linearForm& );

    void        copy_new     ( int );
    void        copy_delete  ( void );
    void        copy_zero    ( void );
    void        copy_shallow ( linearForm& );
    void        copy_deep    ( const linearForm& );

    Rational    weight       ( poly, const ring r ) const;
    Rational    weight_shift ( poly, const ring r ) const;
    Rational    weight1      ( poly, const ring r ) const;
    Rational    weight_shift1( poly, const ring r ) const;

    Rational    pweight      ( poly, const ring r ) const;

    int         positive     ( void );

    #ifdef  NPOLYGON_PRINT
        friend ostream & operator << ( ostream&,const linearForm& );
    #endif

    friend class newtonPolygon;
};

// ----------------------------------------------------------------------------
//  Class representing a Newton polygon
// ----------------------------------------------------------------------------

class newtonPolygon
{

private:

    linearForm  *l;                   // the linear forms
    int         N;                    // number of linear forms

public:

    newtonPolygon( );
    newtonPolygon( const newtonPolygon& );
    newtonPolygon( poly, const ring r );
    ~newtonPolygon( );

    newtonPolygon & operator = ( const newtonPolygon& );


    void        copy_new    ( int );
    void        copy_delete ( void );
    void        copy_zero   ( void );
    void        copy_shallow( newtonPolygon& );
    void        copy_deep   ( const newtonPolygon& );

    void        add_linearForm( const linearForm& );

    Rational    weight       ( poly, const ring r ) const;
    Rational    weight_shift ( poly, const ring r ) const;
    Rational    weight1      ( poly, const ring r ) const;
    Rational    weight_shift1( poly, const ring r ) const;

    //int         is_sqh     ( void ) const;
    //Rational*   sqh_weights( void ) const;
    //int         sqh_N      ( void ) const;

    #ifdef  NPOLYGON_PRINT
        friend ostream & operator << ( ostream&,const newtonPolygon&  );
    #endif
};

// ---------------------------------------
//  inline functions for class linearForm
// ---------------------------------------

// ----------------------------------------------------------------------------
//  Initialize with zero
// ----------------------------------------------------------------------------

inline  void    linearForm::copy_zero( void )
{
    c = (Rational*)NULL;
    N = 0;
}

// ----------------------------------------------------------------------------
//  Initialize shallow from another linear form
// ----------------------------------------------------------------------------

inline  void    linearForm::copy_shallow( linearForm &l )
{
    c = l.c;
    N = l.N;
}


// ----------------------------------------------------------------------------
//  Zero constructor
// ----------------------------------------------------------------------------

inline  linearForm::linearForm( )
{
    copy_zero( );
}


// ------------------------------------------
//  inline functions for class newtonPolygon
// ------------------------------------------

// ----------------------------------------------------------------------------
//  Initialize with zero
// ----------------------------------------------------------------------------

inline  void    newtonPolygon::copy_zero( void )
{
    l = (linearForm*)NULL;
    N = 0;
}

// ----------------------------------------------------------------------------
//  Initialize shallow from another Newton polygon
// ----------------------------------------------------------------------------

inline  void    newtonPolygon::copy_shallow( newtonPolygon &np )
{
    l = np.l;
    N = np.N;
}


// ----------------------------------------------------------------------------
//  Zero constructor
// ----------------------------------------------------------------------------

inline newtonPolygon::newtonPolygon( )
{
    copy_zero( );
}

#endif /* NPOLYGON_H */

// ----------------------------------------------------------------------------
//  npolygon.h
//  end of file
// ----------------------------------------------------------------------------

APT Browse - Built by Thomas Orozco.