IsoSpec 2.2.1
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
26namespace IsoSpec
27{
28
29inline 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
38inline 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
47inline int* getConf(void* conf)
48{
49 return reinterpret_cast<int*>(
50 reinterpret_cast<char*>(conf) + sizeof(double)
51 );
52}
53
54inline double getLProb(void* conf)
55{
56 double ret = *reinterpret_cast<double*>(conf);
57 return ret;
58}
59
60
61inline 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
71inline 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
85template<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
94template<typename T> void printVector(const std::vector<T>& vec)
95{
96 printArray<T>(vec.data(), vec.size());
97}
98
99template<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
108template<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
116void* quickselect(const void** array, int n, int start, int end);
117
118
119template <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
126template <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
133template<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
142template<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
151template<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
162template<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
173template<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