SHOGUN  4.0.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SGVector.cpp
Go to the documentation of this file.
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 3 of the License, or
5  * (at your option) any later version.
6  *
7  * Written (W) 2013 Thoralf Klein
8  * Written (W) 2011-2013 Heiko Strathmann
9  * Written (W) 2013 Soumyajit De
10  * Written (W) 2012 Fernando José Iglesias García
11  * Written (W) 2010,2012 Soeren Sonnenburg
12  * Copyright (C) 2010 Berlin Institute of Technology
13  * Copyright (C) 2012 Soeren Sonnenburg
14  */
15 
16 #include <shogun/lib/config.h>
17 #include <shogun/lib/SGVector.h>
18 #include <shogun/lib/SGMatrix.h>
21 #include <shogun/io/File.h>
22 
25 #include <algorithm>
26 
28 
29 #define COMPLEX128_ERROR_NOARG(function) \
30 template <> \
31 void SGVector<complex128_t>::function() \
32 { \
33  SG_SERROR("SGVector::%s():: Not supported for complex128_t\n",\
34  #function);\
35 }
36 
37 #define BOOL_ERROR_ONEARG(function) \
38 template <> \
39 void SGVector<bool>::function(bool a) \
40 { \
41  SG_SERROR("SGVector::%s():: Not supported for bool\n",\
42  #function);\
43 }
44 
45 #define COMPLEX128_ERROR_ONEARG(function) \
46 template <> \
47 void SGVector<complex128_t>::function(complex128_t a) \
48 { \
49  SG_SERROR("SGVector::%s():: Not supported for complex128_t\n",\
50  #function);\
51 }
52 
53 #define COMPLEX128_ERROR_TWOARGS(function) \
54 template <> \
55 void SGVector<complex128_t>::function(complex128_t a, complex128_t b) \
56 { \
57  SG_SERROR("SGVector::%s():: Not supported for complex128_t\n",\
58  #function);\
59 }
60 
61 #define COMPLEX128_ERROR_THREEARGS(function) \
62 template <> \
63 void SGVector<complex128_t>::function(complex128_t a, complex128_t b,\
64  complex128_t c) \
65 { \
66  SG_SERROR("SGVector::%s():: Not supported for complex128_t\n",\
67  #function);\
68 }
69 
70 namespace shogun {
71 
72 template<class T>
74 {
75  init_data();
76 }
77 
78 template<class T>
79 SGVector<T>::SGVector(T* v, index_t len, bool ref_counting)
80 : SGReferencedData(ref_counting), vector(v), vlen(len)
81 {
82 }
83 
84 template<class T>
85 SGVector<T>::SGVector(index_t len, bool ref_counting)
86 : SGReferencedData(ref_counting), vlen(len)
87 {
88  vector=SG_MALLOC(T, len);
89 }
90 
91 template<class T>
93 {
94  copy_data(orig);
95 }
96 
97 template<class T>
99 {
100  *this = SGVector<T>(orig);
101 }
102 
103 template<class T>
105 {
106  unref();
107 }
108 
109 #ifdef HAVE_EIGEN3
110 template <class T>
111 SGVector<T>::SGVector(EigenVectorXt& vec)
112 : SGReferencedData(false), vector(vec.data()), vlen(vec.size())
113 {
114 
115 }
116 
117 template <class T>
118 SGVector<T>::SGVector(EigenRowVectorXt& vec)
119 : SGReferencedData(false), vector(vec.data()), vlen(vec.size())
120 {
121 
122 }
123 
124 template <class T>
125 SGVector<T>::operator EigenVectorXtMap() const
126 {
127  return EigenVectorXtMap(vector, vlen);
128 }
129 
130 template <class T>
131 SGVector<T>::operator EigenRowVectorXtMap() const
132 {
133  return EigenRowVectorXtMap(vector, vlen);
134 }
135 #endif
136 
137 template<class T>
139 {
140  if (vector && vlen)
141  set_const(0);
142 }
143 
144 template <>
146 {
147  if (vector && vlen)
148  set_const(complex128_t(0.0));
149 }
150 
151 template<class T>
152 void SGVector<T>::set_const(T const_elem)
153 {
154  for (index_t i=0; i<vlen; i++)
155  vector[i]=const_elem ;
156 }
157 
158 #if HAVE_CATLAS
159 template<>
161 {
162  catlas_dset(vlen, const_elem, vector, 1);
163 }
164 
165 template<>
166 void SGVector<float32_t>::set_const(float32_t const_elem)
167 {
168  catlas_sset(vlen, const_elem, vector, 1);
169 }
170 #endif // HAVE_CATLAS
171 
172 template<class T>
174 {
175  range_fill_vector(vector, vlen, start);
176 }
177 
178 COMPLEX128_ERROR_ONEARG(range_fill)
179 
180 template<class T>
181 void SGVector<T>::random(T min_value, T max_value)
182 {
183  random_vector(vector, vlen, min_value, max_value);
184 }
185 
187 
188 template <class T>
189 index_t SGVector<T>::find_position_to_insert(T element)
190 {
191  index_t i;
192  for (i=0; i<vlen; ++i)
193  {
194  if (vector[i]>element)
195  break;
196  }
197  return i;
198 }
199 
200 template <>
202 {
203  SG_SERROR("SGVector::find_position_to_insert():: \
204  Not supported for complex128_t\n");
205  return index_t(-1);
206 }
207 
208 template<class T>
210 {
211  return SGVector<T>(clone_vector(vector, vlen), vlen);
212 }
213 
214 template<class T>
215 T* SGVector<T>::clone_vector(const T* vec, int32_t len)
216 {
217  T* result = SG_MALLOC(T, len);
218  memcpy(result, vec, sizeof(T)*len);
219  return result;
220 }
221 
222 template<class T>
223 void SGVector<T>::fill_vector(T* vec, int32_t len, T value)
224 {
225  for (int32_t i=0; i<len; i++)
226  vec[i]=value;
227 }
228 
229 template<class T>
230 void SGVector<T>::range_fill_vector(T* vec, int32_t len, T start)
231 {
232  for (int32_t i=0; i<len; i++)
233  vec[i]=i+start;
234 }
235 
236 template <>
238  int32_t len, complex128_t start)
239 {
240  SG_SERROR("SGVector::range_fill_vector():: \
241  Not supported for complex128_t\n");
242 }
243 
244 template<class T>
246 {
247  ASSERT(vector && (index>=0) && (index<vlen))
248  return vector[index];
249 }
250 
251 template<class T>
252 void SGVector<T>::set_element(const T& p_element, index_t index)
253 {
254  ASSERT(vector && (index>=0) && (index<vlen))
255  vector[index]=p_element;
256 }
257 
258 template<class T>
260 {
261  vector=SG_REALLOC(T, vector, vlen, n);
262 
263  if (n > vlen)
264  memset(&vector[vlen], 0, (n-vlen)*sizeof(T));
265  vlen=n;
266 }
267 
269 template<class T>
271 {
272  ASSERT(x.vector && vector)
273  ASSERT(x.vlen == vlen)
274 
275  SGVector<T> result=clone();
276  result.add(x);
277  return result;
278 }
279 
280 template<class T>
282 {
283  ASSERT(x.vector && vector)
284  ASSERT(x.vlen == vlen)
285 
286  for (int32_t i=0; i<vlen; i++)
287  vector[i]+=x.vector[i];
288 }
289 
290 template<class T>
291 void SGVector<T>::add(const T x)
292 {
293  ASSERT(vector)
294 
295  for (int32_t i=0; i<vlen; i++)
296  vector[i]+=x;
297 }
298 
299 template<class T>
301 {
302  if (x.features)
303  {
304  for (int32_t i=0; i < x.num_feat_entries; i++)
305  {
306  index_t idx = x.features[i].feat_index;
307  ASSERT(idx < vlen)
308  vector[idx] += x.features[i].entry;
309  }
310  }
311 }
312 
313 template<class T>
315 {
316  SG_SPRINT("SGVector '%p' of size: %d\n", vector, vlen)
317 }
318 
319 template<class T>
321 {
322  vector=((SGVector*)(&orig))->vector;
323  vlen=((SGVector*)(&orig))->vlen;
324 }
325 
326 template<class T>
328 {
329  vector=NULL;
330  vlen=0;
331 }
332 
333 template<class T>
335 {
336  SG_FREE(vector);
337  vector=NULL;
338  vlen=0;
339 }
340 
341 template<class T>
343 {
344  if (other.vlen!=vlen)
345  return false;
346 
347  for (index_t i=0; i<vlen; ++i)
348  {
349  if (other.vector[i]!=vector[i])
350  return false;
351  }
352 
353  return true;
354 }
355 
356 template<class T>
357 void SGVector<T>::display_vector(const char* name,
358  const char* prefix) const
359 {
360  display_vector(vector, vlen, name, prefix);
361 }
362 
363 template <class T>
364 void SGVector<T>::display_vector(const SGVector<T> vector, const char* name,
365  const char* prefix)
366 {
367  vector.display_vector(prefix);
368 }
369 
370 template <>
371 void SGVector<bool>::display_vector(const bool* vector, int32_t n, const char* name,
372  const char* prefix)
373 {
374  ASSERT(n>=0)
375  SG_SPRINT("%s%s=[", prefix, name)
376  for (int32_t i=0; i<n; i++)
377  SG_SPRINT("%s%d%s", prefix, vector[i] ? 1 : 0, i==n-1? "" : ",")
378  SG_SPRINT("%s]\n", prefix)
379 }
380 
381 template <>
382 void SGVector<char>::display_vector(const char* vector, int32_t n, const char* name,
383  const char* prefix)
384 {
385  ASSERT(n>=0)
386  SG_SPRINT("%s%s=[", prefix, name)
387  for (int32_t i=0; i<n; i++)
388  SG_SPRINT("%s%c%s", prefix, vector[i], i==n-1? "" : ",")
389  SG_SPRINT("%s]\n", prefix)
390 }
391 
392 template <>
393 void SGVector<uint8_t>::display_vector(const uint8_t* vector, int32_t n, const char* name,
394  const char* prefix)
395 {
396  ASSERT(n>=0)
397  SG_SPRINT("%s%s=[", prefix, name)
398  for (int32_t i=0; i<n; i++)
399  SG_SPRINT("%s%u%s", prefix, vector[i], i==n-1? "" : ",")
400  SG_SPRINT("%s]\n", prefix)
401 }
402 
403 template <>
404 void SGVector<int8_t>::display_vector(const int8_t* vector, int32_t n, const char* name,
405  const char* prefix)
406 {
407  ASSERT(n>=0)
408  SG_SPRINT("%s%s=[", prefix, name)
409  for (int32_t i=0; i<n; i++)
410  SG_SPRINT("%s%d%s", prefix, vector[i], i==n-1? "" : ",")
411  SG_SPRINT("%s]\n", prefix)
412 }
413 
414 template <>
415 void SGVector<uint16_t>::display_vector(const uint16_t* vector, int32_t n, const char* name,
416  const char* prefix)
417 {
418  ASSERT(n>=0)
419  SG_SPRINT("%s%s=[", prefix, name)
420  for (int32_t i=0; i<n; i++)
421  SG_SPRINT("%s%u%s", prefix, vector[i], i==n-1? "" : ",")
422  SG_SPRINT("%s]\n", prefix)
423 }
424 
425 template <>
426 void SGVector<int16_t>::display_vector(const int16_t* vector, int32_t n, const char* name,
427  const char* prefix)
428 {
429  ASSERT(n>=0)
430  SG_SPRINT("%s%s=[", prefix, name)
431  for (int32_t i=0; i<n; i++)
432  SG_SPRINT("%s%d%s", prefix, vector[i], i==n-1? "" : ",")
433  SG_SPRINT("%s]\n", prefix)
434 }
435 
436 template <>
437 void SGVector<int32_t>::display_vector(const int32_t* vector, int32_t n, const char* name,
438  const char* prefix)
439 {
440  ASSERT(n>=0)
441  SG_SPRINT("%s%s=[", prefix, name)
442  for (int32_t i=0; i<n; i++)
443  SG_SPRINT("%s%d%s", prefix, vector[i], i==n-1? "" : ",")
444  SG_SPRINT("%s]\n", prefix)
445 }
446 
447 template <>
448 void SGVector<uint32_t>::display_vector(const uint32_t* vector, int32_t n, const char* name,
449  const char* prefix)
450 {
451  ASSERT(n>=0)
452  SG_SPRINT("%s%s=[", prefix, name)
453  for (int32_t i=0; i<n; i++)
454  SG_SPRINT("%s%u%s", prefix, vector[i], i==n-1? "" : ",")
455  SG_SPRINT("%s]\n", prefix)
456 }
457 
458 
459 template <>
460 void SGVector<int64_t>::display_vector(const int64_t* vector, int32_t n, const char* name,
461  const char* prefix)
462 {
463  ASSERT(n>=0)
464  SG_SPRINT("%s%s=[", prefix, name)
465  for (int32_t i=0; i<n; i++)
466  SG_SPRINT("%s%lld%s", prefix, vector[i], i==n-1? "" : ",")
467  SG_SPRINT("%s]\n", prefix)
468 }
469 
470 template <>
471 void SGVector<uint64_t>::display_vector(const uint64_t* vector, int32_t n, const char* name,
472  const char* prefix)
473 {
474  ASSERT(n>=0)
475  SG_SPRINT("%s%s=[", prefix, name)
476  for (int32_t i=0; i<n; i++)
477  SG_SPRINT("%s%llu%s", prefix, vector[i], i==n-1? "" : ",")
478  SG_SPRINT("%s]\n", prefix)
479 }
480 
481 template <>
482 void SGVector<float32_t>::display_vector(const float32_t* vector, int32_t n, const char* name,
483  const char* prefix)
484 {
485  ASSERT(n>=0)
486  SG_SPRINT("%s%s=[", prefix, name)
487  for (int32_t i=0; i<n; i++)
488  SG_SPRINT("%s%g%s", prefix, vector[i], i==n-1? "" : ",")
489  SG_SPRINT("%s]\n", prefix)
490 }
491 
492 template <>
493 void SGVector<float64_t>::display_vector(const float64_t* vector, int32_t n, const char* name,
494  const char* prefix)
495 {
496  ASSERT(n>=0)
497  SG_SPRINT("%s%s=[", prefix, name)
498  for (int32_t i=0; i<n; i++)
499  SG_SPRINT("%s%.18g%s", prefix, vector[i], i==n-1? "" : ",")
500  SG_SPRINT("%s]\n", prefix)
501 }
502 
503 template <>
504 void SGVector<floatmax_t>::display_vector(const floatmax_t* vector, int32_t n,
505  const char* name, const char* prefix)
506 {
507  ASSERT(n>=0)
508  SG_SPRINT("%s%s=[", prefix, name)
509  for (int32_t i=0; i<n; i++)
510  {
511  SG_SPRINT("%s%.36Lg%s", prefix, (long double) vector[i],
512  i==n-1? "" : ",");
513  }
514  SG_SPRINT("%s]\n", prefix)
515 }
516 
517 template <>
519  const char* name, const char* prefix)
520 {
521  ASSERT(n>=0)
522  SG_SPRINT("%s%s=[", prefix, name)
523  for (int32_t i=0; i<n; i++)
524  {
525  SG_SPRINT("%s(%.36lg+i%.36lg)%s", prefix, vector[i].real(),
526  vector[i].imag(), i==n-1? "" : ",");
527  }
528  SG_SPRINT("%s]\n", prefix)
529 }
530 
531 template <class T>
533  const T scalar, const T* vec2, int32_t n)
534 {
535  for (int32_t i=0; i<n; i++)
536  vec1[i]+=scalar*vec2[i];
537 }
538 
539 template <>
541  float64_t scalar, const float64_t* vec2, int32_t n)
542 {
543 #ifdef HAVE_LAPACK
544  int32_t skip=1;
545  cblas_daxpy(n, scalar, vec2, skip, vec1, skip);
546 #else
547  for (int32_t i=0; i<n; i++)
548  vec1[i]+=scalar*vec2[i];
549 #endif
550 }
551 
552 template <>
554  float32_t scalar, const float32_t* vec2, int32_t n)
555 {
556 #ifdef HAVE_LAPACK
557  int32_t skip=1;
558  cblas_saxpy(n, scalar, vec2, skip, vec1, skip);
559 #else
560  for (int32_t i=0; i<n; i++)
561  vec1[i]+=scalar*vec2[i];
562 #endif
563 }
564 
565 template <class T>
566  void SGVector<T>::random_vector(T* vec, int32_t len, T min_value, T max_value)
567  {
568  for (int32_t i=0; i<len; i++)
569  vec[i]=CMath::random(min_value, max_value);
570  }
571 
572 template <>
574  complex128_t min_value, complex128_t max_value)
575 {
577 }
578 
579 template <>
580 bool SGVector<bool>::twonorm(const bool* x, int32_t len)
581 {
583  return false;
584 }
585 
586 template <>
587 char SGVector<char>::twonorm(const char* x, int32_t len)
588 {
590  return '\0';
591 }
592 
593 template <>
594 int8_t SGVector<int8_t>::twonorm(const int8_t* x, int32_t len)
595 {
596  float64_t result=0;
597  for (int32_t i=0; i<len; i++)
598  result+=x[i]*x[i];
599 
600  return CMath::sqrt(result);
601 }
602 
603 template <>
604 uint8_t SGVector<uint8_t>::twonorm(const uint8_t* x, int32_t len)
605 {
606  float64_t result=0;
607  for (int32_t i=0; i<len; i++)
608  result+=x[i]*x[i];
609 
610  return CMath::sqrt(result);
611 }
612 
613 template <>
614 int16_t SGVector<int16_t>::twonorm(const int16_t* x, int32_t len)
615 {
616  float64_t result=0;
617  for (int32_t i=0; i<len; i++)
618  result+=x[i]*x[i];
619 
620  return CMath::sqrt(result);
621 }
622 
623 template <>
624 uint16_t SGVector<uint16_t>::twonorm(const uint16_t* x, int32_t len)
625 {
626  float64_t result=0;
627  for (int32_t i=0; i<len; i++)
628  result+=x[i]*x[i];
629 
630  return CMath::sqrt(result);
631 }
632 
633 template <>
634 int32_t SGVector<int32_t>::twonorm(const int32_t* x, int32_t len)
635 {
636  float64_t result=0;
637  for (int32_t i=0; i<len; i++)
638  result+=x[i]*x[i];
639 
640  return CMath::sqrt(result);
641 }
642 
643 template <>
644 uint32_t SGVector<uint32_t>::twonorm(const uint32_t* x, int32_t len)
645 {
646  float64_t result=0;
647  for (int32_t i=0; i<len; i++)
648  result+=x[i]*x[i];
649 
650  return CMath::sqrt(result);
651 }
652 
653 template <>
654 int64_t SGVector<int64_t>::twonorm(const int64_t* x, int32_t len)
655 {
656  float64_t result=0;
657  for (int32_t i=0; i<len; i++)
658  result+=x[i]*x[i];
659 
660  return CMath::sqrt(result);
661 }
662 
663 template <>
664 uint64_t SGVector<uint64_t>::twonorm(const uint64_t* x, int32_t len)
665 {
666  float64_t result=0;
667  for (int32_t i=0; i<len; i++)
668  result+=x[i]*x[i];
669 
670  return CMath::sqrt(result);
671 }
672 
673 template <>
675 {
676  float64_t result=0;
677  for (int32_t i=0; i<len; i++)
678  result+=x[i]*x[i];
679 
680  return CMath::sqrt(result);
681 }
682 
683 template <>
685 {
686  float64_t norm = 0.0;
687 #ifdef HAVE_LAPACK
688  norm = cblas_dnrm2(n, v, 1);
689 #else
690  norm = CMath::sqrt(CMath::dot(v, v, n));
691 #endif
692  return norm;
693 }
694 
695 template <>
697 {
698  float64_t result=0;
699  for (int32_t i=0; i<len; i++)
700  result+=x[i]*x[i];
701 
702  return CMath::sqrt(result);
703 }
704 
705 template <>
707 {
708  complex128_t result(0.0);
709  for (int32_t i=0; i<len; i++)
710  result+=x[i]*x[i];
711 
712  return CMath::sqrt(result);
713 }
714 
715 template <class T>
716 float64_t SGVector<T>::onenorm(T* x, int32_t len)
717 {
718  float64_t result=0;
719  for (int32_t i=0;i<len; ++i)
720  result+=CMath::abs(x[i]);
721 
722  return result;
723 }
724 
726 template <class T>
727 T SGVector<T>::qsq(T* x, int32_t len, float64_t q)
728 {
729  float64_t result=0;
730  for (int32_t i=0; i<len; i++)
731  result+=CMath::pow(fabs(x[i]), q);
732 
733  return result;
734 }
735 
736 template <>
738 {
740  return complex128_t(0.0);
741 }
742 
744 template <class T>
745 T SGVector<T>::qnorm(T* x, int32_t len, float64_t q)
746 {
747  ASSERT(q!=0)
748  return CMath::pow((float64_t) qsq(x, len, q), 1.0/q);
749 }
750 
751 template <>
753 {
755  return complex128_t(0.0);
756 }
757 
759 template <class T>
760 T SGVector<T>::sum_abs(T* vec, int32_t len)
761 {
762  T result=0;
763  for (int32_t i=0; i<len; i++)
764  result+=CMath::abs(vec[i]);
765 
766  return result;
767 }
768 
769 #if HAVE_LAPACK
770 template <>
772 {
773  float64_t result=0;
774  result = cblas_dasum(len, vec, 1);
775  return result;
776 }
777 
778 template <>
780 {
781  float32_t result=0;
782  result = cblas_sasum(len, vec, 1);
783  return result;
784 }
785 #endif
786 
787 template <class T>
788 int32_t SGVector<T>::unique(T* output, int32_t size)
789 {
790  CMath::qsort<T>(output, size);
791  int32_t j=0;
792 
793  for (int32_t i=0; i<size; i++)
794  {
795  if (i==0 || output[i]!=output[i-1])
796  output[j++]=output[i];
797  }
798  return j;
799 }
800 
801 template <>
802 int32_t SGVector<complex128_t>::unique(complex128_t* output, int32_t size)
803 {
804  int32_t j=0;
805  SG_SERROR("SGVector::unique():: Not supported for complex128_t\n");
806  return j;
807 }
808 
809 template <class T>
811 {
812  SGVector<index_t> idx(vlen);
813  index_t k=0;
814 
815  for (index_t i=0; i < vlen; ++i)
816  if (vector[i] == elem)
817  idx[k++] = i;
818  idx.vlen = k;
819  return idx;
820 }
821 
822 template<class T>
823 void SGVector<T>::scale_vector(T alpha, T* vec, int32_t len)
824 {
825  for (int32_t i=0; i<len; i++)
826  vec[i]*=alpha;
827 }
828 
829 #ifdef HAVE_LAPACK
830 template<>
832 {
833  cblas_dscal(len, alpha, vec, 1);
834 }
835 
836 template<>
838 {
839  cblas_sscal(len, alpha, vec, 1);
840 }
841 #endif
842 
843 template<class T>
844 void SGVector<T>::scale(T alpha)
845 {
846  scale_vector(alpha, vector, vlen);
847 }
848 
849 template<class T> void SGVector<T>::load(CFile* loader)
850 {
851  ASSERT(loader)
852  unref();
853 
855  SGVector<T> vec;
856  loader->get_vector(vec.vector, vec.vlen);
857  copy_data(vec);
858  copy_refcount(vec);
859  ref();
861 }
862 
863 template<>
865 {
866  SG_SERROR("SGVector::load():: Not supported for complex128_t\n");
867 }
868 
869 template<class T> void SGVector<T>::save(CFile* saver)
870 {
871  ASSERT(saver)
872 
874  saver->set_vector(vector, vlen);
876 }
877 
878 template<>
880 {
881  SG_SERROR("SGVector::save():: Not supported for complex128_t\n");
882 }
883 
885 {
886  SGVector<float64_t> real(vlen);
887  for (int32_t i=0; i<vlen; i++)
888  real[i]=CMath::real(vector[i]);
889  return real;
890 }
891 
893 {
894  SGVector<float64_t> imag(vlen);
895  for (int32_t i=0; i<vlen; i++)
896  imag[i]=CMath::imag(vector[i]);
897  return imag;
898 }
899 
900 template <class T>
902  index_t nrows, index_t ncols, bool fortran_order)
903 {
904  if (nrows*ncols>vector.size())
905  SG_SERROR("SGVector::convert_to_matrix():: Dimensions mismatch\n");
906 
907  T* data=NULL;
908  SGVector<T>::convert_to_matrix(data, nrows, ncols, vector.vector, vector.vlen, fortran_order);
909 
910  SGMatrix<T> matrix=SGMatrix<T>(data, nrows, ncols);
911  return matrix;
912 }
913 
914 template <class T>
915 void SGVector<T>::convert_to_matrix(T*& matrix, index_t nrows, index_t ncols, const T* vector, int32_t vlen, bool fortran_order)
916 {
917  if (nrows*ncols>vlen)
918  SG_SERROR("SGVector::convert_to_matrix():: Dimensions mismatch\n");
919 
920  if (matrix!=NULL)
921  SG_FREE(matrix);
922  matrix=SG_MALLOC(T, nrows*ncols);
923 
924  if (fortran_order)
925  {
926  for (index_t i=0; i<ncols*nrows; i++)
927  matrix[i]=vector[i];
928  }
929  else
930  {
931  for (index_t i=0; i<nrows; i++)
932  {
933  for (index_t j=0; j<ncols; j++)
934  matrix[i+j*nrows]=vector[j+i*ncols];
935  }
936  }
937 }
938 
939 #define UNDEFINED(function, type) \
940 template <> \
941 SGVector<float64_t> SGVector<type>::function() \
942 { \
943  SG_SERROR("SGVector::%s():: Not supported for %s\n", \
944  #function, #type); \
945  SGVector<float64_t> ret(vlen); \
946  return ret; \
947 }
948 
949 UNDEFINED(get_real, bool)
950 UNDEFINED(get_real, char)
951 UNDEFINED(get_real, int8_t)
952 UNDEFINED(get_real, uint8_t)
953 UNDEFINED(get_real, int16_t)
954 UNDEFINED(get_real, uint16_t)
955 UNDEFINED(get_real, int32_t)
956 UNDEFINED(get_real, uint32_t)
957 UNDEFINED(get_real, int64_t)
958 UNDEFINED(get_real, uint64_t)
959 UNDEFINED(get_real, float32_t)
960 UNDEFINED(get_real, float64_t)
961 UNDEFINED(get_real, floatmax_t)
962 UNDEFINED(get_imag, bool)
963 UNDEFINED(get_imag, char)
964 UNDEFINED(get_imag, int8_t)
965 UNDEFINED(get_imag, uint8_t)
966 UNDEFINED(get_imag, int16_t)
967 UNDEFINED(get_imag, uint16_t)
968 UNDEFINED(get_imag, int32_t)
969 UNDEFINED(get_imag, uint32_t)
970 UNDEFINED(get_imag, int64_t)
971 UNDEFINED(get_imag, uint64_t)
972 UNDEFINED(get_imag, float32_t)
973 UNDEFINED(get_imag, float64_t)
974 UNDEFINED(get_imag, floatmax_t)
975 #undef UNDEFINED
976 
977 template class SGVector<bool>;
978 template class SGVector<char>;
979 template class SGVector<int8_t>;
980 template class SGVector<uint8_t>;
981 template class SGVector<int16_t>;
982 template class SGVector<uint16_t>;
983 template class SGVector<int32_t>;
984 template class SGVector<uint32_t>;
985 template class SGVector<int64_t>;
986 template class SGVector<uint64_t>;
987 template class SGVector<float32_t>;
988 template class SGVector<float64_t>;
989 template class SGVector<floatmax_t>;
990 template class SGVector<complex128_t>;
991 }
992 
993 #undef COMPLEX128_ERROR_NOARG
994 #undef COMPLEX128_ERROR_ONEARG
995 #undef COMPLEX128_ERROR_TWOARGS
996 #undef COMPLEX128_ERROR_THREEARGS

SHOGUN Machine Learning Toolbox - Documentation