libdspl-2.0
Библиотека алгоритмов цифровой обработки сигналов
inout.c
1 /*
2 * Copyright (c) 2015-2019 Sergey Bakhurin
3 * Digital Signal Processing Library [http://dsplib.org]
4 *
5 * This file is part of DSPL.
6 *
7 * is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * DSPL is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
19 */
20 
21 
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 
26 #include "dspl.h"
27 
28 
29 
30 /*******************************************************************************
31 Print DSPL info
32 *******************************************************************************/
33 void DSPL_API dspl_info()
34 {
35  printf("\n\n D S P L - 2.0\n");
36  printf(" version 2.20.01.09\n");
37  printf("\n Copyright (C) 2015-2020\n");
38  printf(" Sergey Bakhurin www.dsplib.org\n");
39  printf(" ---------------------------------------------\n");
40  printf(" BLAS and LAPACK ver.: 3.8.0 www.netlib.org\n");
41 
42 }
43 
44 
45 
46 /******************************************************************************
47 Write a real array to the binary file "fn"
48 *******************************************************************************/
49 int DSPL_API readbin(char* fn, void** x, int* k, int* dtype)
50 {
51  FILE* pFile = NULL;
52  int n, m, t, err;
53 
54  if(!x)
55  return ERROR_PTR;
56  if(!fn)
57  return ERROR_FNAME;
58 
59  pFile = fopen(fn, "rb");
60  if(pFile == NULL)
61  return ERROR_FOPEN;
62 
63  if(fread(&t, sizeof(int), 1, pFile) != 1)
64  {
65  err = ERROR_FREAD_SIZE;
66  goto exit_label;
67  }
68 
69  if(dtype)
70  *dtype = t;
71 
72  if(fread(&n, sizeof(int), 1, pFile) != 1)
73  {
74  err = ERROR_FREAD_SIZE;
75  goto exit_label;
76  }
77 
78  if(fread(&m, sizeof(int), 1, pFile) != 1)
79  {
80  err = ERROR_FREAD_SIZE;
81  goto exit_label;
82  }
83 
84  if(k)
85  *k = n*m;
86 
87  switch(t)
88  {
89  case DAT_DOUBLE:
90  (*x) = (*x) ? realloc(*x, n*m*sizeof(double)) :
91  malloc(n*m*sizeof(double));
92  if(fread(*x, sizeof(double), n*m, pFile) != n*m)
93  {
94  err = ERROR_FREAD_SIZE;
95  goto exit_label;
96  }
97 
98  break;
99  case DAT_COMPLEX:
100  (*x) = (*x) ? realloc(*x, n*m*sizeof(complex_t)) :
101  malloc(n*m*sizeof(complex_t));
102  if(fread(*x, sizeof(complex_t), n*m, pFile) != n*m)
103  {
104  err = ERROR_FREAD_SIZE;
105  goto exit_label;
106  }
107  default:
108  err = ERROR_DAT_TYPE;
109  goto exit_label;
110  }
111  err = RES_OK;
112 exit_label:
113  if(pFile)
114  fclose(pFile);
115  return err;
116 }
117 
118 
119 
120 /******************************************************************************
121 Write a real array to the binary file "fn"
122 *******************************************************************************/
123 int DSPL_API writebin(void* x, int n, int dtype, char* fn)
124 {
125  int k, res;
126  FILE* pFile = NULL;
127 
128  if(!x)
129  return ERROR_PTR;
130  if(n < 1)
131  return ERROR_SIZE;
132  if(!fn)
133  return ERROR_FNAME;
134 
135  pFile = fopen(fn, "wb");
136  if(pFile == NULL)
137  return ERROR_FOPEN;
138 
139 
140  if(fwrite(&dtype, sizeof(int), 1, pFile) != 1)
141  {
142  res = ERROR_FWRITE_SIZE;
143  goto exit_label;
144  }
145 
146 
147  if(fwrite(&n, sizeof(int), 1, pFile) != 1)
148  {
149  res = ERROR_FWRITE_SIZE;
150  goto exit_label;
151  }
152 
153  k = 1;
154  if(fwrite(&k, sizeof(int), 1, pFile) != 1)
155  {
156  res = ERROR_FWRITE_SIZE;
157  goto exit_label;
158  };
159 
160  switch(dtype)
161  {
162  case DAT_DOUBLE:
163  if(fwrite((double*)x, sizeof(double), n, pFile) != n)
164  {
165  res = ERROR_FWRITE_SIZE;
166  goto exit_label;
167  }
168  break;
169  case DAT_COMPLEX:
170  if(fwrite((complex_t*)x,
171  sizeof(complex_t), n, pFile) != n)
172  {
173  res = ERROR_FWRITE_SIZE;
174  goto exit_label;
175  }
176  break;
177  default:
178  res = ERROR_DAT_TYPE;
179  goto exit_label;
180  }
181  res = RES_OK;
182 exit_label:
183  if(pFile)
184  fclose(pFile);
185  return res;
186 }
187 
188 
189 
190 
191 
192 
193 /******************************************************************************
194 Write a real arrays to the text file "fn"
195 *******************************************************************************/
196 int DSPL_API writetxt(double* x, double* y, int n, char* fn)
197 {
198  int k;
199  FILE* pFile = NULL;
200  if(!x)
201  return ERROR_PTR;
202  if(n < 1)
203  return ERROR_SIZE;
204  if(!fn)
205  return ERROR_FNAME;
206 
207  pFile = fopen(fn, "w+");
208  if(pFile == NULL)
209  return ERROR_FOPEN;
210 
211  if(y)
212  for(k = 0; k < n; k++)
213  fprintf(pFile, "%+.12E\t%+.12E\n", x[k], y[k]);
214 
215  else
216  for(k = 0; k < n; k++)
217  fprintf(pFile, "%+.12E\n", x[k]);
218 
219 
220  fclose(pFile);
221  return RES_OK;
222 }
223 
224 
225 /******************************************************************************
226 Write a int arrays to the text file "fn"
227 *******************************************************************************/
228 int DSPL_API writetxt_int(int* x, int* y, int n, char* fn)
229 {
230  int k;
231  FILE* pFile = NULL;
232  if(!x)
233  return ERROR_PTR;
234  if(n < 1)
235  return ERROR_SIZE;
236  if(!fn)
237  return ERROR_FNAME;
238 
239  pFile = fopen(fn, "w+");
240  if(pFile == NULL)
241  return ERROR_FOPEN;
242 
243  if(y)
244  for(k = 0; k < n; k++)
245  fprintf(pFile, "% -14d\t% -14d\n", x[k], y[k]);
246 
247  else
248  for(k = 0; k < n; k++)
249  fprintf(pFile, "% -.14d\n", x[k]);
250 
251  fclose(pFile);
252  return RES_OK;
253 }
254 
255 
256 
257 /******************************************************************************
258  * Write a 3d plot data to file "fn" (pgfplots3d acceptable)
259  ******************************************************************************/
260 int DSPL_API writetxt_3d(double* x, int nx, double* y, int ny,
261  double* z, char* fn)
262 {
263  int k, n;
264  FILE* pFile = NULL;
265 
266  if(!x || !y || !z)
267  return ERROR_PTR;
268  if(nx < 1 || ny < 1)
269  return ERROR_SIZE;
270  if(!fn)
271  return ERROR_FNAME;
272 
273  pFile = fopen(fn, "w+");
274  if(pFile == NULL)
275  return ERROR_FOPEN;
276 
277  for(k = 0; k < ny; k++)
278  {
279  for(n = 0; n < nx; n++)
280  fprintf(pFile, "%+.12E\t%+.12E\t%+.12E\n",
281  x[n], y[k], z[n+k*nx]);
282  fprintf(pFile, "\n");
283 
284  }
285  fclose(pFile);
286  return RES_OK;
287 }
288 
289 
290 
291 
292 
293 
294 
295 /******************************************************************************
296  * Write a 3d line data to file "fn" (pgfplots3d acceptable)
297  ******************************************************************************/
298 int DSPL_API writetxt_3dline(double* x, double *y, double* z, int n, char* fn)
299 {
300  int k;
301  FILE* pFile = NULL;
302 
303  if(!x || !y || !z)
304  return ERROR_PTR;
305  if(n < 1)
306  return ERROR_SIZE;
307  if(!fn)
308  return ERROR_FNAME;
309 
310  pFile = fopen(fn, "w+");
311  if(pFile == NULL)
312  return ERROR_FOPEN;
313 
314  for(k = 0; k < n; k++)
315  fprintf(pFile, "%+.12E\t%+.12E\t%+.12E\n", x[k], y[k], z[k]);
316  fprintf(pFile, "\n");
317  fclose(pFile);
318  return RES_OK;
319 }
320 
321 
322 
323 
324 /******************************************************************************
325 Write a real part of complex array to the text file "fn"
326 *******************************************************************************/
327 int DSPL_API writetxt_cmplx_re(double* x, complex_t *y, int n, char* fn)
328 {
329  int k;
330  FILE* pFile = NULL;
331 
332  if(!x)
333  return ERROR_PTR;
334  if(n < 1)
335  return ERROR_SIZE;
336  if(!fn)
337  return ERROR_FNAME;
338 
339  pFile = fopen(fn, "w+");
340  if(pFile == NULL)
341  return ERROR_FOPEN;
342 
343  if(x)
344  for(k = 0; k < n; k++)
345  fprintf(pFile, "%+.12E\t%+.12E\n", x[k], RE(y[k]));
346  else
347  for(k = 0; k < n; k++)
348  fprintf(pFile, "%+.12E\n", RE(y[k]));
349 
350  fclose(pFile);
351  return RES_OK;
352 }
353 
354 
355 
356 /******************************************************************************
357 Write a image part of complex array to the text file "fn"
358 *******************************************************************************/
359 int DSPL_API writetxt_cmplx_im(double* x, complex_t *y, int n, char* fn)
360 {
361  int k;
362  FILE* pFile = NULL;
363 
364  if(!x)
365  return ERROR_PTR;
366  if(n < 1)
367  return ERROR_SIZE;
368  if(!fn)
369  return ERROR_FNAME;
370 
371  pFile = fopen(fn, "w+");
372  if(pFile == NULL)
373  return ERROR_FOPEN;
374 
375  if(x)
376  for(k = 0; k < n; k++)
377  fprintf(pFile, "%+.12E\t%+.12E\n", x[k], IM(y[k]));
378  else
379  for(k = 0; k < n; k++)
380  fprintf(pFile, "%+.12E\n", IM(y[k]));
381 
382  fclose(pFile);
383  return RES_OK;
384 }
385 
#define ERROR_FOPEN
Ошибка открытия файла. Файл с заданным именем не может быть открыт для записи и (или) чтения.
Definition: dspl.h:119
int writebin(void *x, int n, int dtype, char *fn)
Сохранить данные в бинарный файл
Definition: inout.c:123
int writetxt_int(int *x, int *y, int n, char *fn)
Сохранить целочисленные данные в текстовый файл
Definition: inout.c:228
#define RE(x)
Макрос определяющий реальную часть комплексного числа.
Definition: dspl.h:77
#define ERROR_PTR
Ошибка указателя. Данная ошибка означает, что один из обязательных указателей (память под который дол...
Definition: dspl.h:142
#define ERROR_SIZE
Ошибка при передаче размера массива. Данная ошибка возникает когда помимо указателя на массив входных...
Definition: dspl.h:150
#define ERROR_FNAME
Ошибка в имени файла. Необходимо задать корректное имя файла.
Definition: dspl.h:118
#define ERROR_FREAD_SIZE
Ошибка чтения блока данных из бинарного файла. Ошибка возникает, если при чтении блока данных из файл...
Definition: dspl.h:120
int writetxt_3d(double *x, int nx, double *y, int ny, double *z, char *fn)
Сохранить данные для построения 3D графика
Definition: inout.c:260
int writetxt(double *x, double *y, int n, char *fn)
Сохранить вещественные данные в текстовый файл
Definition: inout.c:196
double complex_t[2]
Описание комплексного типа данных.
Definition: dspl.h:41
#define RES_OK
Функция завершилась корректно. Ошибки отсутствуют.
Definition: dspl.h:94
#define ERROR_FWRITE_SIZE
Ошибка записи блока данных в бинарный файла. Ошибка возникает, если при записи блока данных в файл,...
Definition: dspl.h:121
#define ERROR_DAT_TYPE
Неверный тип данных. Данная ошибка возникает при сохранении данных в бинарный файл,...
Definition: dspl.h:102
#define IM(x)
Макрос определяющий мнимую часть комплексного числа.
Definition: dspl.h:78