source: branches/dev/LinAlg/TMatrices/IpTripletHelper.cpp @ 567

Last change on this file since 567 was 567, checked in by andreasw, 15 years ago

adapted for Portland compilers

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 22.8 KB
Line 
1// Copyright (C) 2004, 2005 International Business Machines and others.
2// All Rights Reserved.
3// This code is published under the Common Public License.
4//
5// $Id: IpTripletHelper.cpp 567 2005-11-01 23:27:11Z andreasw $
6//
7// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
8
9#include "IpTripletHelper.hpp"
10
11#include "IpGenTMatrix.hpp"
12#include "IpSymTMatrix.hpp"
13#include "IpDiagMatrix.hpp"
14#include "IpIdentityMatrix.hpp"
15#include "IpExpansionMatrix.hpp"
16#include "IpScaledMatrix.hpp"
17#include "IpSymScaledMatrix.hpp"
18#include "IpSumMatrix.hpp"
19#include "IpSumSymMatrix.hpp"
20#include "IpZeroMatrix.hpp"
21#include "IpCompoundMatrix.hpp"
22#include "IpCompoundSymMatrix.hpp"
23
24#include "IpDenseVector.hpp"
25#include "IpCompoundVector.hpp"
26
27#include "IpBlas.hpp"
28
29namespace Ipopt
30{
31
32  Index TripletHelper::GetNumberEntries(const Matrix& matrix)
33  {
34    const Matrix* mptr = &matrix;
35    const GenTMatrix* gent = dynamic_cast<const GenTMatrix*>(mptr);
36    if (gent) {
37      return gent->Nonzeros();
38    }
39
40    const SymTMatrix* symt = dynamic_cast<const SymTMatrix*>(mptr);
41    if (symt) {
42      return symt->Nonzeros();
43    }
44
45    const ScaledMatrix* scaled = dynamic_cast<const ScaledMatrix*>(mptr);
46    if (scaled) {
47      return GetNumberEntries(*GetRawPtr(scaled->GetUnscaledMatrix()));
48    }
49
50    const SymScaledMatrix* symscaled = dynamic_cast<const SymScaledMatrix*>(mptr);
51    if (symscaled) {
52      return GetNumberEntries(*GetRawPtr(symscaled->GetUnscaledMatrix()));
53    }
54
55    const DiagMatrix* diag = dynamic_cast<const DiagMatrix*>(mptr);
56    if (diag) {
57      return diag->Dim();
58    }
59
60    const IdentityMatrix* ident = dynamic_cast<const IdentityMatrix*>(mptr);
61    if (ident) {
62      return ident->Dim();
63    }
64
65    const ExpansionMatrix* exp = dynamic_cast<const ExpansionMatrix*>(mptr);
66    if (exp) {
67      return exp->NCols();
68    }
69
70    const SumMatrix* sum = dynamic_cast<const SumMatrix*>(mptr);
71    if (sum) {
72      return GetNumberEntries_(*sum);
73    }
74
75    const SumSymMatrix* sumsym = dynamic_cast<const SumSymMatrix*>(mptr);
76    if (sumsym) {
77      return GetNumberEntries_(*sumsym);
78    }
79
80    const ZeroMatrix* zero = dynamic_cast<const ZeroMatrix*>(mptr);
81    if (zero) {
82      return 0;
83    }
84
85    const CompoundMatrix* cmpd = dynamic_cast<const CompoundMatrix*>(mptr);
86    if (cmpd) {
87      return GetNumberEntries_(*cmpd);
88    }
89
90    const CompoundSymMatrix* cmpd_sym = dynamic_cast<const CompoundSymMatrix*>(mptr);
91    if (cmpd_sym) {
92      return GetNumberEntries_(*cmpd_sym);
93    }
94
95    THROW_EXCEPTION(UNKNOWN_MATRIX_TYPE,"Unknown matrix type passed to TripletHelper::GetNumberEntries");
96  }
97
98  void TripletHelper::FillRowCol(Index n_entries, const Matrix& matrix, Index* iRow, Index* jCol, Index row_offset/*=0*/, Index col_offset/*=0*/)
99  {
100    const Matrix* mptr = &matrix;
101    const GenTMatrix* gent = dynamic_cast<const GenTMatrix*>(mptr);
102    if (gent) {
103      FillRowCol_(n_entries, *gent, row_offset, col_offset, iRow, jCol);
104      return;
105    }
106
107    const SymTMatrix* symt = dynamic_cast<const SymTMatrix*>(mptr);
108    if (symt) {
109      FillRowCol_(n_entries, *symt, row_offset, col_offset, iRow, jCol);
110      return;
111    }
112
113    const ScaledMatrix* scaled = dynamic_cast<const ScaledMatrix*>(mptr);
114    if (scaled) {
115      FillRowCol_(n_entries, *scaled, row_offset, col_offset, iRow, jCol);
116      return;
117    }
118
119    const SymScaledMatrix* symscaled = dynamic_cast<const SymScaledMatrix*>(mptr);
120    if (symscaled) {
121      FillRowCol_(n_entries, *symscaled, row_offset, col_offset, iRow, jCol);
122      return;
123    }
124
125    const DiagMatrix* diag = dynamic_cast<const DiagMatrix*>(mptr);
126    if (diag) {
127      FillRowCol_(n_entries, *diag, row_offset, col_offset, iRow, jCol);
128      return;
129    }
130
131    const IdentityMatrix* ident = dynamic_cast<const IdentityMatrix*>(mptr);
132    if (ident) {
133      FillRowCol_(n_entries, *ident, row_offset, col_offset, iRow, jCol);
134      return;
135    }
136
137    const ExpansionMatrix* exp = dynamic_cast<const ExpansionMatrix*>(mptr);
138    if (exp) {
139      FillRowCol_(n_entries, *exp, row_offset, col_offset, iRow, jCol);
140      return;
141    }
142
143    const SumMatrix* sum = dynamic_cast<const SumMatrix*>(mptr);
144    if (sum) {
145      FillRowCol_(n_entries, *sum, row_offset, col_offset, iRow, jCol);
146      return;
147    }
148
149    const SumSymMatrix* sumsym = dynamic_cast<const SumSymMatrix*>(mptr);
150    if (sumsym) {
151      FillRowCol_(n_entries, *sumsym, row_offset, col_offset, iRow, jCol);
152      return;
153    }
154
155    const ZeroMatrix* zero = dynamic_cast<const ZeroMatrix*>(mptr);
156    if (zero) {
157      DBG_ASSERT(n_entries == 0);
158      return;
159    }
160
161    const CompoundMatrix* cmpd = dynamic_cast<const CompoundMatrix*>(mptr);
162    if (cmpd) {
163      FillRowCol_(n_entries, *cmpd, row_offset, col_offset, iRow, jCol);
164      return;
165    }
166
167    const CompoundSymMatrix* cmpd_sym = dynamic_cast<const CompoundSymMatrix*>(mptr);
168    if (cmpd_sym) {
169      FillRowCol_(n_entries, *cmpd_sym, row_offset, col_offset, iRow, jCol);
170      return;
171    }
172
173    THROW_EXCEPTION(UNKNOWN_MATRIX_TYPE,"Unknown matrix type passed to TripletHelper::FillRowCol");
174  }
175
176  void TripletHelper::FillValues(Index n_entries, const Matrix& matrix, Number* values)
177  {
178    const Matrix* mptr = &matrix;
179    const GenTMatrix* gent = dynamic_cast<const GenTMatrix*>(mptr);
180    if (gent) {
181      FillValues_(n_entries, *gent, values);
182      return;
183    }
184
185    const SymTMatrix* symt = dynamic_cast<const SymTMatrix*>(mptr);
186    if (symt) {
187      FillValues_(n_entries, *symt, values);
188      return;
189    }
190
191    const ScaledMatrix* scaled = dynamic_cast<const ScaledMatrix*>(mptr);
192    if (scaled) {
193      FillValues_(n_entries, *scaled, values);
194      return;
195    }
196
197    const SymScaledMatrix* symscaled = dynamic_cast<const SymScaledMatrix*>(mptr);
198    if (symscaled) {
199      FillValues_(n_entries, *symscaled, values);
200      return;
201    }
202
203    const DiagMatrix* diag = dynamic_cast<const DiagMatrix*>(mptr);
204    if (diag) {
205      FillValues_(n_entries, *diag, values);
206      return;
207    }
208
209    const IdentityMatrix* ident = dynamic_cast<const IdentityMatrix*>(mptr);
210    if (ident) {
211      FillValues_(n_entries, *ident, values);
212      return;
213    }
214
215    const ExpansionMatrix* exp = dynamic_cast<const ExpansionMatrix*>(mptr);
216    if (exp) {
217      FillValues_(n_entries, *exp, values);
218      return;
219    }
220
221    const SumMatrix* sum = dynamic_cast<const SumMatrix*>(mptr);
222    if (sum) {
223      FillValues_(n_entries, *sum, values);
224      return;
225    }
226
227    const SumSymMatrix* sumsym = dynamic_cast<const SumSymMatrix*>(mptr);
228    if (sumsym) {
229      FillValues_(n_entries, *sumsym, values);
230      return;
231    }
232
233    const ZeroMatrix* zero = dynamic_cast<const ZeroMatrix*>(mptr);
234    if (zero) {
235      DBG_ASSERT(n_entries == 0);
236      return;
237    }
238
239    const CompoundMatrix* cmpd = dynamic_cast<const CompoundMatrix*>(mptr);
240    if (cmpd) {
241      FillValues_(n_entries, *cmpd, values);
242      return;
243    }
244
245    const CompoundSymMatrix* cmpd_sym = dynamic_cast<const CompoundSymMatrix*>(mptr);
246    if (cmpd_sym) {
247      FillValues_(n_entries, *cmpd_sym, values);
248      return;
249    }
250
251    THROW_EXCEPTION(UNKNOWN_MATRIX_TYPE,"Unknown matrix type passed to TripletHelper::FillValues");
252  }
253
254  Index TripletHelper::GetNumberEntries_(const SumMatrix& matrix)
255  {
256    Index n_entries = 0;
257    Index nterms = matrix.NTerms();
258    for (Index i=0; i<nterms; i++) {
259      Number dummy;
260      SmartPtr<const Matrix> i_mat;
261      matrix.GetTerm(i, dummy, i_mat);
262      n_entries += GetNumberEntries(*i_mat);
263    }
264    return n_entries;
265  }
266
267  Index TripletHelper::GetNumberEntries_(const SumSymMatrix& matrix)
268  {
269    Index n_entries = 0;
270    Index nterms = matrix.NTerms();
271    for (Index i=0; i<nterms; i++) {
272      Number dummy;
273      SmartPtr<const SymMatrix> i_mat;
274      matrix.GetTerm(i, dummy, i_mat);
275      n_entries += GetNumberEntries(*i_mat);
276    }
277    return n_entries;
278  }
279
280  Index TripletHelper::GetNumberEntries_(const CompoundMatrix& matrix)
281  {
282    Index n_entries = 0;
283    Index nrows = matrix.NComps_Rows();
284    Index ncols = matrix.NComps_Cols();
285    for (Index i=0; i<nrows; i++) {
286      for (Index j=0; j<ncols; j++) {
287        SmartPtr<const Matrix> comp = matrix.GetComp(i,j);
288        if (IsValid(comp)) {
289          n_entries += GetNumberEntries(*comp);
290        }
291      }
292    }
293    return n_entries;
294  }
295
296  Index TripletHelper::GetNumberEntries_(const CompoundSymMatrix& matrix)
297  {
298    Index n_entries = 0;
299    Index dim = matrix.NComps_Dim();
300    for (Index i=0; i<dim; i++) {
301      for (Index j=0; j<=i; j++) {
302        SmartPtr<const Matrix> comp = matrix.GetComp(i,j);
303        if (IsValid(comp)) {
304          n_entries += GetNumberEntries(*comp);
305        }
306      }
307    }
308    return n_entries;
309  }
310
311  void TripletHelper::FillRowCol_(Index n_entries, const GenTMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
312  {
313    DBG_ASSERT(n_entries == matrix.Nonzeros());
314    const Index* irow = matrix.Irows();
315    const Index* jcol = matrix.Jcols();
316    for (Index i=0; i<n_entries; i++) {
317      iRow[i] = irow[i] + row_offset;
318      jCol[i] = jcol[i] + col_offset;
319    }
320  }
321
322  void TripletHelper::FillValues_(Index n_entries, const GenTMatrix& matrix, Number* values)
323  {
324    DBG_ASSERT(n_entries == matrix.Nonzeros());
325    const Number* vals = matrix.Values();
326    for (Index i=0; i<n_entries; i++) {
327      values[i] = vals[i];
328    }
329  }
330
331  void TripletHelper::FillRowCol_(Index n_entries, const SymTMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
332  {
333    DBG_ASSERT(n_entries == matrix.Nonzeros());
334    const Index* irow = matrix.Irows();
335    const Index* jcol = matrix.Jcols();
336    for (Index i=0; i<n_entries; i++) {
337      iRow[i] = irow[i] + row_offset;
338      jCol[i] = jcol[i] + col_offset;
339    }
340  }
341
342  void TripletHelper::FillValues_(Index n_entries, const SymTMatrix& matrix, Number* values)
343  {
344    DBG_ASSERT(n_entries == matrix.Nonzeros());
345    matrix.FillValues(values);
346  }
347
348  void TripletHelper::FillRowCol_(Index n_entries, const DiagMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
349  {
350    DBG_ASSERT(n_entries == matrix.Dim());
351    for (Index i=0; i<n_entries; i++) {
352      iRow[i] = i + row_offset + 1;
353      jCol[i] = i + col_offset + 1;
354    }
355  }
356
357  void TripletHelper::FillValues_(Index n_entries, const DiagMatrix& matrix, Number* values)
358  {
359    DBG_ASSERT(n_entries == matrix.Dim());
360    SmartPtr<const Vector> v = matrix.GetDiag();
361    FillValuesFromVector(n_entries, *v, values);
362    //    const DenseVector* vec = dynamic_cast<const DenseVector*>(GetRawPtr(v));
363    //    ASSERT_EXCEPTION(vec, UNKNOWN_VECTOR_TYPE, "Unkown Vector type found in FillValues for DiagMatrix");
364    //    const Number* vals = vec->Values();
365    //    IpBlasDcopy(n_entries, vals, 1, values, 1);
366  }
367
368  void TripletHelper::FillRowCol_(Index n_entries, const IdentityMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
369  {
370    DBG_ASSERT(n_entries == matrix.Dim());
371    for (Index i=0; i<n_entries; i++) {
372      iRow[i] = i + row_offset + 1;
373      jCol[i] = i + col_offset + 1;
374    }
375  }
376
377  void TripletHelper::FillValues_(Index n_entries, const IdentityMatrix& matrix, Number* values)
378  {
379    DBG_ASSERT(n_entries == matrix.Dim());
380    Number factor = matrix.GetFactor();
381    for (Index i=0; i<n_entries; i++) {
382      values[i] = factor;
383    }
384  }
385
386  void TripletHelper::FillRowCol_(Index n_entries, const ExpansionMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
387  {
388    DBG_ASSERT(n_entries == matrix.NCols());
389    const Index* exp_pos = matrix.ExpandedPosIndices();
390    for (Index i=0; i<n_entries; i++) {
391      iRow[i] = exp_pos[i] + row_offset + 1;
392      jCol[i] = i + col_offset + 1;
393    }
394  }
395
396  void TripletHelper::FillValues_(Index n_entries, const ExpansionMatrix& matrix, Number* values)
397  {
398    DBG_ASSERT(n_entries == matrix.NCols());
399    for (Index i=0; i<n_entries; i++) {
400      values[i] = 1.0;
401    }
402  }
403
404  void TripletHelper::FillRowCol_(Index n_entries, const SumMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
405  {
406    Index total_n_entries = 0;
407    for (Index i=0; i<matrix.NTerms(); i++) {
408      // Fill the indices for the individual term
409      Number retFactor = 0.0;
410      SmartPtr<const Matrix> retTerm;
411      matrix.GetTerm(i, retFactor, retTerm);
412      Index term_n_entries = GetNumberEntries(*retTerm);
413      total_n_entries += term_n_entries;
414      FillRowCol(term_n_entries, *retTerm, iRow, jCol, row_offset, col_offset);
415
416      // now shift the iRow, jCol pointers for the next term
417      iRow += term_n_entries;
418      jCol += term_n_entries;
419    }
420    DBG_ASSERT(total_n_entries == n_entries);
421  }
422
423  void TripletHelper::FillValues_(Index n_entries, const SumMatrix& matrix, Number* values)
424  {
425    Index total_n_entries = 0;
426    for (Index i=0; i<matrix.NTerms(); i++) {
427      // Fill the values for the individual term
428      Number retFactor = 0.0;
429      SmartPtr<const Matrix> retTerm;
430      matrix.GetTerm(i, retFactor, retTerm);
431      Index term_n_entries = GetNumberEntries(*retTerm);
432      total_n_entries += term_n_entries;
433      FillValues(term_n_entries, *retTerm, values);
434
435      // Now adjust the values based on the factor
436      IpBlasDscal(term_n_entries, retFactor, values, 1);
437
438      // now shift the values pointer for the next term
439      values += term_n_entries;
440    }
441    DBG_ASSERT(total_n_entries == n_entries);
442  }
443
444  void TripletHelper::FillRowCol_(Index n_entries, const SumSymMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
445  {
446    Index total_n_entries = 0;
447    for (Index i=0; i<matrix.NTerms(); i++) {
448      // Fill the indices for the individual term
449      Number retFactor = 0.0;
450      SmartPtr<const SymMatrix> retTerm;
451      matrix.GetTerm(i, retFactor, retTerm);
452      Index term_n_entries = GetNumberEntries(*retTerm);
453      total_n_entries += term_n_entries;
454      FillRowCol(term_n_entries, *retTerm, iRow, jCol, row_offset, col_offset);
455
456      // now shift the iRow, jCol pointers for the next term
457      iRow += term_n_entries;
458      jCol += term_n_entries;
459    }
460    DBG_ASSERT(total_n_entries == n_entries);
461  }
462
463  void TripletHelper::FillValues_(Index n_entries, const SumSymMatrix& matrix, Number* values)
464  {
465    Index total_n_entries = 0;
466    for (Index i=0; i<matrix.NTerms(); i++) {
467      // Fill the values for the individual term
468      Number retFactor = 0.0;
469      SmartPtr<const SymMatrix> retTerm;
470      matrix.GetTerm(i, retFactor, retTerm);
471      Index term_n_entries = GetNumberEntries(*retTerm);
472      total_n_entries += term_n_entries;
473      FillValues(term_n_entries, *retTerm, values);
474
475      // Now adjust the values based on the factor
476      IpBlasDscal(term_n_entries, retFactor, values, 1);
477
478      // now shift the values pointer for the next term
479      values += term_n_entries;
480    }
481    DBG_ASSERT(total_n_entries == n_entries);
482  }
483
484  void TripletHelper::FillRowCol_(Index n_entries, const CompoundMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
485  {
486    Index total_n_entries = 0;
487
488    const CompoundMatrixSpace* owner_space = dynamic_cast<const CompoundMatrixSpace*>(GetRawPtr(matrix.OwnerSpace()));
489    DBG_ASSERT(owner_space);
490
491    Index c_row_offset = row_offset;
492    for (Index i=0; i<matrix.NComps_Rows(); i++) {
493      Index c_col_offset = col_offset;
494      for (Index j=0; j<matrix.NComps_Cols(); j++) {
495        // Fill the indices for the individual term
496        SmartPtr<const Matrix> blk_mat = matrix.GetComp(i, j);
497        if (IsValid(blk_mat)) {
498          Index blk_n_entries = GetNumberEntries(*blk_mat);
499          total_n_entries += blk_n_entries;
500          FillRowCol(blk_n_entries, *blk_mat, iRow, jCol, c_row_offset, c_col_offset);
501
502          // now shift the iRow, jCol pointers for the next term
503          iRow += blk_n_entries;
504          jCol += blk_n_entries;
505        }
506        c_col_offset += owner_space->GetBlockCols(j);
507      }
508      c_row_offset += owner_space->GetBlockRows(i);
509    }
510    DBG_ASSERT(total_n_entries == n_entries);
511  }
512
513  void TripletHelper::FillValues_(Index n_entries, const CompoundMatrix& matrix, Number* values)
514  {
515    Index total_n_entries = 0;
516
517    for (Index i=0; i<matrix.NComps_Rows(); i++) {
518      for (Index j=0; j<matrix.NComps_Cols(); j++) {
519        // Fill the indices for the individual term
520        SmartPtr<const Matrix> blk_mat = matrix.GetComp(i, j);
521        if (IsValid(blk_mat)) {
522          Index blk_n_entries = GetNumberEntries(*blk_mat);
523          total_n_entries += blk_n_entries;
524          FillValues(blk_n_entries, *blk_mat, values);
525
526          // now shift the values pointer for the next term
527          values += blk_n_entries;
528        }
529      }
530    }
531    DBG_ASSERT(total_n_entries == n_entries);
532  }
533
534  void TripletHelper::FillRowCol_(Index n_entries, const CompoundSymMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
535  {
536    Index total_n_entries = 0;
537
538    const CompoundSymMatrixSpace* owner_space = dynamic_cast<const CompoundSymMatrixSpace*>(GetRawPtr(matrix.OwnerSpace()));
539    DBG_ASSERT(owner_space);
540
541    Index c_row_offset = row_offset;
542    for (Index i=0; i<matrix.NComps_Dim(); i++) {
543      Index c_col_offset = col_offset;
544      for (Index j=0; j<=i; j++) {
545        // Fill the indices for the individual term
546        SmartPtr<const Matrix> blk_mat = matrix.GetComp(i, j);
547        if (IsValid(blk_mat)) {
548          Index blk_n_entries = GetNumberEntries(*blk_mat);
549          total_n_entries += blk_n_entries;
550          FillRowCol(blk_n_entries, *blk_mat, iRow, jCol, c_row_offset, c_col_offset);
551
552          // now shift the iRow, jCol pointers for the next term
553          iRow += blk_n_entries;
554          jCol += blk_n_entries;
555        }
556        c_col_offset += owner_space->GetBlockDim(j);
557      }
558      c_row_offset += owner_space->GetBlockDim(i);
559    }
560    DBG_ASSERT(total_n_entries == n_entries);
561  }
562
563  void TripletHelper::FillValues_(Index n_entries, const CompoundSymMatrix& matrix, Number* values)
564  {
565    Index total_n_entries = 0;
566
567    for (Index i=0; i<matrix.NComps_Dim(); i++) {
568      for (Index j=0; j<=i; j++) {
569        // Fill the indices for the individual term
570        SmartPtr<const Matrix> blk_mat = matrix.GetComp(i, j);
571        if (IsValid(blk_mat)) {
572          Index blk_n_entries = GetNumberEntries(*blk_mat);
573          total_n_entries += blk_n_entries;
574          FillValues(blk_n_entries, *blk_mat, values);
575
576          // now shift the iRow, jCol pointers for the next term
577          values += blk_n_entries;
578        }
579      }
580    }
581    DBG_ASSERT(total_n_entries == n_entries);
582  }
583
584  void TripletHelper::FillValuesFromVector(Index dim, const Vector& vector, Number* values)
585  {
586    DBG_ASSERT(dim == vector.Dim());
587    const DenseVector* dv = dynamic_cast<const DenseVector*>(&vector);
588    if (dv) {
589      if (dv->IsHomogeneous()) {
590        Number scalar = dv->Scalar();
591        IpBlasDcopy(dim, &scalar, 0, values, 1);
592      }
593      else {
594        const Number* dv_vals = dv->Values();
595        IpBlasDcopy(dim, dv_vals, 1, values, 1);
596      }
597      return;
598    }
599
600    const CompoundVector* cv = dynamic_cast<const CompoundVector*>(&vector);
601    if (cv) {
602      Index ncomps = cv->NComps();
603      Index total_dim = 0;
604      for (Index i=0; i<ncomps; i++) {
605        SmartPtr<const Vector> comp = cv->GetComp(i);
606        Index comp_dim = comp->Dim();
607        FillValuesFromVector(comp_dim, *comp, values);
608        values += comp_dim;
609        total_dim += comp_dim;
610      }
611      DBG_ASSERT(total_dim == dim);
612      return;
613    }
614
615    THROW_EXCEPTION(UNKNOWN_VECTOR_TYPE,"Unknown vector type passed to TripletHelper::FillValues");
616  }
617
618  void TripletHelper::FillRowCol_(Index n_entries, const ScaledMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
619  {
620    FillRowCol(n_entries, *GetRawPtr(matrix.GetUnscaledMatrix()), iRow, jCol, row_offset, col_offset);
621  }
622
623  void TripletHelper::FillValues_(Index n_entries, const ScaledMatrix& matrix, Number* values)
624  {
625    // ToDo:
626    // This method can be made much more efficient for ScaledMatrix with GenTMatrix
627    // contained
628
629    // Get the matrix values
630    FillValues(n_entries, *GetRawPtr(matrix.GetUnscaledMatrix()), values);
631
632    // Scale the values
633    // To Do : This assumes 1-base values (like the TMatrices)
634    Index* iRow = new Index[n_entries];
635    Index* jCol = new Index[n_entries];
636    FillRowCol(n_entries, *GetRawPtr(matrix.GetUnscaledMatrix()), iRow, jCol, 0, 0);
637
638    if (IsValid(matrix.RowScaling())) {
639      Index n_rows = matrix.NRows();
640      Number* row_scaling = new Number[n_rows];
641      FillValuesFromVector(n_rows, *matrix.RowScaling(), row_scaling);
642      for (Index i=0; i<n_entries; i++) {
643        values[i] *= row_scaling[iRow[i]-1];
644      }
645      delete [] row_scaling;
646    }
647
648    if (IsValid(matrix.ColumnScaling())) {
649      Index n_cols = matrix.NCols();
650      Number* col_scaling = new Number[n_cols];
651      FillValuesFromVector(n_cols, *matrix.ColumnScaling(), col_scaling);
652      for (Index i=0; i<n_entries; i++) {
653        values[i] *= col_scaling[jCol[i]-1];
654      }
655      delete [] col_scaling;
656    }
657
658    delete [] iRow;
659    delete [] jCol;
660  }
661
662  void TripletHelper::FillRowCol_(Index n_entries, const SymScaledMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol)
663  {
664    FillRowCol(n_entries, *GetRawPtr(matrix.GetUnscaledMatrix()), iRow, jCol, row_offset, col_offset);
665  }
666
667  void TripletHelper::FillValues_(Index n_entries, const SymScaledMatrix& matrix, Number* values)
668  {
669    // ToDo:
670    // This method can be made much more efficient for ScaledMatrix with SymTMatrix
671    // contained
672
673    // Get the matrix values
674    FillValues(n_entries, *GetRawPtr(matrix.GetUnscaledMatrix()), values);
675
676    // Scale the values
677    // To Do : This assumes 1-base values (like the TMatrices)
678    Index* iRow = new Index[n_entries];
679    Index* jCol = new Index[n_entries];
680    FillRowCol(n_entries, *GetRawPtr(matrix.GetUnscaledMatrix()), iRow, jCol, 0, 0);
681
682    if (IsValid(matrix.RowColScaling())) {
683      Index n_dim = matrix.NRows();
684      Number* scaling = new Number[n_dim];
685      FillValuesFromVector(n_dim, *matrix.RowColScaling(), scaling);
686      for (Index i=0; i<n_entries; i++) {
687        values[i] *= scaling[iRow[i]-1];
688        values[i] *= scaling[jCol[i]-1];
689      }
690      delete [] scaling;
691    }
692
693    delete [] iRow;
694    delete [] jCol;
695  }
696
697  void TripletHelper::PutValuesInVector(Index dim, const double* values, Vector& vector)
698  {
699    DBG_ASSERT(dim == vector.Dim());
700    DenseVector* dv = dynamic_cast<DenseVector*>(&vector);
701    if (dv) {
702      Number* dv_vals = dv->Values();
703      IpBlasDcopy(dim, values, 1, dv_vals, 1);
704      return;
705    }
706
707    CompoundVector* cv = dynamic_cast<CompoundVector*>(&vector);
708    if (cv) {
709      Index ncomps = cv->NComps();
710      Index total_dim = 0;
711      for (Index i=0; i<ncomps; i++) {
712        SmartPtr<Vector> comp = cv->GetCompNonConst(i);
713        Index comp_dim = comp->Dim();
714        PutValuesInVector(comp_dim, values, *comp);
715        values += comp_dim;
716        total_dim += comp_dim;
717      }
718      DBG_ASSERT(total_dim == dim);
719      return;
720    }
721
722    THROW_EXCEPTION(UNKNOWN_VECTOR_TYPE,"Unknown vector type passed to TripletHelper::PutValuesInVector");
723  }
724
725} // namespace Ipopt
726
Note: See TracBrowser for help on using the repository browser.