File: vektor.cpp

package info (click to toggle)
gfan 0.3dfsg-1
  • links: PTS
  • area: main
  • in suites: lenny, squeeze
  • size: 2,012 kB
  • ctags: 1,935
  • sloc: cpp: 17,728; makefile: 251
file content (112 lines) | stat: -rw-r--r-- 2,036 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include "vektor.h"

IntegerVectorList transposeIntegerVectorList(IntegerVectorList const &l)
{
  int n=l.size();
  assert(n);
  int m=l.begin()->size();

  IntegerVectorList r;

  for(int i=0;i<m;i++)
    {
      IntegerVector column(n);
      
      int j=0;
      for(IntegerVectorList::const_iterator J=l.begin();J!=l.end();J++)
	{
	  column[j]=(*J)[i];
	  j++;
	}
      r.push_back(column);
    }
  return r;
}


IntegerVectorList multiplyIntegerVectorList(IntegerVectorList const &A, IntegerVectorList const &B)
{
  int s1=A.size();
  assert(s1);
  int r=A.begin()->size();
  int t=B.size();
  assert(t);
  int s2=B.begin()->size();

  assert(s1==s2);

  IntegerVectorList C;
  for(IntegerVectorList::const_iterator I=B.begin();I!=B.end();I++)
  {
    IntegerVector column(r);

    int j=0;
    for(IntegerVectorList::const_iterator J=A.begin();J!=A.end();J++)
      {
	column+=(*I)[j]*(*J);
	j++;
      }
    C.push_back(column);
  }
  return C;
}


/* Computes the greatest common divisor of two integers.
   The result is always positive.
   Asserts if both integers are zero.
 */
int gcd(int r, int s)
{
  if(r<0)r=-r;
  if(s<0)s=-s;
  
  if(s<r)
    {
      int t;
      t=r;
      r=s;
      s=t;
    }

  while(r!=0)
    {
      int t=s%r;
      s=r;
      r=t;
    }
  assert(s!=0);

  return s;
}


/* Returns positive gcd of elements in the vector.
   The result is always positive. 
   Asserts if the vector is the zero-vector.
 */
int gcdOfVector(IntegerVector const &v)
{
  int ret=0;
  for(int i=0;i<v.size();i++)if(ret=v[i])break;
  if(ret<0)ret=-ret;
  assert(ret!=0);
  for(int i=0;i<v.size();i++)ret=gcd(ret,v[i]);

  return ret;
}


/* Uses gcd to put (the direction given by) the vector in a unique form by scaling.
   Only positive scaling is applied.
   If the input is the zero-vector so is the output.
   Otherwise, the common divisor of the output is 1. 
*/
IntegerVector normalized(IntegerVector v)
{
  if(v.isZero())return v;
  int a=gcdOfVector(v);
  for(int i=0;i<v.size();i++)v[i]/=a;

  return v;
}