SDDS ToolKit Programs and Libraries for C and Python
Loading...
Searching...
No Matches
sddssampledist.c
Go to the documentation of this file.
1/**
2 * @file sddssampledist.c
3 * @brief Generates sampled distributions based on input SDDS files or direct specifications.
4 *
5 * @details
6 * This program generates samples from specified distributions (Gaussian, Uniform, Poisson)
7 * or based on cumulative distribution functions (CDF/DF) provided in input SDDS files. It
8 * supports various options to customize the sampling process, including the number of samples,
9 * random seed, verbosity, and output ordering.
10 *
11 * @section Usage
12 * ```
13 * sddssampledist [<inputfile>] [<outputfile>]
14 * [-pipe=[in][,out]]
15 * -columns=independentVariable=<name>,{cdf=<CDFName> | df=<DFName>}[,output=<name>][,units=<string>][,factor=<value>][,offset=<value>][,datafile=<filename>][,haltonRadix=<primeNumber>[,haltonOffset=<integer>][,randomize[,group=<groupID>]]]
16 * [-columns=...]
17 * -samples=<integer>
18 * [-seed=<integer>]
19 * [-verbose]
20 * [-gaussian=columnName=<columnName>[,meanValue=<value>|@<parameter_name>][,sigmaValue=<value>|@<parameter_name>][,units=<string>]]
21 * [-uniform=columnName=<columnName>[,minimumValue=<value>|@<parameter_name>][,maximumValue=<value>|@<parameter_name>][,units=<string>]]
22 * [-poisson=columnName=<columnName>[,meanValue=<value>|@<parameter_name>][,units=<string>]]
23 * [-optimalHalton]
24 * [-majorOrder=row|column]
25 * [-threads=<number>]
26 * ```
27 *
28 * @section Options
29 * | Required | Description |
30 * |---------------------------------------|---------------------------------------------------------------------------------------|
31 * | `-columns` | Defines independent variable and distribution function with customization options. |
32 * | `-samples` | Specifies the number of samples to generate. |
33 *
34 * | Optional | Description |
35 * |---------------------------------------|---------------------------------------------------------------------------------------|
36 * | `-pipe` | Use standard input and/or output streams. |
37 * | `-seed` | Specifies the seed for the random number generator. |
38 * | `-verbose` | Enables verbose output. |
39 * | `-gaussian` | Samples from a Gaussian distribution. |
40 * | `-uniform` | Samples from a Uniform distribution. |
41 * | `-poisson` | Samples from a Poisson distribution. |
42 * | `-majorOrder` | Specifies the output file order as row-major or column-major. |
43 * | `-threads` | Number of datafile-backed distributions to read concurrently. |
44 *
45 * @subsection Incompatibilities
46 * - `-columns`
47 * - Requires at least one `independentVariable` and exactly one of `cdf` or `df`.
48 * - If `haltonRadix` is used, the value must be a prime number.
49 * - Randomization requires valid group identifiers if `group=<groupID>` is specified.
50 *
51 * @copyright
52 * - (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
53 * - (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.
54 *
55 * @license
56 * This file is distributed under the terms of the Software License Agreement
57 * found in the file LICENSE included with this distribution.
58 *
59 * @authors
60 * M. Borland, R. Soliday, H. Shang
61 */
62
63#include "mdb.h"
64#include "scan.h"
65#include "SDDS.h"
66#include <time.h>
67
68/* Enumeration for option types */
69enum option_type {
70 CLO_PIPE,
71 CLO_COLUMNS,
72 CLO_SAMPLES,
73 CLO_SEED,
74 CLO_VERBOSE,
75 CLO_GAUSSIAN,
76 CLO_UNIFORM,
77 CLO_POISSON,
78 CLO_OPTIMAL_HALTON,
79 CLO_MAJOR_ORDER,
80 CLO_THREADS,
81 CLO_OPTIONS
82};
83
84static char *option[CLO_OPTIONS] = {
85 "pipe",
86 "columns",
87 "samples",
88 "seed",
89 "verbose",
90 "gaussian",
91 "uniform",
92 "poisson",
93 "optimalHalton",
94 "majorOrder",
95 "threads",
96};
97
98char *USAGE1 =
99 "Usage: sddssampledist [<input>] [<output>] [-pipe=[in][,out]]\n"
100 " -columns=independentVariable=<name>,{cdf=<CDFName> | df=<DFName>}"
101 "[,output=<name>][,units=<string>][,factor=<value>][,offset=<value>]"
102 "[,datafile=<filename>][,haltonRadix=<primeNumber>[,haltonOffset=<integer>]"
103 "[,randomize[,group=<groupID>]]]\n"
104 " [-columns=...] [-samples=<integer>] [-seed=<integer>] [-verbose]\n"
105 " [-gaussian=columnName=<columnName>[,meanValue=<value>|@<parameter_name>]"
106 "[,sigmaValue=<value>|@<parameter_name>][,units=<string>]]\n"
107 " [-uniform=columnName=<columnName>[,minimumValue=<value>|@<parameter_name>]"
108 "[,maximumValue=<value>|@<parameter_name>][,units=<string>]]\n"
109 " [-poisson=columnName=<columnName>[,meanValue=<value>|@<parameter_name>]"
110 "[,units=<string>]] [-optimalHalton] [-majorOrder=row|column] [-threads=<number>]\n";
111
112char *USAGE2 =
113 "Options:\n"
114 " -columns Specifies the independent variable and its distribution.\n"
115 " Usage:\n"
116 " -columns=independentVariable=<name>,{cdf=<CDFName> | df=<DFName>}\n"
117 " [,output=<name>][,units=<string>][,factor=<value>][,offset=<value>]\n"
118 " [,datafile=<filename>][,haltonRadix=<primeNumber>]\n"
119 " [,haltonOffset=<integer>][,randomize[,group=<groupID>]]\n"
120 " Description:\n"
121 " Defines the independent variable and its distribution function (CDF or DF).\n"
122 " Additional qualifiers allow for customization of output names, units,\n"
123 " scaling factors, offsets, data sources, Halton sequence parameters,\n"
124 " and randomization groups.\n\n"
125 " -gaussian Samples from a Gaussian distribution.\n"
126 " Usage:\n"
127 " -gaussian=columnName=<columnName>[,meanValue=<value>|@<parameter_name>]\n"
128 " [,sigmaValue=<value>|@<parameter_name>][,units=<string>]\n"
129 " Description:\n"
130 " Generates Gaussian-distributed samples with specified mean and sigma.\n"
131 " Parameters can be directly provided or referenced from input file parameters.\n\n";
132
133char *USAGE3 =
134 " -uniform Samples from a Uniform distribution.\n"
135 " Usage:\n"
136 " -uniform=columnName=<columnName>[,minimumValue=<value>|@<parameter_name>]\n"
137 " [,maximumValue=<value>|@<parameter_name>][,units=<string>]\n"
138 " Description:\n"
139 " Generates uniformly distributed samples within specified minimum and maximum values.\n"
140 " Parameters can be directly provided or referenced from input file parameters.\n\n"
141 " -poisson Samples from a Poisson distribution.\n"
142 " Usage:\n"
143 " -poisson=columnName=<columnName>[,meanValue=<value>|@<parameter_name>]\n"
144 " [,units=<string>]\n"
145 " Description:\n"
146 " Generates Poisson-distributed samples with a specified mean.\n"
147 " The mean can be directly provided or referenced from an input file parameter.\n\n"
148 " -samples Specifies the number of samples to generate.\n"
149 " -seed Specifies the seed for the random number generator.\n"
150 " If not provided or non-positive, the seed is derived from the system clock.\n"
151 " -optimalHalton Uses an improved Halton sequence for generating random numbers.\n"
152 " -majorOrder Specifies the output file order as row-major or column-major.\n"
153 " Usage:\n"
154 " -majorOrder=row|column\n"
155 " -threads Number of datafile-backed distributions to read concurrently.\n"
156 " Sampling and SDDS output operations remain serial. The default is 1.\n"
157 " -verbose Enables verbose output, printing information to stderr during execution.\n\n"
158 "Program by Michael Borland. (" __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION ")\n";
159
160#define SEQ_DATAFILE 0x0001UL
161#define SEQ_INDEPNAME 0x0002UL
162#define SEQ_CDFNAME 0x0004UL
163#define SEQ_DFNAME 0x0008UL
164#define SEQ_OUTPUTNAME 0x0010UL
165#define SEQ_HALTONRADIX 0x0020UL
166#define SEQ_RANDOMIZE 0x0040UL
167#define SEQ_RANDOMGROUP 0x0080UL
168#define SEQ_UNITSGIVEN 0x0100UL
169#define SEQ_HALTONOFFSET 0x0200UL
170#define SEQ_DIRECT_GAUSSIAN 0x0400UL
171#define SEQ_DIRECT_UNIFORM 0x0800UL
172#define SEQ_DIRECT_POISSON 0x1000UL
173
174typedef struct
175{
176 unsigned long flags;
177 char *dataFileName, *indepName, *CDFName, *DFName, *outputName, *units, *meanPar, *sigmaPar, *minPar, *maxPar;
178 SDDS_DATASET SDDSin;
179 int32_t haltonRadix, randomizationGroup, haltonOffset;
180 double factor, offset, mean, min, max, sigma;
181} SEQ_REQUEST;
182
183typedef struct
184{
185 long group;
186 long *order;
187} RANDOMIZED_ORDER;
188
189long CreatePoissonDistributionTable(double **x, double **pos_CDF, double mean);
190
191int main(int argc, char **argv) {
192 int iArg;
193 char *input, *output, *meanPar, *sigmaPar, *maxPar, *minPar;
194 long i, mainInputOpened, haltonID = 0, requireInput = 0;
195 unsigned long pipeFlags, majorOrderFlag;
196 SCANNED_ARG *scanned;
197 SDDS_DATASET SDDSin, SDDSout, *SDDSptr;
198 long randomNumberSeed = 0;
199 SEQ_REQUEST *seqRequest;
200 long samples, seqRequests, randomizationGroups = 0;
201 int64_t j, values;
202 double *sample, *IVValue, *CDFValue;
203 char msgBuffer[1000];
204 RANDOMIZED_ORDER *randomizationData = NULL;
205 long verbose, optimalHalton = 0;
206 short columnMajorOrder = -1;
207 int threads = 1;
208 int *dataFilePageStatus = NULL;
209
210 SDDS_RegisterProgramName(argv[0]);
211 argc = scanargs(&scanned, argc, argv);
212 if (argc < 2) {
213 fprintf(stderr, "%s%s%s\n", USAGE1, USAGE2, USAGE3);
214 return EXIT_FAILURE;
215 }
216 seqRequest = NULL;
217 seqRequests = 0;
218 output = input = NULL;
219 pipeFlags = 0;
220 samples = values = 0;
221 sample = IVValue = CDFValue = NULL;
222 verbose = 0;
223 maxPar = minPar = meanPar = sigmaPar = NULL;
224
225 for (iArg = 1; iArg < argc; iArg++) {
226 if (scanned[iArg].arg_type == OPTION) {
227 /* process options here */
228 switch (match_string(scanned[iArg].list[0], option, CLO_OPTIONS, 0)) {
229 case CLO_MAJOR_ORDER:
230 majorOrderFlag = 0;
231 scanned[iArg].n_items--;
232 if (scanned[iArg].n_items > 0 &&
233 (!scanItemList(&majorOrderFlag, scanned[iArg].list + 1, &scanned[iArg].n_items, 0,
234 "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER,
235 "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL)))
236 SDDS_Bomb("invalid -majorOrder syntax/values");
237 if (majorOrderFlag & SDDS_COLUMN_MAJOR_ORDER)
238 columnMajorOrder = 1;
239 else if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
240 columnMajorOrder = 0;
241 break;
242 case CLO_COLUMNS:
243 if (scanned[iArg].n_items < 3)
244 SDDS_Bomb("invalid -columns syntax");
245 if (!(seqRequest = SDDS_Realloc(seqRequest, sizeof(*seqRequest) * (seqRequests + 1))))
246 SDDS_Bomb("memory allocation failure");
247 scanned[iArg].n_items -= 1;
248 memset(seqRequest + seqRequests, 0, sizeof(*seqRequest));
249 /* remove following pointer initialization because memset already initializes them */
250 seqRequest[seqRequests].randomizationGroup = -1;
251 seqRequest[seqRequests].factor = 1;
252 seqRequest[seqRequests].offset = 0;
253 if (!scanItemList(&seqRequest[seqRequests].flags,
254 scanned[iArg].list + 1, &scanned[iArg].n_items, 0,
255 "datafile", SDDS_STRING, &seqRequest[seqRequests].dataFileName, 1, SEQ_DATAFILE,
256 "independentvariable", SDDS_STRING, &seqRequest[seqRequests].indepName, 1, SEQ_INDEPNAME,
257 "cdf", SDDS_STRING, &seqRequest[seqRequests].CDFName, 1, SEQ_CDFNAME,
258 "df", SDDS_STRING, &seqRequest[seqRequests].DFName, 1, SEQ_DFNAME,
259 "output", SDDS_STRING, &seqRequest[seqRequests].outputName, 1, SEQ_OUTPUTNAME,
260 "units", SDDS_STRING, &seqRequest[seqRequests].units, 1, SEQ_UNITSGIVEN,
261 "haltonradix", SDDS_LONG, &seqRequest[seqRequests].haltonRadix, 1, SEQ_HALTONRADIX,
262 "haltonoffset", SDDS_LONG, &seqRequest[seqRequests].haltonOffset, 1, SEQ_HALTONOFFSET,
263 "randomize", -1, NULL, 0, SEQ_RANDOMIZE,
264 "group", SDDS_LONG, &seqRequest[seqRequests].randomizationGroup, 1, SEQ_RANDOMGROUP,
265 "factor", SDDS_DOUBLE, &seqRequest[seqRequests].factor, 1, 0,
266 "offset", SDDS_DOUBLE, &seqRequest[seqRequests].offset, 1, 0, NULL) ||
267 bitsSet(seqRequest[seqRequests].flags & (SEQ_INDEPNAME + SEQ_CDFNAME + SEQ_DFNAME)) != 2)
268 SDDS_Bomb("invalid -columns syntax");
269 if (seqRequest[seqRequests].flags & SEQ_RANDOMGROUP && seqRequest[seqRequests].randomizationGroup <= 0)
270 SDDS_Bomb("use a positive integer for the randomization group ID");
271 if (seqRequest[seqRequests].flags & SEQ_CDFNAME && seqRequest[seqRequests].flags & SEQ_DFNAME)
272 SDDS_Bomb("give df or cdf for -columns, not both");
273 if (seqRequest[seqRequests].flags & SEQ_HALTONRADIX && !is_prime(seqRequest[seqRequests].haltonRadix))
274 SDDS_Bomb("halton radix must be a prime number");
275 seqRequests++;
276 scanned[iArg].n_items += 1;
277 break;
278 case CLO_GAUSSIAN:
279 if (scanned[iArg].n_items < 2)
280 SDDS_Bomb("invalid -gaussian syntax");
281 if (!(seqRequest = SDDS_Realloc(seqRequest, sizeof(*seqRequest) * (seqRequests + 1))))
282 SDDS_Bomb("memory allocation failure");
283 memset(seqRequest + seqRequests, 0, sizeof(*seqRequest));
284 scanned[iArg].n_items -= 1;
285 seqRequest[seqRequests].randomizationGroup = -1;
286 seqRequest[seqRequests].mean = 0;
287 seqRequest[seqRequests].sigma = 1;
288 if (!scanItemList(&seqRequest[seqRequests].flags,
289 scanned[iArg].list + 1, &scanned[iArg].n_items, 0,
290 "columnName", SDDS_STRING, &seqRequest[seqRequests].outputName, 1, SEQ_OUTPUTNAME,
291 "meanValue", SDDS_STRING, &meanPar, 1, 0,
292 "sigmaValue", SDDS_STRING, &sigmaPar, 1, 0,
293 "units", SDDS_STRING, &seqRequest[seqRequests].units, 1, SEQ_UNITSGIVEN, NULL))
294 SDDS_Bomb("invalid -gaussian syntax");
295 seqRequest[seqRequests].flags |= SEQ_DIRECT_GAUSSIAN;
296 if (!(seqRequest[seqRequests].flags & SEQ_OUTPUTNAME) || !(seqRequest[seqRequests].outputName))
297 SDDS_Bomb("columnName is not provided for gaussian distribution/");
298 if (meanPar) {
299 if (wild_match(meanPar, "@*"))
300 SDDS_CopyString(&seqRequest[seqRequests].meanPar, meanPar + 1);
301 else if (!get_double(&seqRequest[seqRequests].mean, meanPar))
302 SDDS_Bomb("Invalid value given for mean value of -gaussian distribution.");
303 free(meanPar);
304 meanPar = NULL;
305 }
306 if (sigmaPar) {
307 if (wild_match(sigmaPar, "@*"))
308 SDDS_CopyString(&seqRequest[seqRequests].sigmaPar, sigmaPar + 1);
309 else if (!get_double(&seqRequest[seqRequests].sigma, sigmaPar))
310 SDDS_Bomb("Invalid value given for sigma value of -gaussian distribution.");
311 free(sigmaPar);
312 sigmaPar = NULL;
313 }
314 seqRequests++;
315 scanned[iArg].n_items += 1;
316 break;
317 case CLO_UNIFORM:
318 if (scanned[iArg].n_items < 2)
319 SDDS_Bomb("invalid -uniform syntax");
320 if (!(seqRequest = SDDS_Realloc(seqRequest, sizeof(*seqRequest) * (seqRequests + 1))))
321 SDDS_Bomb("memory allocation failure");
322 memset(seqRequest + seqRequests, 0, sizeof(*seqRequest));
323 scanned[iArg].n_items -= 1;
324 memset(seqRequest + seqRequests, 0, sizeof(*seqRequest));
325 seqRequest[seqRequests].randomizationGroup = -1;
326 seqRequest[seqRequests].min = 0;
327 seqRequest[seqRequests].max = 1;
328 if (!scanItemList(&seqRequest[seqRequests].flags,
329 scanned[iArg].list + 1, &scanned[iArg].n_items, 0,
330 "columnName", SDDS_STRING, &seqRequest[seqRequests].outputName, 1, SEQ_OUTPUTNAME,
331 "minimumValue", SDDS_STRING, &minPar, 1, 0,
332 "maximumValue", SDDS_STRING, &maxPar, 1, 0,
333 "units", SDDS_STRING, &seqRequest[seqRequests].units, 1, SEQ_UNITSGIVEN, NULL))
334 SDDS_Bomb("invalid -uniform syntax");
335 seqRequest[seqRequests].flags |= SEQ_DIRECT_UNIFORM;
336 if (!(seqRequest[seqRequests].flags & SEQ_OUTPUTNAME) ||
337 !(seqRequest[seqRequests].outputName))
338 SDDS_Bomb("columnName is not provided for uniform distribution/");
339 if (minPar) {
340 if (wild_match(minPar, "@*"))
341 SDDS_CopyString(&seqRequest[seqRequests].minPar, minPar + 1);
342 else if (!get_double(&seqRequest[seqRequests].min, minPar))
343 SDDS_Bomb("Invalid value given for minimum value of -uniform distribution.");
344 free(minPar);
345 minPar = NULL;
346 }
347 if (maxPar) {
348 if (wild_match(maxPar, "@*"))
349 SDDS_CopyString(&seqRequest[seqRequests].maxPar, maxPar + 1);
350 else if (!get_double(&seqRequest[seqRequests].max, maxPar))
351 SDDS_Bomb("Invalid value given for maximum value of -uniform distribution.");
352 free(maxPar);
353 maxPar = NULL;
354 }
355 seqRequests++;
356 scanned[iArg].n_items += 1;
357 break;
358 case CLO_POISSON:
359 if (scanned[iArg].n_items < 2)
360 SDDS_Bomb("invalid -poisson syntax");
361 if (!(seqRequest = SDDS_Realloc(seqRequest, sizeof(*seqRequest) * (seqRequests + 1))))
362 SDDS_Bomb("memory allocation failure");
363 memset(seqRequest + seqRequests, 0, sizeof(*seqRequest));
364 scanned[iArg].n_items -= 1;
365 memset(seqRequest + seqRequests, 0, sizeof(*seqRequest));
366 seqRequest[seqRequests].randomizationGroup = -1;
367 seqRequest[seqRequests].mean = 1;
368 if (!scanItemList(&seqRequest[seqRequests].flags,
369 scanned[iArg].list + 1, &scanned[iArg].n_items, 0,
370 "columnName", SDDS_STRING, &seqRequest[seqRequests].outputName, 1, SEQ_OUTPUTNAME,
371 "meanValue", SDDS_STRING, &meanPar, 1, 0,
372 "units", SDDS_STRING, &seqRequest[seqRequests].units, 1, SEQ_UNITSGIVEN, NULL))
373 SDDS_Bomb("invalid -poisson syntax");
374 seqRequest[seqRequests].flags |= SEQ_DIRECT_POISSON;
375 if (!(seqRequest[seqRequests].flags & SEQ_OUTPUTNAME) || !(seqRequest[seqRequests].outputName))
376 SDDS_Bomb("columnName is not provided for poisson distribution/");
377 if (meanPar) {
378 if (wild_match(meanPar, "@*"))
379 SDDS_CopyString(&seqRequest[seqRequests].meanPar, meanPar + 1);
380 else if (!get_double(&seqRequest[seqRequests].mean, meanPar))
381 SDDS_Bomb("Invalid value given for mean value of -poisson distribution.");
382 free(meanPar);
383 meanPar = NULL;
384 }
385 seqRequests++;
386 scanned[iArg].n_items += 1;
387 break;
388 case CLO_SAMPLES:
389 if (scanned[iArg].n_items != 2 ||
390 sscanf(scanned[iArg].list[1], "%ld", &samples) != 1 ||
391 samples <= 0)
392 SDDS_Bomb("invalid -samples syntax");
393 break;
394 case CLO_SEED:
395 if (scanned[iArg].n_items != 2 ||
396 sscanf(scanned[iArg].list[1], "%ld", &randomNumberSeed) != 1)
397 SDDS_Bomb("invalid -seed syntax");
398 break;
399 case CLO_PIPE:
400 if (!processPipeOption(scanned[iArg].list + 1, scanned[iArg].n_items - 1, &pipeFlags))
401 SDDS_Bomb("invalid -pipe syntax");
402 break;
403 case CLO_VERBOSE:
404 verbose = 1;
405 break;
406 case CLO_OPTIMAL_HALTON:
407 optimalHalton = 1;
408 break;
409 case CLO_THREADS:
410 if (scanned[iArg].n_items != 2 ||
411 sscanf(scanned[iArg].list[1], "%d", &threads) != 1 ||
412 threads < 1)
413 SDDS_Bomb("invalid -threads syntax");
414 break;
415 default:
416 fprintf(stderr, "error: unknown/ambiguous option: %s\n", scanned[iArg].list[0]);
417 exit(EXIT_FAILURE);
418 break;
419 }
420 } else {
421 if (!input)
422 input = scanned[iArg].list[0];
423 else if (!output)
424 output = scanned[iArg].list[0];
425 else
426 SDDS_Bomb("too many filenames seen");
427 }
428 }
429
430 if (!seqRequests)
431 SDDS_Bomb("give one or more -columns options");
432 if (samples < 1)
433 SDDS_Bomb("-samples option not given");
434
435 for (i = 0; i < seqRequests; i++) {
436 if (!(seqRequest[i].flags & (SEQ_DATAFILE | SEQ_DIRECT_GAUSSIAN | SEQ_DIRECT_UNIFORM | SEQ_DIRECT_POISSON)))
437 break;
438 }
439 if (i == seqRequests) {
440 /* all columns options have either their own input files or else use
441 * one of the "direct" distributions. Hence, we don't expect an input
442 * file.
443 */
444 if (!input)
445 pipeFlags |= USE_STDIN; /* not really, but fakes out processFilenames */
446 if (input && !output) {
447 output = input;
448 input = NULL;
449 pipeFlags |= USE_STDIN;
450 if (fexists(output)) {
451 sprintf(msgBuffer, "%s exists already (sddssampledist)", output);
452 SDDS_Bomb(msgBuffer);
453 }
454 }
455 }
456
457 processFilenames("sddssampledist", &input, &output, pipeFlags, 0, NULL);
458
459 if (!SDDS_InitializeOutput(&SDDSout, SDDS_BINARY, 0, NULL, NULL, output))
460 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
461
462 if (verbose)
463 fprintf(stderr, "Initialized output file %s\n", output);
464
465 /* open and check input files */
466 for (i = mainInputOpened = 0; i < seqRequests; i++) {
467 if (seqRequest[i].flags & SEQ_DIRECT_GAUSSIAN) {
468 if (seqRequest[i].meanPar || seqRequest[i].sigmaPar) {
469 if (!mainInputOpened) {
470 if (!SDDS_InitializeInput(&SDDSin, input) ||
471 !SDDS_TransferAllParameterDefinitions(&SDDSout, &SDDSin, 0))
472 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
473 mainInputOpened = 1;
474 }
475 requireInput = 1;
476 SDDSptr = &SDDSin;
477 if ((seqRequest[i].meanPar &&
478 SDDS_CheckParameter(SDDSptr, seqRequest[i].meanPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) ||
479 (seqRequest[i].sigmaPar &&
480 SDDS_CheckParameter(SDDSptr, seqRequest[i].sigmaPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK)) {
481 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
482 exit(EXIT_FAILURE);
483 }
484 }
485 if (!SDDS_DefineSimpleColumn(&SDDSout, seqRequest[i].outputName, NULL, SDDS_DOUBLE))
486 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
487 } else if (seqRequest[i].flags & SEQ_DIRECT_UNIFORM) {
488 if (seqRequest[i].minPar || seqRequest[i].maxPar) {
489 if (!mainInputOpened) {
490 if (!SDDS_InitializeInput(&SDDSin, input) ||
491 !SDDS_TransferAllParameterDefinitions(&SDDSout, &SDDSin, 0))
492 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
493 mainInputOpened = 1;
494 }
495 requireInput = 1;
496 SDDSptr = &SDDSin;
497 if ((seqRequest[i].minPar &&
498 SDDS_CheckParameter(SDDSptr, seqRequest[i].minPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) ||
499 (seqRequest[i].maxPar &&
500 SDDS_CheckParameter(SDDSptr, seqRequest[i].maxPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK)) {
501 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
502 exit(EXIT_FAILURE);
503 }
504 }
505 if (!SDDS_DefineSimpleColumn(&SDDSout, seqRequest[i].outputName, NULL, SDDS_DOUBLE))
506 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
507 } else if (seqRequest[i].flags & SEQ_DIRECT_POISSON) {
508 if (seqRequest[i].meanPar) {
509 if (!mainInputOpened) {
510 if (!SDDS_InitializeInput(&SDDSin, input) ||
511 !SDDS_TransferAllParameterDefinitions(&SDDSout, &SDDSin, 0))
512 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
513 mainInputOpened = 1;
514 }
515 requireInput = 1;
516 SDDSptr = &SDDSin;
517 if (SDDS_CheckParameter(SDDSptr, seqRequest[i].meanPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) {
518 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
519 exit(EXIT_FAILURE);
520 }
521 }
522 if (!SDDS_DefineSimpleColumn(&SDDSout, seqRequest[i].outputName, NULL, SDDS_LONG))
523 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
524 } else {
525 if (seqRequest[i].flags & SEQ_RANDOMIZE) {
526 long newGroupID = 0;
527 /* define randomization groups */
528 if (seqRequest[i].flags & SEQ_RANDOMGROUP) {
529 newGroupID = seqRequest[i].randomizationGroup;
530 for (j = 0; j < randomizationGroups; j++)
531 if (randomizationData[j].group == newGroupID) {
532 newGroupID = 0;
533 break;
534 }
535 } else {
536 seqRequest[i].randomizationGroup = newGroupID = -(i + 1);
537 }
538 if (newGroupID != 0) {
539 if (!(randomizationData = SDDS_Realloc(randomizationData, sizeof(*randomizationData) * (randomizationGroups + 1))))
540 SDDS_Bomb("memory allocation failure");
541 randomizationData[randomizationGroups].group = newGroupID;
542 randomizationData[randomizationGroups].order = NULL;
543 randomizationGroups++;
544 }
545 }
546 if (seqRequest[i].flags & SEQ_DATAFILE) {
547 if (!SDDS_InitializeInput(&seqRequest[i].SDDSin, seqRequest[i].dataFileName))
548 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
549 SDDSptr = &seqRequest[i].SDDSin;
550 } else {
551 if (!mainInputOpened) {
552 if (!SDDS_InitializeInput(&SDDSin, input) ||
553 !SDDS_TransferAllParameterDefinitions(&SDDSout, &SDDSin, 0))
554 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
555 mainInputOpened = 1;
556 }
557 requireInput = 1;
558 SDDSptr = &SDDSin;
559 }
560 if (SDDS_CheckColumn(SDDSptr, seqRequest[i].indepName, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK ||
561 ((seqRequest[i].flags & SEQ_CDFNAME) &&
562 SDDS_CheckColumn(SDDSptr, seqRequest[i].CDFName, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) ||
563 ((seqRequest[i].flags & SEQ_DFNAME) &&
564 SDDS_CheckColumn(SDDSptr, seqRequest[i].DFName, NULL, SDDS_ANY_NUMERIC_TYPE, stderr) != SDDS_CHECK_OK) ||
565 !SDDS_TransferColumnDefinition(&SDDSout, SDDSptr, seqRequest[i].indepName, seqRequest[i].outputName)) {
566 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
567 exit(EXIT_FAILURE);
568 }
569 }
570
571 if (seqRequest[i].flags & SEQ_UNITSGIVEN &&
572 !SDDS_ChangeColumnInformation(&SDDSout, "units", seqRequest[i].units, SDDS_SET_BY_NAME, seqRequest[i].outputName))
573 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
574 }
575
576 if (verbose)
577 fprintf(stderr, "Initialized input files\n");
578
579 if (columnMajorOrder != -1)
580 SDDSout.layout.data_mode.column_major = columnMajorOrder;
581 else
582 SDDSout.layout.data_mode.column_major = 0;
583
584 if (!SDDS_WriteLayout(&SDDSout))
585 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
586
587 if (randomNumberSeed <= 0) {
588 randomNumberSeed = (long)time((time_t *)NULL);
589 randomNumberSeed = 2 * (randomNumberSeed / 2) + 1;
590#if defined(_WIN32) || defined(__APPLE__)
591 random_1(-labs(randomNumberSeed));
592#else
593 random_1(-fabs(randomNumberSeed));
594#endif
595 } else
596 random_1(-randomNumberSeed);
597
598 if (!(sample = calloc(samples, sizeof(*sample))))
599 SDDS_Bomb("memory allocation failure");
600 if (!(dataFilePageStatus = calloc(seqRequests, sizeof(*dataFilePageStatus))))
601 SDDS_Bomb("memory allocation failure");
602 while (1) {
603 if (verbose)
604 fprintf(stderr, "Beginning page loop\n");
605 if (input && SDDS_ReadPage(&SDDSin) <= 0)
606 break;
607 for (i = 0; i < seqRequests; i++)
608 dataFilePageStatus[i] = 1;
609#pragma omp parallel for if (threads > 1 && seqRequests > 1) num_threads(threads) schedule(dynamic)
610 for (i = 0; i < seqRequests; i++) {
611 if (seqRequest[i].flags & SEQ_DATAFILE)
612 dataFilePageStatus[i] = SDDS_ReadPage(&seqRequest[i].SDDSin);
613 }
614 for (i = 0; i < seqRequests; i++)
615 if ((seqRequest[i].flags & SEQ_DATAFILE) && dataFilePageStatus[i] <= 0)
616 break;
617 if (i != seqRequests)
618 break;
619 if (!SDDS_StartPage(&SDDSout, samples) || (input && !SDDS_CopyParameters(&SDDSout, &SDDSin)))
620 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
621 if (verbose)
622 fprintf(stderr, "Defining randomization tables\n");
623 /* define randomization tables */
624 for (i = 0; i < randomizationGroups; i++) {
625 if (!(randomizationData[i].order = SDDS_Malloc(sizeof(*randomizationData[i].order) * samples)))
626 SDDS_Bomb("memory allocation failure");
627 for (j = 0; j < samples; j++)
628 randomizationData[i].order[j] = j;
629 randomizeOrder((char *)randomizationData[i].order, sizeof(*randomizationData[i].order), samples, 0, random_1);
630 }
631 if (verbose)
632 fprintf(stderr, "Beginning loop over sequence requests\n");
633 for (i = 0; i < seqRequests; i++) {
634 if (verbose)
635 fprintf(stderr, "Processing sequence request %ld\n", i);
636 if (seqRequest[i].flags & SEQ_DIRECT_GAUSSIAN) {
637 if ((seqRequest[i].meanPar &&
638 !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].meanPar, &seqRequest[i].mean)) ||
639 (seqRequest[i].sigmaPar &&
640 !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].sigmaPar, &seqRequest[i].sigma)))
641 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
642 for (j = 0; j < samples; j++)
643 sample[j] = gauss_rn_lim(seqRequest[i].mean, seqRequest[i].sigma, -1, random_1);
644 } else if (seqRequest[i].flags & SEQ_DIRECT_UNIFORM) {
645 if ((seqRequest[i].minPar &&
646 !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].minPar, &seqRequest[i].min)) ||
647 (seqRequest[i].maxPar &&
648 !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].maxPar, &seqRequest[i].max)))
649 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
650 for (j = 0; j < samples; j++)
651 sample[j] = seqRequest[i].min + (seqRequest[i].max - seqRequest[i].min) * random_1(1);
652 } else if (seqRequest[i].flags & SEQ_DIRECT_POISSON) {
653 double *pos_x, *pos_cdf, CDF;
654 long pos_points, code;
655 pos_x = pos_cdf = NULL;
656 if ((seqRequest[i].meanPar &&
657 !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].meanPar, &seqRequest[i].mean)))
658 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
659 pos_points = CreatePoissonDistributionTable(&pos_x, &pos_cdf, seqRequest[i].mean);
660
661 for (j = 0; j < samples; j++) {
662 CDF = random_1(1);
663 sample[j] = (int)(interp(pos_x, pos_cdf, pos_points, CDF, 0, 1, &code));
664 /* fprintf(stderr, "%ld, cdf=%f, sample=%f\n", j, CDF, sample[j]); */
665 }
666 free(pos_x);
667 free(pos_cdf);
668 } else {
669 if (input && !(seqRequest[i].flags & SEQ_DATAFILE))
670 SDDSptr = &SDDSin;
671 else
672 SDDSptr = &seqRequest[i].SDDSin;
673 if ((values = SDDS_CountRowsOfInterest(SDDSptr))) {
674 if (!(IVValue = SDDS_GetColumnInDoubles(SDDSptr, seqRequest[i].indepName)) ||
675 (seqRequest[i].flags & SEQ_CDFNAME &&
676 !(CDFValue = SDDS_GetColumnInDoubles(SDDSptr, seqRequest[i].CDFName))) ||
677 (seqRequest[i].flags & SEQ_DFNAME &&
678 !(CDFValue = SDDS_GetColumnInDoubles(SDDSptr, seqRequest[i].DFName))))
679 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
680 } else {
681 sprintf(msgBuffer, "empty page for file %s\n",
682 (seqRequest[i].flags & SEQ_DATAFILE) ? seqRequest[i].dataFileName : input);
683 SDDS_Bomb(msgBuffer);
684 }
685 if (verbose)
686 fprintf(stderr, "Checking and converting CDF/DF values\n");
687 /* check/convert CDF/DF values */
688 for (j = 1; j < values; j++) {
689 if (IVValue[j - 1] > IVValue[j]) {
690 sprintf(msgBuffer, "random variate values not monotonically increasing for %s",
691 (seqRequest[i].flags & SEQ_DATAFILE) ? seqRequest[i].dataFileName : input);
692 SDDS_Bomb(msgBuffer);
693 }
694 if (seqRequest[i].flags & SEQ_DFNAME)
695 /* convert DF to CDF */
696 CDFValue[j] += CDFValue[j - 1];
697 if (CDFValue[j] < CDFValue[j - 1]) {
698 sprintf(msgBuffer, "CDF values decreasing for %s",
699 (seqRequest[i].flags & SEQ_DATAFILE) ? seqRequest[i].dataFileName : input);
700 SDDS_Bomb(msgBuffer);
701 }
702 }
703 if (verbose)
704 fprintf(stderr, "Normalizing CDF\n");
705 /* normalize the CDF */
706 if (CDFValue[values - 1] <= 0) {
707 sprintf(msgBuffer, "CDF not valid for %s\n", seqRequest[i].dataFileName);
708 SDDS_Bomb(msgBuffer);
709 }
710 for (j = 0; j < values; j++)
711 CDFValue[j] /= CDFValue[values - 1];
712 if (seqRequest[i].flags & SEQ_HALTONRADIX) {
713 if (verbose)
714 fprintf(stderr, "Starting halton sequence, offset=%" PRId32 "\n", seqRequest[i].haltonOffset);
715 if (!optimalHalton)
716 haltonID = startHaltonSequence(&seqRequest[i].haltonRadix, 0.5);
717 else
718 haltonID = startModHaltonSequence(&seqRequest[i].haltonRadix, 0);
719 while (seqRequest[i].haltonOffset-- > 0) {
720 if (!optimalHalton)
721 nextHaltonSequencePoint(haltonID);
722 else
723 nextModHaltonSequencePoint(haltonID);
724 }
725 }
726 if (verbose)
727 fprintf(stderr, "Generating samples\n");
728 for (j = 0; j < samples; j++) {
729 double CDF;
730 long code;
731 while (1) {
732 if (seqRequest[i].flags & SEQ_HALTONRADIX) {
733 if (!optimalHalton)
734 CDF = nextHaltonSequencePoint(haltonID);
735 else
736 CDF = nextModHaltonSequencePoint(haltonID);
737 } else
738 CDF = random_1(1);
739 if (CDF <= CDFValue[values - 1] && CDF >= CDFValue[0])
740 break;
741 }
742 sample[j] = seqRequest[i].factor * interp(IVValue, CDFValue, values, CDF, 0, 1, &code) + seqRequest[i].offset;
743 }
744 if (seqRequest[i].flags & SEQ_RANDOMIZE) {
745 long k, l;
746 double *sample1;
747 if (verbose)
748 fprintf(stderr, "Randomizing order of values\n");
749 if (!(sample1 = malloc(sizeof(*sample1) * samples)))
750 SDDS_Bomb("memory allocation failure");
751 for (l = 0; l < randomizationGroups; l++)
752 if (randomizationData[l].group == seqRequest[i].randomizationGroup)
753 break;
754 if (l == randomizationGroups)
755 SDDS_Bomb("problem with construction of randomization groups!");
756 for (k = 0; k < samples; k++)
757 sample1[k] = sample[randomizationData[l].order[k]];
758 free(sample);
759 sample = sample1;
760 }
761 free(IVValue);
762 free(CDFValue);
763 }
764 if (verbose)
765 fprintf(stderr, "Setting SDDS column values\n");
766 if (!SDDS_SetColumnFromDoubles(&SDDSout, SDDS_SET_BY_NAME, sample, samples,
767 seqRequest[i].outputName ? seqRequest[i].outputName : seqRequest[i].indepName))
768 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
769 }
770 if (verbose)
771 fprintf(stderr, "Writing data page\n");
772 if (!SDDS_WritePage(&SDDSout))
773 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
774 if (!requireInput)
775 break;
776 }
777 if (verbose)
778 fprintf(stderr, "Exited read loop\n");
779 free(sample);
780 free(dataFilePageStatus);
781 if ((input && !SDDS_Terminate(&SDDSin)) || !SDDS_Terminate(&SDDSout))
782 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
783 for (i = 0; i < seqRequests; i++) {
784 if (seqRequest[i].dataFileName)
785 free(seqRequest[i].dataFileName);
786 if (seqRequest[i].indepName)
787 free(seqRequest[i].indepName);
788 if (seqRequest[i].outputName)
789 free(seqRequest[i].outputName);
790 if (seqRequest[i].DFName)
791 free(seqRequest[i].DFName);
792 if (seqRequest[i].CDFName)
793 free(seqRequest[i].CDFName);
794 if (seqRequest[i].units)
795 free(seqRequest[i].units);
796 if (seqRequest[i].meanPar)
797 free(seqRequest[i].meanPar);
798 if (seqRequest[i].sigmaPar)
799 free(seqRequest[i].sigmaPar);
800 if (seqRequest[i].minPar)
801 free(seqRequest[i].minPar);
802 if (seqRequest[i].maxPar)
803 free(seqRequest[i].maxPar);
804 if (seqRequest[i].flags & SEQ_DATAFILE && !SDDS_Terminate(&(seqRequest[i].SDDSin)))
805 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
806 }
807 free(seqRequest);
808 for (i = 0; i < randomizationGroups; i++)
809 free(randomizationData[i].order);
810 if (randomizationData)
811 free(randomizationData);
812
813 free_scanargs(&scanned, argc);
814
815 return EXIT_SUCCESS;
816}
817
818long CreatePoissonDistributionTable(double **x, double **pos_CDF, double mean) {
819 long i, npoints = 20, count = 0;
820 double *pos = NULL;
821 /* SDDS_DATASET pos_out; */
822
823 *x = *pos_CDF = NULL;
824 if (!(*x = malloc(sizeof(**x) * npoints)) ||
825 !(pos = malloc(sizeof(*pos) * npoints)) ||
826 !(*pos_CDF = malloc(sizeof(**pos_CDF) * npoints)))
827 SDDS_Bomb("memory allocation failure.");
828 i = count = 0;
829 while (1) {
830 if (count + 2 >= npoints) {
831 npoints += 20;
832 *x = SDDS_Realloc(*x, sizeof(**x) * npoints);
833 *pos_CDF = SDDS_Realloc(*pos_CDF, sizeof(**pos_CDF) * npoints);
834 pos = SDDS_Realloc(pos, sizeof(*pos) * npoints);
835 }
836
837 (*x)[count] = i;
838 if (!i) {
839 pos[i] = exp(-mean);
840 (*pos_CDF)[count] = pos[i];
841 count++;
842 } else {
843 pos[i] = pos[i - 1] * mean / i;
844 (*pos_CDF)[count] = (*pos_CDF)[count - 1];
845 (*pos_CDF)[count + 1] = (*pos_CDF)[count - 1] + pos[i];
846 (*x)[count + 1] = i;
847 if (1.0 - (*pos_CDF)[count + 1] <= 1.0e-15)
848 break;
849 count += 2;
850 }
851 i++;
852 }
853 /* fprintf(stderr,"lamda=%f\n", mean);
854 if (!SDDS_InitializeOutput(&pos_out, SDDS_BINARY, 0, NULL, NULL, "pos_dist.sdds"))
855 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
856 if (!SDDS_DefineSimpleColumn(&pos_out, "Count", NULL, SDDS_DOUBLE) ||
857 !SDDS_DefineSimpleColumn(&pos_out, "P", NULL, SDDS_DOUBLE))
858 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
859 if (!SDDS_SaveLayout(&pos_out) || !SDDS_WriteLayout(&pos_out))
860 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
861 if (!SDDS_StartPage(&pos_out, count) ||
862 !SDDS_SetColumnFromDoubles(&pos_out, SDDS_SET_BY_NAME, *x, count, "Count") ||
863 !SDDS_SetColumnFromDoubles(&pos_out, SDDS_SET_BY_NAME, *pos_CDF, count, "P"))
864 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
865 if (!SDDS_WritePage(&pos_out) || !SDDS_Terminate(&pos_out))
866 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
867 */
868 free(pos);
869 return count;
870}
SDDS.h
SDDS (Self Describing Data Set) Data Types Definitions and Function Prototypes.
SDDS_CopyParameters
int32_t SDDS_CopyParameters(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source)
Definition SDDS_copy.c:286
SDDS_StartPage
int32_t SDDS_StartPage(SDDS_DATASET *SDDS_dataset, int64_t expected_n_rows)
Definition SDDS_dataprep.c:70
SDDS_SetColumnFromDoubles
int32_t SDDS_SetColumnFromDoubles(SDDS_DATASET *SDDS_dataset, int32_t mode, double *data, int64_t rows,...)
Sets the values for a single data column using double-precision floating-point numbers.
Definition SDDS_dataprep.c:1648
SDDS_GetParameterAsDouble
double * SDDS_GetParameterAsDouble(SDDS_DATASET *SDDS_dataset, char *parameter_name, double *memory)
Retrieves the value of a specified parameter as a double from the current data table of an SDDS datas...
Definition SDDS_extract.c:2783
SDDS_CountRowsOfInterest
int64_t SDDS_CountRowsOfInterest(SDDS_DATASET *SDDS_dataset)
Counts the number of rows marked as "of interest" in the current data table.
Definition SDDS_extract.c:364
SDDS_GetColumnInDoubles
double * SDDS_GetColumnInDoubles(SDDS_DATASET *SDDS_dataset, char *column_name)
Retrieves the data of a specified numerical column as an array of doubles, considering only rows mark...
Definition SDDS_extract.c:872
SDDS_ChangeColumnInformation
int32_t SDDS_ChangeColumnInformation(SDDS_DATASET *SDDS_dataset, char *field_name, void *memory, int32_t mode,...)
Modifies a specific field in a column definition within the SDDS dataset.
Definition SDDS_info.c:364
SDDS_InitializeInput
int32_t SDDS_InitializeInput(SDDS_DATASET *SDDS_dataset, char *filename)
Definition SDDS_input.c:50
SDDS_Terminate
int32_t SDDS_Terminate(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1471
SDDS_ReadPage
int32_t SDDS_ReadPage(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1007
SDDS_InitializeOutput
int32_t SDDS_InitializeOutput(SDDS_DATASET *SDDS_dataset, int32_t data_mode, int32_t lines_per_row, const char *description, const char *contents, const char *filename)
Initializes the SDDS output dataset.
Definition SDDS_output.c:602
SDDS_DefineSimpleColumn
int32_t SDDS_DefineSimpleColumn(SDDS_DATASET *SDDS_dataset, const char *name, const char *unit, int32_t type)
Defines a simple data column within the SDDS dataset.
Definition SDDS_output.c:1853
SDDS_WritePage
int32_t SDDS_WritePage(SDDS_DATASET *SDDS_dataset)
Writes the current data table to the output file.
Definition SDDS_output.c:1229
SDDS_WriteLayout
int32_t SDDS_WriteLayout(SDDS_DATASET *SDDS_dataset)
Writes the SDDS layout header to the output file.
Definition SDDS_output.c:900
SDDS_TransferColumnDefinition
int32_t SDDS_TransferColumnDefinition(SDDS_DATASET *target, SDDS_DATASET *source, char *name, char *newName)
Transfers a column definition from a source dataset to a target dataset.
Definition SDDS_transfer.c:35
SDDS_TransferAllParameterDefinitions
int32_t SDDS_TransferAllParameterDefinitions(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source, uint32_t mode)
Transfers all parameter definitions from a source dataset to a target dataset.
Definition SDDS_transfer.c:343
SDDS_CheckColumn
int32_t SDDS_CheckColumn(SDDS_DATASET *SDDS_dataset, char *name, char *units, int32_t type, FILE *fp_message)
Checks if a column exists in the SDDS dataset with the specified name, units, and type.
Definition SDDS_utils.c:4646
SDDS_PrintErrors
void SDDS_PrintErrors(FILE *fp, int32_t mode)
Prints recorded error messages to a specified file stream.
Definition SDDS_utils.c:474
SDDS_Malloc
void * SDDS_Malloc(size_t size)
Allocates memory of a specified size.
Definition SDDS_utils.c:705
SDDS_RegisterProgramName
void SDDS_RegisterProgramName(const char *name)
Registers the executable program name for use in error messages.
Definition SDDS_utils.c:318
SDDS_Bomb
void SDDS_Bomb(char *message)
Terminates the program after printing an error message and recorded errors.
Definition SDDS_utils.c:380
SDDS_CheckParameter
int32_t SDDS_CheckParameter(SDDS_DATASET *SDDS_dataset, char *name, char *units, int32_t type, FILE *fp_message)
Checks if a parameter exists in the SDDS dataset with the specified name, units, and type.
Definition SDDS_utils.c:4737
SDDS_CopyString
int32_t SDDS_CopyString(char **target, const char *source)
Copies a source string to a target string with memory allocation.
Definition SDDS_utils.c:922
SDDS_Realloc
void * SDDS_Realloc(void *old_ptr, size_t new_size)
Reallocates memory to a new size.
Definition SDDS_utils.c:743
SDDS_STRING
#define SDDS_STRING
Identifier for the string data type.
Definition SDDStypes.h:85
SDDS_LONG
#define SDDS_LONG
Identifier for the signed 32-bit integer data type.
Definition SDDStypes.h:61
SDDS_ANY_NUMERIC_TYPE
#define SDDS_ANY_NUMERIC_TYPE
Special identifier used by SDDS_Check*() routines to accept any numeric type.
Definition SDDStypes.h:157
SDDS_DOUBLE
#define SDDS_DOUBLE
Identifier for the double data type.
Definition SDDStypes.h:37
bitsSet
long bitsSet(unsigned long data)
Counts the number of set bits (1s) in the given data.
Definition binary.c:52
get_double
int get_double(double *dptr, char *s)
Parses a double value from the given string.
Definition data_scan.c:40
random_1
double random_1(long iseed)
Generate a uniform random double in [0,1] using a custom seed initialization.
Definition drand.c:230
randomizeOrder
long randomizeOrder(char *ptr, long size, long length, long iseed, double(*urandom)(long iseed1))
Randomize the order of an array of elements.
Definition drand.c:520
gauss_rn_lim
double gauss_rn_lim(double mean, double sigma, double limit_in_sigmas, double(*urandom)(long iseed))
Generate a Gaussian-distributed random number with specified mean, sigma, and optional cutoff.
Definition drand.c:433
is_prime
int64_t is_prime(int64_t number)
Determine if a number is prime.
Definition factorize.c:26
fexists
long fexists(const char *filename)
Checks if a file exists.
Definition fexists.c:27
startModHaltonSequence
int32_t startModHaltonSequence(int32_t *radix, double tiny)
Start a modified Halton sequence.
Definition halton.c:509
nextModHaltonSequencePoint
double nextModHaltonSequencePoint(long ID)
Retrieve the next point from the modified Halton sequence.
Definition halton.c:625
startHaltonSequence
int32_t startHaltonSequence(int32_t *radix, double value)
Initialize and start a new Halton sequence.
Definition halton.c:38
nextHaltonSequencePoint
double nextHaltonSequencePoint(long ID)
Get the next point in a Halton sequence.
Definition halton.c:107
interp
double interp(double *f, double *x, long n, double xo, long warnings, long order, long *returnCode)
Performs simple linear interpolation of data.
Definition interp.c:34
match_string
long match_string(char *string, char **option, long n_options, long mode)
Matches a given string against an array of option strings based on specified modes.
Definition match_string.c:34
scanargs
int scanargs(SCANNED_ARG **scanned, int argc, char **argv)
Definition scanargs.c:36
processPipeOption
long processPipeOption(char **item, long items, unsigned long *flags)
Definition scanargs.c:357
processFilenames
void processFilenames(char *programName, char **input, char **output, unsigned long pipeFlags, long noWarnings, long *tmpOutputUsed)
Definition scanargs.c:391
free_scanargs
void free_scanargs(SCANNED_ARG **scanned, int argc)
Definition scanargs.c:588
scanItemList
long scanItemList(unsigned long *flags, char **item, long *items, unsigned long mode,...)
Scans a list of items and assigns values based on provided keywords and types.
Definition scanitemlist.c:41
RANDOMIZED_ORDER
Definition sddssampledist.c:184
SDDS_DATASET
Definition SDDS.h:308
SEQ_REQUEST
Definition sddssampledist.c:175
wild_match
int wild_match(char *string, char *template)
Determine whether one string is a wildcard match for another.
Definition wild_match.c:49
Generated by doxygen 1.12.0