1 //============================================================================================== 2 // 3 // This file is part of LiDIA --- a library for computational number theory 4 // 5 // Copyright (c) 1994--2001 the LiDIA Group. All rights reserved. 6 // 7 // See http://www.informatik.tu-darmstadt.de/TI/LiDIA/ 8 // 9 //---------------------------------------------------------------------------------------------- 10 // 11 // $Id$ 12 // 13 // Author : Patrick Theobald (PT) 14 // Changes : See CVS log 15 // 16 //============================================================================================== 17 18 19 // 20 // usage: 21 // 22 // include all headers that are necessary to describe the type TYPE 23 // 24 // define the type TYPE 25 // 26 // define either NORMAL, DENSE, SPARSE, or SUBCLASSES 27 // 28 // define either BASE_MATRIX, RING_MATRIX, or FIELD_MATRIX 29 // 30 // include this file 31 // 32 33 34 #ifdef BASE_MATRIX 35 36 # ifdef SUBCLASSES 37 # include "LiDIA/base_matrix.h" 38 # include "LiDIA/base_matrix.cc" 39 # include "LiDIA/matrix/base_matrix_algorithms.h" 40 # include "LiDIA/matrix/base_matrix_algorithms.cc" 41 # include "LiDIA/matrix/dense_base_matrix_kernel.h" 42 # include "LiDIA/matrix/dense_base_matrix_kernel.cc" 43 # include "LiDIA/matrix/sparse_base_matrix_kernel.h" 44 # include "LiDIA/matrix/sparse_base_matrix_kernel.cc" 45 46 # define DBMKex DBMK< TYPE > 47 # define SBMKex SBMK< TYPE > 48 49 50 51 # ifdef LIDIA_NAMESPACE 52 namespace LiDIA { 53 # endif 54 55 56 57 template class DBMKex; 58 template class SBMKex; 59 60 template class BMA< TYPE, DBMKex, DBMKex >; 61 template class BMA< TYPE, DBMKex, SBMKex >; 62 template class BMA< TYPE, SBMKex, DBMKex >; 63 template class BMA< TYPE, SBMKex, SBMKex >; 64 65 66 67 # ifdef LIDIA_NAMESPACE 68 } // end of namespace LiDIA 69 # endif 70 71 # undef DBMKex 72 # undef SBMKex 73 74 # endif // SUBCLASSES 75 76 77 78 # ifdef NORMAL 79 # include "LiDIA/base_matrix.h" 80 # include "LiDIA/base_matrix.cc" 81 # include "LiDIA/matrix/base_matrix_algorithms.h" 82 # include "LiDIA/matrix/base_matrix_algorithms.cc" 83 # include "LiDIA/matrix/dense_base_matrix_kernel.h" 84 # include "LiDIA/matrix/dense_base_matrix_kernel.cc" 85 # include "LiDIA/matrix/sparse_base_matrix_kernel.h" 86 # include "LiDIA/matrix/sparse_base_matrix_kernel.cc" 87 88 # ifdef LIDIA_NAMESPACE 89 namespace LiDIA { 90 # endif 91 92 93 94 template class base_matrix< TYPE >; 95 96 template std::ostream & operator << (std::ostream &, const base_matrix< TYPE > &); 97 template std::istream & operator >> (std::istream &, base_matrix< TYPE > &); 98 template void swap(base_matrix< TYPE > &, base_matrix< TYPE > &); 99 template void assign(base_matrix< TYPE > &, const base_matrix< TYPE > &); 100 template void diag(base_matrix< TYPE > &, const TYPE &, const TYPE &); 101 template void trans(base_matrix< TYPE > &, const base_matrix< TYPE > &); 102 template base_matrix< TYPE > trans(const base_matrix< TYPE > &); 103 104 105 106 # ifdef LIDIA_NAMESPACE 107 } // end of namespace LiDIA 108 # endif 109 110 # endif // NORMAL 111 112 113 114 # ifdef DENSE 115 # include "LiDIA/dense_base_matrix.h" 116 # include "LiDIA/dense_base_matrix.cc" 117 # include "LiDIA/matrix/base_matrix_algorithms.h" 118 # include "LiDIA/matrix/base_matrix_algorithms.cc" 119 # include "LiDIA/matrix/dense_base_matrix_kernel.h" 120 # include "LiDIA/matrix/dense_base_matrix_kernel.cc" 121 122 # ifdef LIDIA_NAMESPACE 123 namespace LiDIA { 124 # endif 125 126 127 128 template class dense_base_matrix< TYPE >; 129 130 template std::ostream & operator << (std::ostream &, const dense_base_matrix< TYPE > &); 131 template std::istream & operator >> (std::istream &, dense_base_matrix< TYPE > &); 132 template void swap(dense_base_matrix< TYPE > &, dense_base_matrix< TYPE > &); 133 template void assign(dense_base_matrix< TYPE > &, const dense_base_matrix< TYPE > &); 134 template void diag(dense_base_matrix< TYPE > &, const TYPE &, const TYPE &); 135 template void trans(dense_base_matrix< TYPE > &, const dense_base_matrix< TYPE > &); 136 template dense_base_matrix< TYPE > trans(const dense_base_matrix< TYPE > &); 137 138 139 140 # ifdef LIDIA_NAMESPACE 141 } // end of namespace LiDIA 142 # endif 143 144 # endif // DENSE 145 146 147 148 # ifdef SPARSE 149 # include "LiDIA/sparse_base_matrix.h" 150 # include "LiDIA/sparse_base_matrix.cc" 151 # include "LiDIA/matrix/base_matrix_algorithms.h" 152 # include "LiDIA/matrix/base_matrix_algorithms.cc" 153 # include "LiDIA/matrix/sparse_base_matrix_kernel.h" 154 # include "LiDIA/matrix/sparse_base_matrix_kernel.cc" 155 156 # ifdef LIDIA_NAMESPACE 157 namespace LiDIA { 158 # endif 159 160 161 162 template class sparse_base_matrix< TYPE >; 163 164 template std::ostream & operator << (std::ostream &, const sparse_base_matrix< TYPE > &); 165 template std::istream & operator >> (std::istream &, sparse_base_matrix< TYPE > &); 166 template void swap(sparse_base_matrix< TYPE > &, sparse_base_matrix< TYPE > &); 167 template void assign(sparse_base_matrix< TYPE > &, const sparse_base_matrix< TYPE > &); 168 template void diag(sparse_base_matrix< TYPE > &, const TYPE &, const TYPE &); 169 template void trans(sparse_base_matrix< TYPE > &, const sparse_base_matrix< TYPE > &); 170 template sparse_base_matrix< TYPE > trans(const sparse_base_matrix< TYPE > &); 171 172 173 174 # ifdef LIDIA_NAMESPACE 175 } // end of namespace LiDIA 176 # endif 177 178 # endif // SPARSE 179 180 #endif // BASE_MATRIX 181 182 183 184 #ifdef RING_MATRIX 185 186 # ifdef SUBCLASSES 187 # include "LiDIA/ring_matrix.h" 188 # include "LiDIA/ring_matrix.cc" 189 # include "LiDIA/matrix/ring_matrix_algorithms.h" 190 # include "LiDIA/matrix/ring_matrix_algorithms.cc" 191 # include "LiDIA/matrix/dense_ring_matrix_kernel.h" 192 # include "LiDIA/matrix/dense_ring_matrix_kernel.cc" 193 # include "LiDIA/matrix/sparse_ring_matrix_kernel.h" 194 # include "LiDIA/matrix/sparse_ring_matrix_kernel.cc" 195 196 # define DRMKex DRMK< TYPE > 197 # define SRMKex SRMK< TYPE > 198 199 # ifdef LIDIA_NAMESPACE 200 namespace LiDIA { 201 # endif 202 203 204 205 template class DRMKex; 206 template class SRMKex; 207 208 template class RMA< TYPE, DRMKex, DRMKex, DRMKex >; 209 template class RMA< TYPE, DRMKex, DRMKex, SRMKex >; 210 template class RMA< TYPE, DRMKex, SRMKex, DRMKex >; 211 template class RMA< TYPE, SRMKex, DRMKex, DRMKex >; 212 template class RMA< TYPE, DRMKex, SRMKex, SRMKex >; 213 template class RMA< TYPE, SRMKex, DRMKex, SRMKex >; 214 template class RMA< TYPE, SRMKex, SRMKex, DRMKex >; 215 template class RMA< TYPE, SRMKex, SRMKex, SRMKex >; 216 217 218 219 # ifdef LIDIA_NAMESPACE 220 } // end of namespace LiDIA 221 # endif 222 223 # undef DRMKex 224 # undef SRMKex 225 226 # endif // SUBCLASSES 227 228 229 230 # ifdef NORMAL 231 # include "LiDIA/ring_matrix.h" 232 # include "LiDIA/ring_matrix.cc" 233 # include "LiDIA/matrix/ring_matrix_algorithms.h" 234 # include "LiDIA/matrix/ring_matrix_algorithms.cc" 235 # include "LiDIA/matrix/dense_ring_matrix_kernel.h" 236 # include "LiDIA/matrix/dense_ring_matrix_kernel.cc" 237 # include "LiDIA/matrix/sparse_ring_matrix_kernel.h" 238 # include "LiDIA/matrix/sparse_ring_matrix_kernel.cc" 239 240 # ifdef LIDIA_NAMESPACE 241 namespace LiDIA { 242 # endif 243 244 245 246 template class ring_matrix< TYPE >; 247 248 template void add(ring_matrix< TYPE > &, const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 249 template void add(ring_matrix< TYPE > &, const ring_matrix< TYPE > &, const TYPE &); 250 template void add(ring_matrix< TYPE > &, const TYPE &, const ring_matrix< TYPE > &); 251 template void subtract(ring_matrix< TYPE > &, const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 252 template void subtract(ring_matrix< TYPE > &, const ring_matrix< TYPE > &, const TYPE &); 253 template void subtract(ring_matrix< TYPE > &, const TYPE &, const ring_matrix< TYPE > &); 254 template void multiply(ring_matrix< TYPE > &, const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 255 template void multiply(ring_matrix< TYPE > &, const ring_matrix< TYPE > &, const TYPE &); 256 template void multiply(ring_matrix< TYPE > &, const TYPE &, const ring_matrix< TYPE > &); 257 template void compwise_multiply(ring_matrix< TYPE > &, const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 258 template void multiply(TYPE *&, const ring_matrix< TYPE > &, const TYPE *); 259 template void multiply(TYPE *&, const TYPE *, const ring_matrix< TYPE > &); 260 template void multiply(math_vector< TYPE > &, const ring_matrix< TYPE > &, const math_vector< TYPE > &); 261 template void multiply(math_vector< TYPE > &, const math_vector< TYPE > &, const ring_matrix< TYPE > &); 262 template void negate(ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 263 template ring_matrix< TYPE > operator + (const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 264 template ring_matrix< TYPE > operator + (const ring_matrix< TYPE > &, const TYPE &); 265 template ring_matrix< TYPE > operator + (const TYPE &, const ring_matrix< TYPE > &); 266 template ring_matrix< TYPE > & operator += (ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 267 template ring_matrix< TYPE > & operator += (ring_matrix< TYPE > &, const TYPE &); 268 template ring_matrix< TYPE > operator - (const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 269 template ring_matrix< TYPE > operator - (const ring_matrix< TYPE > &, const TYPE &); 270 template ring_matrix< TYPE > operator - (const TYPE &, const ring_matrix< TYPE > &); 271 template ring_matrix< TYPE > & operator -= (ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 272 template ring_matrix< TYPE > & operator -= (ring_matrix< TYPE > &, const TYPE &); 273 template ring_matrix< TYPE > operator * (const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 274 template ring_matrix< TYPE > operator * (const ring_matrix< TYPE > &, const TYPE &); 275 template ring_matrix< TYPE > operator * (const TYPE &, const ring_matrix< TYPE > &); 276 template TYPE * operator * (const ring_matrix< TYPE > &, const TYPE *); 277 template TYPE * operator * (const TYPE *, const ring_matrix< TYPE > &); 278 template math_vector< TYPE > operator * (const ring_matrix< TYPE > &, const math_vector< TYPE > &); 279 template math_vector< TYPE > operator * (const math_vector< TYPE > &, const ring_matrix< TYPE > &); 280 template ring_matrix< TYPE > & operator *= (ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 281 template ring_matrix< TYPE > & operator *= (ring_matrix< TYPE > &, const TYPE &); 282 template ring_matrix< TYPE > operator - (const ring_matrix< TYPE > &); 283 template bool operator == (const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 284 template bool equal(const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 285 template bool operator != (const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 286 template bool unequal(const ring_matrix< TYPE > &, const ring_matrix< TYPE > &); 287 template TYPE trace(const ring_matrix< TYPE > &); 288 289 template class MR< TYPE >; 290 291 292 293 # ifdef LIDIA_NAMESPACE 294 } // end of namespace LiDIA 295 # endif 296 297 # endif // NORMAL 298 299 300 301 # ifdef DENSE 302 # include "LiDIA/dense_ring_matrix.h" 303 # include "LiDIA/dense_ring_matrix.cc" 304 # include "LiDIA/matrix/dense_ring_matrix_kernel.h" 305 # include "LiDIA/matrix/dense_ring_matrix_kernel.cc" 306 307 # ifdef LIDIA_NAMESPACE 308 namespace LiDIA { 309 # endif 310 311 312 313 template class dense_ring_matrix< TYPE >; 314 315 template void add(dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 316 template void add(dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &, const TYPE &); 317 template void add(dense_ring_matrix< TYPE > &, const TYPE &, const dense_ring_matrix< TYPE > &); 318 template void subtract(dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 319 template void subtract(dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &, const TYPE &); 320 template void subtract(dense_ring_matrix< TYPE > &, const TYPE &, const dense_ring_matrix< TYPE > &); 321 template void multiply(dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 322 template void multiply(dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &, const TYPE &); 323 template void multiply(dense_ring_matrix< TYPE > &, const TYPE &, const dense_ring_matrix< TYPE > &); 324 template void compwise_multiply(dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 325 template void multiply(TYPE *&, const dense_ring_matrix< TYPE > &, const TYPE *); 326 template void multiply(TYPE *&, const TYPE *, const dense_ring_matrix< TYPE > &); 327 template void multiply(math_vector< TYPE > &, const dense_ring_matrix< TYPE > &, const math_vector< TYPE > &); 328 template void multiply(math_vector< TYPE > &, const math_vector< TYPE > &, const dense_ring_matrix< TYPE > &); 329 template void negate(dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 330 template dense_ring_matrix< TYPE > operator + (const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 331 template dense_ring_matrix< TYPE > operator + (const dense_ring_matrix< TYPE > &, const TYPE &); 332 template dense_ring_matrix< TYPE > operator + (const TYPE &, const dense_ring_matrix< TYPE > &); 333 template dense_ring_matrix< TYPE > & operator += (dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 334 template dense_ring_matrix< TYPE > & operator += (dense_ring_matrix< TYPE > &, const TYPE &); 335 template dense_ring_matrix< TYPE > operator - (const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 336 template dense_ring_matrix< TYPE > operator - (const dense_ring_matrix< TYPE > &, const TYPE &); 337 template dense_ring_matrix< TYPE > operator - (const TYPE &, const dense_ring_matrix< TYPE > &); 338 template dense_ring_matrix< TYPE > & operator -= (dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 339 template dense_ring_matrix< TYPE > & operator -= (dense_ring_matrix< TYPE > &, const TYPE &); 340 template dense_ring_matrix< TYPE > operator * (const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 341 template dense_ring_matrix< TYPE > operator * (const dense_ring_matrix< TYPE > &, const TYPE &); 342 template dense_ring_matrix< TYPE > operator * (const TYPE &, const dense_ring_matrix< TYPE > &); 343 template TYPE * operator * (const dense_ring_matrix< TYPE > &, const TYPE *); 344 template TYPE * operator * (const TYPE *, const dense_ring_matrix< TYPE > &); 345 template math_vector< TYPE > operator * (const dense_ring_matrix< TYPE > &, const math_vector< TYPE > &); 346 template math_vector< TYPE > operator * (const math_vector< TYPE > &, const dense_ring_matrix< TYPE > &); 347 template dense_ring_matrix< TYPE > & operator *= (dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 348 template dense_ring_matrix< TYPE > & operator *= (dense_ring_matrix< TYPE > &, const TYPE &); 349 template dense_ring_matrix< TYPE > operator - (const dense_ring_matrix< TYPE > &); 350 template bool operator == (const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 351 template bool equal(const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 352 template bool operator != (const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 353 template bool unequal(const dense_ring_matrix< TYPE > &, const dense_ring_matrix< TYPE > &); 354 template TYPE trace(const dense_ring_matrix< TYPE > &); 355 356 357 358 # ifdef LIDIA_NAMESPACE 359 } // end of namespace LiDIA 360 # endif 361 362 # endif // DENSE 363 364 365 366 # ifdef SPARSE 367 # include "LiDIA/sparse_ring_matrix.h" 368 # include "LiDIA/sparse_ring_matrix.cc" 369 # include "LiDIA/matrix/ring_matrix_algorithms.h" 370 # include "LiDIA/matrix/ring_matrix_algorithms.cc" 371 # include "LiDIA/matrix/sparse_ring_matrix_kernel.h" 372 # include "LiDIA/matrix/sparse_ring_matrix_kernel.cc" 373 374 # ifdef LIDIA_NAMESPACE 375 namespace LiDIA { 376 # endif 377 378 379 380 template class sparse_ring_matrix< TYPE >; 381 382 template void add(sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 383 template void add(sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &, const TYPE &); 384 template void add(sparse_ring_matrix< TYPE > &, const TYPE &, const sparse_ring_matrix< TYPE > &); 385 template void subtract(sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 386 template void subtract(sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &, const TYPE &); 387 template void subtract(sparse_ring_matrix< TYPE > &, const TYPE &, const sparse_ring_matrix< TYPE > &); 388 template void multiply(sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 389 template void multiply(sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &, const TYPE &); 390 template void multiply(sparse_ring_matrix< TYPE > &, const TYPE &, const sparse_ring_matrix< TYPE > &); 391 template void compwise_multiply(sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 392 template void multiply(TYPE *&, const sparse_ring_matrix< TYPE > &, const TYPE *); 393 template void multiply(TYPE *&, const TYPE *, const sparse_ring_matrix< TYPE > &); 394 template void multiply(math_vector< TYPE > &, const sparse_ring_matrix< TYPE > &, const math_vector< TYPE > &); 395 template void multiply(math_vector< TYPE > &, const math_vector< TYPE > &, const sparse_ring_matrix< TYPE > &); 396 template void negate(sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 397 template sparse_ring_matrix< TYPE > operator + (const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 398 template sparse_ring_matrix< TYPE > operator + (const sparse_ring_matrix< TYPE > &, const TYPE &); 399 template sparse_ring_matrix< TYPE > operator + (const TYPE &, const sparse_ring_matrix< TYPE > &); 400 template sparse_ring_matrix< TYPE > & operator += (sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 401 template sparse_ring_matrix< TYPE > & operator += (sparse_ring_matrix< TYPE > &, const TYPE &); 402 template sparse_ring_matrix< TYPE > operator - (const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 403 template sparse_ring_matrix< TYPE > operator - (const sparse_ring_matrix< TYPE > &, const TYPE &); 404 template sparse_ring_matrix< TYPE > operator - (const TYPE &, const sparse_ring_matrix< TYPE > &); 405 template sparse_ring_matrix< TYPE > & operator -= (sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 406 template sparse_ring_matrix< TYPE > & operator -= (sparse_ring_matrix< TYPE > &, const TYPE &); 407 template sparse_ring_matrix< TYPE > operator * (const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 408 template sparse_ring_matrix< TYPE > operator * (const sparse_ring_matrix< TYPE > &, const TYPE &); 409 template sparse_ring_matrix< TYPE > operator * (const TYPE &, const sparse_ring_matrix< TYPE > &); 410 template TYPE * operator * (const sparse_ring_matrix< TYPE > &, const TYPE *); 411 template TYPE * operator * (const TYPE *, const sparse_ring_matrix< TYPE > &); 412 template math_vector< TYPE > operator * (const sparse_ring_matrix< TYPE > &, const math_vector< TYPE > &); 413 template math_vector< TYPE > operator * (const math_vector< TYPE > &, const sparse_ring_matrix< TYPE > &); 414 template sparse_ring_matrix< TYPE > & operator *= (sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 415 template sparse_ring_matrix< TYPE > & operator *= (sparse_ring_matrix< TYPE > &, const TYPE &); 416 template sparse_ring_matrix< TYPE > operator - (const sparse_ring_matrix< TYPE > &); 417 template bool operator == (const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 418 template bool equal(const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 419 template bool operator != (const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 420 template bool unequal(const sparse_ring_matrix< TYPE > &, const sparse_ring_matrix< TYPE > &); 421 template TYPE trace(const sparse_ring_matrix< TYPE > &); 422 423 424 425 # ifdef LIDIA_NAMESPACE 426 } // end of namespace LiDIA 427 # endif 428 429 # endif // SPARSE 430 431 #endif // RING_MATRIX 432 433 434 435 #ifdef FIELD_MATRIX 436 437 # ifdef SUBCLASSES 438 # include "LiDIA/field_matrix.h" 439 # include "LiDIA/field_matrix.cc" 440 # include "LiDIA/matrix/field_matrix_algorithms.h" 441 # include "LiDIA/matrix/field_matrix_algorithms.cc" 442 # include "LiDIA/matrix/dense_field_matrix_kernel.h" 443 # include "LiDIA/matrix/dense_field_matrix_kernel.cc" 444 # include "LiDIA/matrix/sparse_field_matrix_kernel.h" 445 # include "LiDIA/matrix/sparse_field_matrix_kernel.cc" 446 447 # define DFMKex DFMK< TYPE > 448 # define SFMKex SFMK< TYPE > 449 450 # ifdef LIDIA_NAMESPACE 451 namespace LiDIA { 452 # endif 453 454 455 456 template class DFMKex; 457 template class SFMKex; 458 459 template class FMA< TYPE, DFMKex, DFMKex, DFMKex >; 460 template class FMA< TYPE, DFMKex, DFMKex, SFMKex >; 461 template class FMA< TYPE, DFMKex, SFMKex, DFMKex >; 462 template class FMA< TYPE, SFMKex, DFMKex, DFMKex >; 463 template class FMA< TYPE, DFMKex, SFMKex, SFMKex >; 464 template class FMA< TYPE, SFMKex, DFMKex, SFMKex >; 465 template class FMA< TYPE, SFMKex, SFMKex, DFMKex >; 466 template class FMA< TYPE, SFMKex, SFMKex, SFMKex >; 467 468 469 470 # ifdef LIDIA_NAMESPACE 471 } // end of namespace LiDIA 472 # endif 473 474 # undef DFMKex 475 # undef SFMKex 476 477 # endif // SUBCLASSES 478 479 480 481 # ifdef NORMAL 482 # include "LiDIA/field_matrix.h" 483 # include "LiDIA/field_matrix.cc" 484 # include "LiDIA/matrix/field_matrix_algorithms.h" 485 # include "LiDIA/matrix/field_matrix_algorithms.cc" 486 # include "LiDIA/matrix/dense_field_matrix_kernel.h" 487 # include "LiDIA/matrix/dense_field_matrix_kernel.cc" 488 # include "LiDIA/matrix/sparse_field_matrix_kernel.h" 489 # include "LiDIA/matrix/sparse_field_matrix_kernel.cc" 490 491 # ifdef LIDIA_NAMESPACE 492 namespace LiDIA { 493 # endif 494 495 496 497 template class field_matrix< TYPE >; 498 499 template void divide(field_matrix< TYPE > &, const field_matrix< TYPE > &, const TYPE &); 500 template void compwise_divide(field_matrix< TYPE > &, const field_matrix< TYPE > &, const field_matrix< TYPE > &); 501 template field_matrix< TYPE > operator / (const field_matrix< TYPE > &, const TYPE &); 502 template field_matrix< TYPE > & operator /= (field_matrix< TYPE > &, const TYPE &); 503 504 505 506 # ifdef LIDIA_NAMESPACE 507 } // end of namespace LiDIA 508 # endif 509 510 # endif // NORMAL 511 512 513 514 # ifdef DENSE 515 # include "LiDIA/dense_field_matrix.h" 516 # include "LiDIA/dense_field_matrix.cc" 517 # include "LiDIA/matrix/dense_field_matrix_kernel.h" 518 # include "LiDIA/matrix/dense_field_matrix_kernel.cc" 519 520 # ifdef LIDIA_NAMESPACE 521 namespace LiDIA { 522 # endif 523 524 525 526 template class dense_field_matrix< TYPE >; 527 528 template void divide(dense_field_matrix< TYPE > &, const dense_field_matrix< TYPE > &, const TYPE &); 529 template void compwise_divide(dense_field_matrix< TYPE > &, const dense_field_matrix< TYPE > &, const dense_field_matrix< TYPE > &); 530 template dense_field_matrix< TYPE > operator / (const dense_field_matrix< TYPE > &, const TYPE &); 531 template dense_field_matrix< TYPE > & operator /= (dense_field_matrix< TYPE > &, const TYPE &); 532 533 534 535 # ifdef LIDIA_NAMESPACE 536 } // end of namespace LiDIA 537 # endif 538 539 # endif // DENSE 540 541 542 543 # ifdef SPARSE 544 # include "LiDIA/sparse_field_matrix.h" 545 # include "LiDIA/sparse_field_matrix.cc" 546 # include "LiDIA/matrix/field_matrix_algorithms.h" 547 # include "LiDIA/matrix/field_matrix_algorithms.cc" 548 # include "LiDIA/matrix/sparse_field_matrix_kernel.h" 549 # include "LiDIA/matrix/sparse_field_matrix_kernel.cc" 550 551 # ifdef LIDIA_NAMESPACE 552 namespace LiDIA { 553 # endif 554 555 556 557 template class sparse_field_matrix< TYPE >; 558 559 template void divide(sparse_field_matrix< TYPE > &, const sparse_field_matrix< TYPE > &, const TYPE &); 560 template void compwise_divide(sparse_field_matrix< TYPE > &, const sparse_field_matrix< TYPE > &, const sparse_field_matrix< TYPE > &); 561 template sparse_field_matrix< TYPE > operator / (const sparse_field_matrix< TYPE > &, const TYPE &); 562 template sparse_field_matrix< TYPE > & operator /= (sparse_field_matrix< TYPE > &, const TYPE &); 563 564 565 566 # ifdef LIDIA_NAMESPACE 567 } // end of namespace LiDIA 568 # endif 569 570 # endif // SPARSE 571 572 #endif // FIELD_MATRIX 573