CoCalc -- zass.h

GAP 4.8.9 installation with standard packages -- copy to your CoCalc project to get it
gap4r8 / pkg / carat / carat-2.1b1 / include / zass.h
⁵⁶³⁵⁹⁵ views
1
#ifdef __cplusplus
2
extern "C" {
3
#endif
4

5

6
#ifndef _ZASSEN_H_
7
#define _ZASSEN_H_
8

9
#ifndef _CARAT_TYPEDEF_H_
10
#include"typedef.h"
11
#endif
12

13
int INFO_LEVEL;
14

15
typedef struct {
16
       long last;
17
       long speicher;
18
       long faktor;
19
       long *pointer;} word;
20

21

22
#ifdef __STDC__
23

24

25
/**********************************************************************\
26
| FILE: cobundary.c
27
\**********************************************************************/
28

29
void coboundary(bravais_TYP *G,
30
                matrix_TYP *C,
31
                matrix_TYP *T);
32

33
/**********************************************************************\
34
| FILE: cong_solve.c
35
\**********************************************************************/
36

37
matrix_TYP **cong_solve(matrix_TYP *A);
38

39
/**********************************************************************\
40
| FILE: convert_cocycle_to_column.c
41
\**********************************************************************/
42

43
void convert_cocycle_to_column(matrix_TYP **Y,
44
                               int number,
45
                               int dim,
46
                               int gen_no);
47

48
/**********************************************************************\
49
| FILE: convert_to_cozycle.c
50
\**********************************************************************/
51

52
extern matrix_TYP *convert_to_cozycle(matrix_TYP *x,
53
                                      matrix_TYP *cozycle,
54
                                      matrix_TYP *D);
55

56
/**********************************************************************\
57
| FILE: put_cocycle.c
58
\**********************************************************************/
59

60
void put_cocycle(matrix_TYP *COZ,
61
                 int dim,
62
                 int number,
63
                 char *file,
64
                 char *comment);
65

66
/*********************************************************************\
67
| FILE: normalop.c
68
\*********************************************************************/
69

70
extern matrix_TYP *normalop(matrix_TYP *cozycle,
71
                            matrix_TYP *D,
72
                            matrix_TYP *R,
73
                            bravais_TYP *G,
74
                            matrix_TYP *N,
75
                            int opt);
76

77
extern matrix_TYP **extensions(matrix_TYP *cozycle,
78
                               matrix_TYP *D,
79
                               matrix_TYP *R,
80
                               bravais_TYP *G,
81
                               int **lengths,
82
                               MP_INT **names,
83
                               int *number_of_orbits,
84
                               int option);
85

86
extern void no_of_extensions(matrix_TYP *cozycle,matrix_TYP *D,
87
                        matrix_TYP *R,bravais_TYP *G,MP_INT *no);
88

89
extern matrix_TYP **identify(matrix_TYP *cozycle,
90
                             matrix_TYP *D,
91
                             matrix_TYP *R,
92
                             bravais_TYP *G,
93
                             matrix_TYP **extension,
94
                             MP_INT *a,int number,
95
                             int transform_flag,
96
                             int ***WORDS,
97
                             int *NUMBER_OF_WORDS);
98

99
extern void translation(matrix_TYP *TR,
100
                        matrix_TYP *rep,
101
                        matrix_TYP *ext,
102
                        matrix_TYP *cocycle,
103
                        matrix_TYP *D,
104
                        bravais_TYP *G);
105

106
extern void valuation(matrix_TYP *x,matrix_TYP *D,MP_INT *val);
107

108
extern matrix_TYP *orbit_rep(matrix_TYP *x,
109
                             matrix_TYP **N,
110
                             int nanz,
111
                             matrix_TYP *D,
112
                             int option,
113
                             char *B,
114
                             MP_INT *l,
115
                             int *anz,
116
                             int **word,
117
                             int word_flag,
118
                             int ***WORDS,
119
                             int *NUMBER_OF_WORDS);
120

121
/**********************************************************************\
122
| FILE: reverse_valuation.c
123
\**********************************************************************/
124

125
extern matrix_TYP *reverse_valuation(MP_INT *val,matrix_TYP *D);
126

127
/**********************************************************************\
128
| FILE: reget_gen.c
129
\**********************************************************************/
130

131
extern matrix_TYP *reget_gen(matrix_TYP **map,int number,bravais_TYP *G,
132
                             int **words, int word_flag);
133

134

135
/**********************************************************************\
136
| FILE: zass.c
137
\**********************************************************************/
138

139
extern matrix_TYP *matrizen_in_word(matrix_TYP **mat,
140
                                    matrix_TYP **matinv,
141
                                    word g);
142

143
extern void matrix_2_word(matrix_TYP *matrix,
144
                          word *relator,
145
                          long zeile);
146

147
extern matrix_TYP **cohomology(long *dim,
148
                               matrix_TYP **mat,
149
                               matrix_TYP **matinv,
150
                               word *relator,
151
                               int erzeuger,
152
                               int relatoren);
153

154
extern int wordfree(word *a);
155

156
extern matrix_TYP *scalar(long n,
157
                          long a);
158

159
extern matrix_TYP *calc_B(matrix_TYP **mat,
160
                          long anz_erzeuger);
161

162
#else
163

164

165
/**********************************************************************\
166
| FILE: cobundary.c
167
\**********************************************************************/
168

169
void coboundary();
170

171
/**********************************************************************\
172
| FILE: cong_solve.c
173
\**********************************************************************/
174

175
matrix_TYP **cong_solve();
176

177

178
/**********************************************************************\
179
| FILE: convert_cocycle_to_column.c
180
\**********************************************************************/
181

182
void convert_cocycle_to_column();
183

184
/**********************************************************************\
185
| FILE: convert_to_cozycle.c
186
\**********************************************************************/
187

188
extern matrix_TYP *convert_to_cozycle();
189

190

191
/**********************************************************************\
192
| FILE: put_cocycle.c
193
\**********************************************************************/
194

195
void put_cocycle();
196

197
/*********************************************************************\
198
| FILE: normalop.c
199
\*********************************************************************/
200

201
extern matrix_TYP *normalop();
202

203
extern matrix_TYP **extensions();
204

205
extern void no_of_extensions();
206

207
extern matrix_TYP **identify();
208

209
extern void translation();
210

211
extern void valuation();
212

213
extern matrix_TYP *orbit_rep();
214
                   
215

216
/**********************************************************************\
217
| FILE: reverse_valuation.c
218
\**********************************************************************/
219

220
extern matrix_TYP *reverse_valuation();
221

222
/**********************************************************************\
223
| FILE: reget_gen.c
224
\**********************************************************************/
225

226
extern matrix_TYP *reget_gen();
227

228
/**********************************************************************\
229
| FILE: zass.c
230
\**********************************************************************/
231

232
extern matrix_TYP *matrizen_in_word();
233

234
extern void matrix_2_word();
235

236
extern matrix_TYP **cohomology();
237

238
extern int wordfree();
239

240
extern matrix_TYP *scalar();
241

242
extern matrix_TYP *calc_B();
243

244
#endif
245
#endif
246

247

248
#ifdef __cplusplus
249
}
250
#endif
251

252

253
Product

Resources

Company
