IsoSpec  2.1.2
misc.h
1 /*
2  * Copyright (C) 2015-2020 Mateusz Łącki and Michał Startek.
3  *
4  * This file is part of IsoSpec.
5  *
6  * IsoSpec is free software: you can redistribute it and/or modify
7  * it under the terms of the Simplified ("2-clause") BSD licence.
8  *
9  * IsoSpec is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12  *
13  * You should have received a copy of the Simplified BSD Licence
14  * along with IsoSpec. If not, see <https://opensource.org/licenses/BSD-2-Clause>.
15  */
16 
17 #pragma once
18 
19 #include <iostream>
20 #include <vector>
21 #include <cstring>
22 #include <algorithm>
23 #include "isoMath.h"
24 #include "pod_vector.h"
25 
26 namespace IsoSpec
27 {
28 
29 inline double combinedSum(
30  const int* conf, const std::vector<double>** valuesContainer, int dimNumber
31 ){
32  double res = 0.0;
33  for(int i = 0; i < dimNumber; i++)
34  res += (*(valuesContainer[i]))[conf[i]];
35  return res;
36 }
37 
38 inline double combinedSum(
39  const int* conf, const pod_vector<double>** valuesContainer, int dimNumber
40 ){
41  double res = 0.0;
42  for(int i = 0; i < dimNumber; i++)
43  res += (*(valuesContainer[i]))[conf[i]];
44  return res;
45 }
46 
47 inline int* getConf(void* conf)
48 {
49  return reinterpret_cast<int*>(
50  reinterpret_cast<char*>(conf) + sizeof(double)
51  );
52 }
53 
54 inline double getLProb(void* conf)
55 {
56  double ret = *reinterpret_cast<double*>(conf);
57  return ret;
58 }
59 
60 
61 inline double unnormalized_logProb(const int* conf, const double* logProbs, int dim)
62 {
63  double res = 0.0;
64 
65  for(int i = 0; i < dim; i++)
66  res += minuslogFactorial(conf[i]) + conf[i] * logProbs[i];
67 
68  return res;
69 }
70 
71 inline double calc_mass(const int* conf, const double* masses, int dim)
72 {
73  double res = 0.0;
74 
75  for(int i = 0; i < dim; i++)
76  {
77  res += conf[i] * masses[i];
78  }
79 
80  return res;
81 }
82 
83 
84 
85 template<typename T> void printArray(const T* array, int size, const char* prefix = "")
86 {
87  if (strlen(prefix) > 0)
88  std::cout << prefix << " ";
89  for (int i = 0; i < size; i++)
90  std::cout << array[i] << " ";
91  std::cout << std::endl;
92 }
93 
94 template<typename T> void printVector(const std::vector<T>& vec)
95 {
96  printArray<T>(vec.data(), vec.size());
97 }
98 
99 template<typename T> void printOffsets(const T** array, int size, const T* offset, const char* prefix = "")
100 {
101  if (strlen(prefix) > 0)
102  std::cout << prefix << " ";
103  for (int i = 0; i < size; i++)
104  std::cout << array[i] - offset << " ";
105  std::cout << std::endl;
106 }
107 
108 template<typename T> void printNestedArray(const T** array, const int* shape, int size)
109 {
110  for (int i = 0; i < size; i++)
111  printArray(array[i], shape[i]);
112  std::cout << std::endl;
113 }
114 
116 void* quickselect(const void** array, int n, int start, int end);
117 
118 
119 template <typename T> inline static T* array_copy(const T* A, int size)
120 {
121  T* ret = new T[size];
122  memcpy(ret, A, size*sizeof(T));
123  return ret;
124 }
125 
126 template <typename T> static T* array_copy_nptr(const T* A, int size)
127 {
128  if(A == nullptr)
129  return nullptr;
130  return array_copy(A, size);
131 }
132 
133 template<typename T> void dealloc_table(T* tbl, int dim)
134 {
135  for(int i = 0; i < dim; i++)
136  {
137  delete tbl[i];
138  }
139  delete[] tbl;
140 }
141 
142 template<typename T> void realloc_append(T** array, T what, size_t old_array_size)
143 {
144  T* newT = new T[old_array_size+1];
145  memcpy(newT, *array, old_array_size*sizeof(T));
146  newT[old_array_size] = what;
147  delete[] *array;
148  *array = newT;
149 }
150 
151 template<typename T> size_t* get_order(T* order_array, size_t N)
152 {
153  size_t* arr = new size_t[N];
154  for(size_t ii = 0; ii < N; ii++)
155  arr[ii] = ii;
156 
157  std::sort(arr, arr + N, [&](int i, int j) { return order_array[i] < order_array[j]; });
158 
159  return arr;
160 }
161 
162 template<typename T> size_t* get_inverse_order(T* order_array, size_t N)
163 {
164  size_t* arr = new size_t[N];
165  for(size_t ii = 0; ii < N; ii++)
166  arr[ii] = ii;
167 
168  std::sort(arr, arr + N, [&](int i, int j) { return order_array[i] > order_array[j]; });
169 
170  return arr;
171 }
172 
173 template<typename TA, typename TB> void impose_order(size_t* O, size_t N, TA* A, TB* B)
174 {
175  for(size_t ii = 0; ii < N; ii++)
176  {
177  if(ii != O[ii])
178  {
179  size_t curr_ii = ii;
180  TA ta = A[ii];
181  TB tb = B[ii];
182  size_t next_ii = O[ii];
183  while(next_ii != ii)
184  {
185  A[curr_ii] = A[next_ii];
186  B[curr_ii] = B[next_ii];
187  O[curr_ii] = curr_ii;
188  curr_ii = next_ii;
189  next_ii = O[next_ii];
190  }
191  A[curr_ii] = ta;
192  B[curr_ii] = tb;
193  O[curr_ii] = curr_ii;
194  }
195  }
196 }
197 
198 
199 } // namespace IsoSpec
pod_vector< double >
IsoSpec
Definition: allocator.cpp:20