← Back to branch summary

~ubuntu-branches/ubuntu/karmic/psicode/karmic

« back to all changes in this revision

Viewing changes to src/lib/libciomr/eigsort.cc

  • Committer: Bazaar Package Importer
  • Author(s): Michael Banck, Michael Banck, Daniel Leidert
  • Date: 2009-02-23 00:12:02 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090223001202-rutldoy3dimfpesc
Tags: 3.4.0-1
* New upstream release.

[ Michael Banck ]
* debian/patches/01_DESTDIR.dpatch: Refreshed.
* debian/patches/02_FHS.dpatch: Removed, applied upstream.
* debian/patches/03_debian_docdir: Likewise.
* debian/patches/04_man.dpatch: Likewise.
* debian/patches/06_466828_fix_gcc_43_ftbfs.dpatch: Likewise.
* debian/patches/07_464867_move_executables: Fixed and refreshed.
* debian/patches/00list: Adjusted.
* debian/control: Improved description.
* debian/patches-held: Removed.
* debian/rules (install/psi3): Do not ship the ruby bindings for now.

[ Daniel Leidert ]
* debian/rules: Fix txtdir via DEB_MAKE_INSTALL_TARGET.
* debian/patches/01_DESTDIR.dpatch: Refreshed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/libciomr/eigsort.cc
 
1
/*!
 
2
  \file
 
3
  \brief Sort eigenvalues and eigenvectors in ascending or descending order
 
4
  \ingroup CIOMR
 
5
*/
 
6
 
 
7
 
 
8
#include <cstdlib>
 
9
 
 
10
extern "C" {
 
11
 
 
12
/*!
 
13
** eigsort(): Sort the eigenvalues in d and eigenvectors in v in ascending
 
14
** (n>0) or descending (n<0) order.  abs(n) is the number of eigenvalues. 
 
15
** 
 
16
** \param d   = array of eigenvalues
 
17
** \param v   = matrix of eigenvectors (each column is an eigenvector)
 
18
**              Note: seems to assume v is a square matrix, could be a
 
19
**              problem if, e.g., nmo != nso.
 
20
** \param n   = abs(n) is the number of eigenvalues/cols of v.  Use
 
21
**              n>0 to sort in ascending order, n<0 to sort in descending
 
22
**              order
 
23
**
 
24
** Returns: none
 
25
**
 
26
** \ingroup CIOMR
 
27
*/
 
28
void eigsort(double *d, double **v, int n)
 
29
{
 
30
  int i,j,k;
 
31
  double p;
 
32
 
 
33
  /* Modified by Ed Valeev - if n is negative,
 
34
     sort eigenvalues in descending order */
 
35
 
 
36
  if (n >= 0) {
 
37
    for (i=0; i < n-1 ; i++) {
 
38
      k=i;
 
39
      p=d[i];
 
40
      for (j=i+1; j < n; j++) {
 
41
        if (d[j] < p) {
 
42
          k=j;
 
43
          p=d[j];
 
44
        }
 
45
      }
 
46
      if (k != i) {
 
47
        d[k]=d[i];
 
48
        d[i]=p;
 
49
        for (j=0; j < n; j++) {
 
50
          p=v[j][i];
 
51
          v[j][i]=v[j][k];
 
52
          v[j][k]=p;
 
53
        }
 
54
      }
 
55
    }
 
56
  }
 
57
  else {
 
58
    n = abs(n);
 
59
    for (i=0; i < n-1 ; i++) {
 
60
      k=i;
 
61
      p=d[i];
 
62
      for (j=i+1; j < n; j++) {
 
63
        if (d[j] > p) {
 
64
          k=j;
 
65
          p=d[j];
 
66
        }
 
67
      }
 
68
      if (k != i) {
 
69
        d[k]=d[i];
 
70
        d[i]=p;
 
71
        for (j=0; j < n; j++) {
 
72
          p=v[j][i];
 
73
          v[j][i]=v[j][k];
 
74
          v[j][k]=p;
 
75
        }
 
76
      }
 
77
    }
 
78
  }
 
79
}
 
80
 
 
81
 
 
82
/*!
 
83
** mosort(): Minor modification of eigsort() to also sort a series of
 
84
** irrep labels.
 
85
**
 
86
** \param d   = array of eigenvalues
 
87
** \param v   = matrix of eigenvectors (each column is an eigenvector)
 
88
** \param sym = array of symmetry ID's (irreps)
 
89
** \param nso = number of rows in v
 
90
** \param nmo = abs(nmo) is the number of eigenvalues/cols of v.  Use
 
91
**              nmo>0 to sort in ascending order, nmo<0 to sort in descending
 
92
**              order
 
93
** 
 
94
** Returns:none
 
95
**
 
96
** TDC, 6/03
 
97
** \ingroup CIOMR
 
98
*/
 
99
void mosort(double *d, double **v, int *sym, int nso, int nmo)
 
100
{
 
101
  int i, j, k, l;
 
102
  double p;
 
103
 
 
104
  if(nmo > 0) {
 
105
    for (i=0; i < nmo-1 ; i++) {
 
106
      k=i;
 
107
      p=d[i];
 
108
      for (j=i+1; j < nmo; j++) {
 
109
        if (d[j] < p) {
 
110
          k=j;
 
111
          p=d[j];
 
112
        }
 
113
      }
 
114
      if (k != i) {
 
115
        d[k]=d[i];
 
116
        d[i]=p;
 
117
 
 
118
        l = sym[i];
 
119
        sym[i] = sym[k];
 
120
        sym[k] = l;
 
121
 
 
122
        for (j=0; j < nso; j++) {
 
123
          p=v[j][i];
 
124
          v[j][i]=v[j][k];
 
125
          v[j][k]=p;
 
126
        }
 
127
      }
 
128
    }
 
129
  }
 
130
  else if(nmo < 0) {
 
131
    nmo = abs(nmo);
 
132
    for (i=0; i < nmo-1 ; i++) {
 
133
      k=i;
 
134
      p=d[i];
 
135
      for (j=i+1; j < nmo; j++) {
 
136
        if (d[j] > p) {
 
137
          k=j;
 
138
          p=d[j];
 
139
        }
 
140
      }
 
141
      if (k != i) {
 
142
        d[k]=d[i];
 
143
        d[i]=p;
 
144
 
 
145
        l = sym[i];
 
146
        sym[i] = sym[k];
 
147
        sym[k] = l;
 
148
 
 
149
        for (j=0; j < nso; j++) {
 
150
          p=v[j][i];
 
151
          v[j][i]=v[j][k];
 
152
          v[j][k]=p;
 
153
        }
 
154
      }
 
155
    }
 
156
  }
 
157
}
 
158
 
 
159
} /* extern "C" */