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

Last change on this file since 501 was 501, checked in by claird, 15 years ago

Cleaned up all the Copyright comments.

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