sim-operations.h

Go to the documentation of this file.

#ifndef SIM_OPERATIONS_H
#define SIM_OPERATIONS_H
/* 
genomicSimulationC v0.3
 
    Last edit: 23 July 2025
    License: MIT License
 
Copyright (c) 2021 Kira Villiers
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 
    Project repository: https://github.com/vllrs/genomicSimulationC
 
*/
 
/* Compile-time options:
 
    #define GSC_NO_SHORT_NAMES
        
        If simple names (eg `make_group_from`) might cause namespace conflicts, 
        then add the above definition before the import, and only module-prefixed 
        names (eg `gsc_make_group_from`) will be exposed. 
        
    #define GSC_MALLOC(ptr,size)  better_malloc
    #define GSC_FREE(ptr)         better_free
    
        By default, genomicSimulation uses stdlib malloc() and free(). These can
        be replaced with other equivalent memory management functions by redefining
        both GSC_MALLOC and GSC_FREE. Do not redefine only one of the pair.
    
    #define CONTIG_WIDTH 1000   
    
        The largest contiguous block of memory that could be requested in the 
        process of simulation is CONTIG_WIDTH integers. This setting's default
        value is 1000 if not redefined.
        
        This could be decreased to help long simulations or lower-end machines.
        Increasing this may provide some speed gain (likely very minor. I haven't
        tested).
        
    #define NAME_LENGTH 45
    
        The maximum number of characters allowed in a name field.
        These include names of SNPs, names of genotypes loaded from files,
        names of generated genotypes, and save-as-you-go filenames.
        
        @TODO render this setting meaningless. 
        
    #define GSC_ID_T unsigned int
    #define GSC_LOCALX_T unsigned int
    #define GSC_GLOBALX_T unsigned int
    #define GSC_GENOLEN_T unsigned int
        
        These type aliases are used for different types of internal identifiers.
        They can be redefined to any signed or unsigned integer type, if needed.
    
*/
 
#ifdef SIM_OPERATIONS
    #define RND_IMPLEMENTATION
#endif
#include "lib/rnd.h"
#include <string.h>
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <ctype.h> // for isdigit etc.
#include <stdint.h> // for SIZE_MAX etc.
 
typedef enum {
    GSC_TRUE = 1,
    GSC_FALSE = 0,
    GSC_NA = -1
} GSC_LOGICVAL;
 
#ifndef GSC_ID_T
    #define GSC_ID_T unsigned int
#endif
#define GSC_NA_ID 0
#define GSC_NA_IDX (GSC_ID_T)-1
// ^ Equivalent but less flexible definition: #define GSC_NA_IDX UINT_MAX
 
#ifndef GSC_GLOBALX_T
    #define GSC_GLOBALX_T unsigned int
#endif
#define GSC_NA_GLOBALX (GSC_GLOBALX_T)-1
 
#ifndef GSC_LOCALX_T
    #define GSC_LOCALX_T unsigned int
#endif
#define GSC_NA_LOCALX (GSC_LOCALX_T)-1
 
#ifndef GSC_GENOLEN_T
    #define GSC_GENOLEN_T unsigned int
#endif
#define GSC_NA_GENOLEN (GSC_GENOLEN_T)-1
 
#ifndef CONTIG_WIDTH
    #define CONTIG_WIDTH 1000
#else
    #if CONTIG_WIDTH > SIZE_MAX
        #error "This C compiler cannot handle a CONTIG_WIDTH that large. Please redefine."
    #elif CONTIG_WIDTH > UINT_MAX
        #undef GSC_LOCALX_T
        #undef GSC_NA_LOCALX
        #define GSC_LOCALX_T size_t
        #define GSC_NA_LOCALX SIZE_MAX
        #undef GSC_GLOBALX_T
        #undef GSC_NA_GLOBALX
        #define GSC_GLOBAL_T size_t
        #define GSC_NA_GLOBALX SIZE_MAX
    #endif //else LOCALX is already defined as unsigned int
#endif
 
#ifndef NAME_LENGTH
    #define NAME_LENGTH 45
#endif
 
#if defined(GSC_MALLOC) && !defined(GSC_FREE) || !defined(GSC_MALLOC) && defined(GSC_FREE)
#error "You must define both GSC_MALLOC and GSC_FREE, or neither."
#endif
#if !defined(GSC_MALLOC) && !defined(GSC_FREE)
    #define GSC_MALLOC(size) malloc(size)
    #define GSC_FREE(ptr) free(ptr)
#endif
 
#ifndef GSC_NO_SHORT_NAMES
 
#define GENOLEN_T                  GSC_GENOLEN_T
#define LOCALX_T                   GSC_LOCALX_T
#define GLOBALX_T                  GSC_GLOBALX_T
#define ID_T                       GSC_ID_T
#define LOGICVAL                   GSC_LOGICVAL
#define NA_GENOLEN                 GSC_NA_GENOLEN
#define NA_LOCALX                  GSC_NA_LOCALX
#define NA_GLOBALX                 GSC_NA_GLOBALX
#define NA_IDX                     GSC_NA_IDX
#define TRUE                       GSC_TRUE 
#define FALSE                      GSC_FALSE
#define NA                         GSC_NA
 
#define PedigreeID                 gsc_PedigreeID
#define NO_PEDIGREE                GSC_NO_PEDIGREE
#define GroupNum                   gsc_GroupNum
#define NO_GROUP                   GSC_NO_GROUP
#define EffectID                   gsc_EffectID
#define NO_EFFECTSET               GSC_NO_EFFECTSET
#define LabelID                    gsc_LabelID
#define NO_LABEL                   GSC_NO_LABEL
#define MapID                      gsc_MapID
#define NO_MAP                     GSC_NO_MAP
#define MultiIDSet                 gsc_MultiIDSet
 
#define TableSize                  gsc_TableSize
#define DecimalMatrix              gsc_DecimalMatrix
#define GenOptions                 gsc_GenOptions
#define BASIC_OPT                  GSC_BASIC_OPT
#define MarkerBlocks               gsc_MarkerBlocks
#define KnownGenome                gsc_KnownGenome
#define RecombinationMap           gsc_RecombinationMap
#define AlleleMatrix               gsc_AlleleMatrix
#define MarkerEffects              gsc_MarkerEffects
#define SimData                    gsc_SimData
#define GenoLocation               gsc_GenoLocation
#define INVALID_GENO_LOCATION      GSC_INVALID_GENO_LOCATION
#define IS_VALID_LOCATION          GSC_IS_VALID_LOCATION
#define BidirectionalIterator      gsc_BidirectionalIterator
#define RandomAccessIterator       gsc_RandomAccessIterator
 
#define create_new_label           gsc_create_new_label
#define change_label_default       gsc_change_label_default
#define change_label_to            gsc_change_label_to
#define change_label_by_amount     gsc_change_label_by_amount
#define change_label_to_values     gsc_change_label_to_values
#define change_names_to_values     gsc_change_names_to_values
#define change_allele_symbol       gsc_change_allele_symbol
#define change_eff_set_centres_to_values        gsc_change_eff_set_centres_to_values
#define change_eff_set_centre_of_markers        gsc_change_eff_set_centre_of_markers
#define change_eff_set_centre_of_allele_count   gsc_change_eff_set_centre_of_allele_count
 
#define create_empty_simdata       gsc_create_empty_simdata
#define clear_simdata              gsc_clear_simdata
#define load_mapfile               gsc_load_mapfile
#define load_effectfile            gsc_load_effectfile
#define load_genotypefile          gsc_load_genotypefile
#define load_data_files            gsc_load_data_files
#define DETECT_FILE_FORMAT         GSC_DETECT_FILE_FORMAT
#define FileFormatSpec             gsc_FileFormatSpec
#define define_matrix_format_details  gsc_define_matrix_format_details
 
#define create_bidirectional_iter  gsc_create_bidirectional_iter 
#define create_randomaccess_iter   gsc_create_randomaccess_iter
#define set_bidirectional_iter_to_start gsc_set_bidirectional_iter_to_start
#define set_bidirectional_iter_to_end   gsc_set_bidirectional_iter_to_end
#define next_forwards              gsc_next_forwards
#define next_backwards             gsc_next_backwards
#define next_get_nth               gsc_next_get_nth
#define get_name                   gsc_get_name
#define set_name                   gsc_set_name
#define get_alleles                gsc_get_alleles
#define get_first_parent           gsc_get_first_parent
#define get_second_parent          gsc_get_second_parent
#define get_id                     gsc_get_id
#define get_group                  gsc_get_group
#define set_group                  gsc_set_group
#define get_label_value            gsc_get_label_value
#define get_index_of_label         gsc_get_index_of_label
#define get_index_of_eff_set       gsc_get_index_of_eff_set
#define get_index_of_map           gsc_get_index_of_map
#define get_index_of_genetic_marker gsc_get_index_of_genetic_marker
#define get_existing_groups        gsc_get_existing_groups
#define get_existing_group_counts  gsc_get_existing_group_counts
#define get_group_size             gsc_get_group_size
#define get_group_names            gsc_get_group_names
#define get_group_ids              gsc_get_group_ids
#define get_group_indexes          gsc_get_group_indexes
#define get_group_genes            gsc_get_group_genes
#define get_group_bvs              gsc_get_group_bvs
#define get_group_parent_names     gsc_get_group_parent_names
#define get_group_parent_ids       gsc_get_group_parent_ids
#define get_group_pedigrees        gsc_get_group_pedigrees
 
#define combine_groups             gsc_combine_groups
#define make_group_from            gsc_make_group_from
#define split_by_label_value       gsc_split_by_label_value
#define split_by_label_range       gsc_split_by_label_range
#define split_into_individuals     gsc_split_into_individuals
#define split_into_families        gsc_split_into_families
#define split_into_halfsib_families gsc_split_into_halfsib_families
#define split_evenly_into_two      gsc_split_evenly_into_two 
#define split_evenly_into_n        gsc_split_evenly_into_n
#define split_into_buckets         gsc_split_into_buckets
#define split_randomly_into_two    gsc_split_randomly_into_two
#define split_randomly_into_n      gsc_split_randomly_into_n
#define split_by_probabilities     gsc_split_by_probabilities 
 
#define generate_gamete            gsc_generate_gamete
#define generate_doubled_haploid   gsc_generate_doubled_haploid
#define generate_clone             gsc_generate_clone
#define make_random_crosses        gsc_make_random_crosses
#define make_random_crosses_between gsc_make_random_crosses_between
#define make_targeted_crosses      gsc_make_targeted_crosses
#define self_n_times               gsc_self_n_times
#define make_doubled_haploids      gsc_make_doubled_haploids
#define make_clones                gsc_make_clones
#define make_all_unidirectional_crosses   gsc_make_all_unidirectional_crosses
#define make_crosses_from_file            gsc_make_crosses_from_file
#define make_double_crosses_from_file     gsc_make_double_crosses_from_file
 
#define split_by_bv                gsc_split_by_bv
#define calculate_bvs              gsc_calculate_bvs
#define calculate_allele_counts    gsc_calculate_allele_counts
#define create_evenlength_blocks_each_chr gsc_create_evenlength_blocks_each_chr
#define load_blocks                       gsc_load_blocks
#define calculate_local_bvs               gsc_calculate_local_bvs
#define calculate_optimal_haplotype          gsc_calculate_optimal_haplotype
#define calculate_optimal_possible_haplotype gsc_calculate_optimal_possible_haplotype
#define calculate_optimal_bv                 gsc_calculate_optimal_bv
#define calculate_optimal_possible_bv        gsc_calculate_optimal_possible_bv
#define calculate_minimal_bv                 gsc_calculate_minimal_bv
 
#define delete_group               gsc_delete_group
#define delete_label               gsc_delete_label
#define delete_recombination_map   gsc_delete_recombination_map
#define delete_eff_set             gsc_delete_eff_set
#define delete_dmatrix             gsc_delete_dmatrix
#define delete_simdata             gsc_delete_simdata
#define delete_markerblocks        gsc_delete_markerblocks
#define delete_bidirectional_iter  gsc_delete_bidirectional_iter
#define delete_randomaccess_iter   gsc_delete_randomaccess_iter
 
#define save_markerblocks          gsc_save_markerblocks
#define save_genotypes             gsc_save_genotypes
#define save_allele_counts         gsc_save_allele_counts
#define save_pedigrees             gsc_save_pedigrees
#define save_bvs                   gsc_save_bvs
#define save_local_bvs             gsc_save_local_bvs
 
#endif
 
#define GSC_CREATE_BUFFER(n,type,length) \
type n##stack[sizeof(int)*CONTIG_WIDTH/sizeof(type)]; size_t n##cap = length; \
type* n = (n##cap >= sizeof(n##stack)/sizeof(type)) ? gsc_malloc_wrap(sizeof(type)*n##cap,GSC_TRUE) : n##stack;
 
#define GSC_BUFFER_ISHEAP(n) n##cap >= sizeof(n##stack)/sizeof(n##stack[0])
 
#define GSC_FINALISE_BUFFER(n,as,nentries) do { if (n##cap >= sizeof(n##stack)/sizeof(n##stack[0])) { as = n; } else \
{ size_t len = nentries > n##cap ? n##cap : nentries; as = gsc_malloc_wrap(sizeof(n##stack[0])*len,GSC_TRUE); memcpy(as,n,sizeof(n##stack[0])*len); } } while (0)
 
#define GSC_DELETE_BUFFER(n) do { if (n##cap >= sizeof(n##stack)/sizeof(n##stack[0])) { GSC_FREE(n); } \
n = NULL; n##cap = 0; } while (0)
 
#define GSC_STRETCH_BUFFER(n,newlen) do {    \
    if (newlen < n##cap) { } \
    else if (n##cap >= sizeof(n##stack)/sizeof(n##stack[0])) { \
        void* tmp = gsc_malloc_wrap(sizeof(n##stack[0])*newlen,GSC_FALSE); \
        if (tmp != NULL) { \
        memcpy(tmp,n,sizeof(n[0])*n##cap); \
        GSC_FREE(n); n = tmp; n##cap = newlen; }} \
    else if (newlen >= sizeof(n##stack)/sizeof(n##stack[0])) { \
        n = gsc_malloc_wrap(sizeof(n##stack[0])*newlen,GSC_FALSE); \
        if (n != NULL) { \
        memcpy(n,n##stack,sizeof(n##stack[0])*n##cap); n##cap = newlen; }} \
    else if (newlen < CONTIG_WIDTH) { n##cap = newlen; } \
} while (0)
 
 
/* A simple struct used for returning the dimensions of a matrix or table.
 *
 * @shortnamed{TableSize}
 */
struct gsc_TableSize {
    int num_columns;
    int num_rows;
};
 
typedef struct {
    GSC_GENOLEN_T num_blocks;
 
    GSC_GENOLEN_T* num_markers_in_block;
 
    GSC_GENOLEN_T** markers_in_block;
} gsc_MarkerBlocks;
 
typedef struct {
    double** matrix; 
    size_t dim1;        
    size_t dim2;        
} gsc_DecimalMatrix;
 
 
typedef struct {
    GSC_ID_T id;
} gsc_PedigreeID;
#define GSC_NO_PEDIGREE (gsc_PedigreeID){.id=GSC_NA_ID}
 
 
typedef struct {
    GSC_ID_T num;
} gsc_GroupNum;
#define GSC_NO_GROUP (gsc_GroupNum){.num=GSC_NA_ID}
 
typedef struct {
    GSC_ID_T id;
} gsc_EffectID;
#define GSC_NO_EFFECTSET (gsc_EffectID){.id=GSC_NA_ID}
 
typedef struct {
    GSC_ID_T id;
} gsc_LabelID;
#define GSC_NO_LABEL (gsc_LabelID){.id=GSC_NA_ID}
 
typedef struct {
    GSC_ID_T id;
} gsc_MapID;
#define GSC_NO_MAP (gsc_MapID){.id=GSC_NA_ID}
 
struct gsc_MultiIDSet {
    gsc_GroupNum group;
    gsc_MapID map;
    gsc_EffectID effSet;
};
 
typedef struct {
    _Bool will_name_offspring; 
    const char* offspring_name_prefix; 
    GSC_GLOBALX_T family_size; 
    _Bool will_track_pedigree; 
    _Bool will_allocate_ids; 
    const char* filename_prefix; 
    _Bool will_save_pedigree_to_file; 
    gsc_EffectID will_save_bvs_to_file; 
    _Bool will_save_alleles_to_file; 
    /* _Bool will_save_recombinations_to_file; **< A boolean. If true, will log recombination
                            * events to "{filename_prefix}-recomb.txt". This information
                            * is not accessible by another saver function - it is only accessible
                            * if logged by the function generating a new set of offspring.
                            * The columns of the log file are:
                            */
    _Bool will_save_to_simdata; 
} gsc_GenOptions;
 
extern const gsc_GenOptions GSC_BASIC_OPT;
 
typedef struct {
    double expected_n_crossovers; 
    GSC_GENOLEN_T n_markers; 
    GSC_GENOLEN_T first_marker_index; 
    double* dists; 
} gsc_SimpleLinkageGroup;
 
typedef struct {
    double expected_n_crossovers; 
    GSC_GENOLEN_T n_markers; 
    GSC_GENOLEN_T* marker_indexes; 
    double* dists; 
} gsc_ReorderedLinkageGroup;
 
typedef struct {
    enum gsc_LinkageGroupType {
        GSC_LINKAGEGROUP_SIMPLE, 
        GSC_LINKAGEGROUP_REORDER 
    } type;
    union {
        gsc_SimpleLinkageGroup simple;
        gsc_ReorderedLinkageGroup reorder;
    } map;
} gsc_LinkageGroup;
 
typedef struct {
    size_t n_chr; 
    char** chr_names; 
    gsc_LinkageGroup* chrs; 
} gsc_RecombinationMap;
 
typedef struct {
    GSC_GENOLEN_T n_markers; 
    char** marker_names; 
    char*** names_alphabetical; 
    GSC_ID_T n_maps; 
    gsc_MapID* map_ids; 
    gsc_RecombinationMap* maps; 
} gsc_KnownGenome;
 
 
typedef struct gsc_AlleleMatrix gsc_AlleleMatrix;
struct gsc_AlleleMatrix {
    char* alleles[CONTIG_WIDTH];
 
    GSC_LOCALX_T n_genotypes; 
    GSC_GENOLEN_T n_markers; 
    char* names[CONTIG_WIDTH]; 
    gsc_PedigreeID ids[CONTIG_WIDTH]; 
    gsc_PedigreeID pedigrees[2][CONTIG_WIDTH]; 
    gsc_GroupNum groups[CONTIG_WIDTH]; 
    GSC_ID_T n_labels; 
    int** labels; 
    gsc_AlleleMatrix* next; 
};
 
typedef struct {
    GSC_GENOLEN_T n_markers; 
    double* centre; 
    GSC_GENOLEN_T* cumn_alleles; 
    char* allele; 
    double* eff; 
} gsc_MarkerEffects;
 
typedef struct {
    GSC_ID_T n_labels; 
    gsc_LabelID* label_ids; 
    int* label_defaults; 
    gsc_KnownGenome genome; 
    gsc_AlleleMatrix* m; 
    GSC_ID_T n_eff_sets; 
    gsc_EffectID* eff_set_ids; 
    gsc_MarkerEffects* e; 
    rnd_pcg_t rng; 
    gsc_PedigreeID current_id; 
    GSC_ID_T n_groups; 
} gsc_SimData;
 
 
enum gsc_TableFileCurrentStatus {
    GSC_TABLEFILE_NEWLINE,
    GSC_TABLEFILE_COLUMNGAP,
    GSC_TABLEFILE_CONTENTS,
    GSC_TABLEFILE_ERROR_EOF,
    GSC_TABLEFILE_ERROR_EOBUF
};
 
typedef struct {
    FILE* fp; 
    char buf[8192]; 
    int buf_fill; 
    int cursor; 
} gsc_TableFileReader;
 
typedef struct {
    _Bool isCellShallow; 
    char* cell; 
    size_t cell_len; 
    int predCol; 
    int predNewline; 
    _Bool eof; 
} gsc_TableFileCell;
 
 
gsc_TableFileReader gsc_tablefilereader_create(const char* filename);
void                gsc_tablefilereader_close(gsc_TableFileReader* tbl);
void gsc_helper_tablefilereader_refill_buffer(gsc_TableFileReader* tbl);
enum gsc_TableFileCurrentStatus gsc_helper_tablefilereader_classify_char(gsc_TableFileReader* tbl);
 
void gsc_tablefilecell_deep_copy(gsc_TableFileCell* c);
gsc_TableFileCell gsc_tablefilereader_get_next_cell(gsc_TableFileReader* tbl);
 
 
enum gsc_GenotypeFileCellStyle {
    GSC_GENOTYPECELLSTYLE_PAIR,
    GSC_GENOTYPECELLSTYLE_COUNT,
    GSC_GENOTYPECELLSTYLE_ENCODED,
    //GSC_GENOTYPECELLSTYLE_SPACEDPAIR, // to come later maybe
    GSC_GENOTYPECELLSTYLE_SLASHPAIR,
    GSC_GENOTYPECELLSTYLE_UNKNOWN
};
 
 
struct gsc_MapfileUnit {
    char* name;
    char* chr;
    double pos;
};
 
struct gsc_EffectfileUnit {
    GSC_GENOLEN_T markerix;
    char allele;
    double centre;
    double eff;
};
 
enum gsc_GenotypeFileType {
    GSC_GENOTYPEFILE_UNKNOWN,
    GSC_GENOTYPEFILE_MATRIX,
    GSC_GENOTYPEFILE_BED,
    GSC_GENOTYPEFILE_PED,
    GSC_GENOTYPEFILE_VCF,
    // GSC_GENOTYPEFILE_FLATFILE
};
 
struct gsc_GenotypeFile_MatrixFormat {
    GSC_LOGICVAL has_header; 
    GSC_LOGICVAL markers_as_rows; 
    enum gsc_GenotypeFileCellStyle cell_style; 
};
 
typedef struct {
    enum gsc_GenotypeFileType filetype;
    union {
        struct gsc_GenotypeFile_MatrixFormat matrix;
        //struct gsc_GenotypeFile_plinkFormat plink;
        //struct gsc_GenotypeFile_vcfFormat vcf;
    } spec;
} gsc_FileFormatSpec;
 
#define GSC_DETECT_FILE_FORMAT ((gsc_FileFormatSpec){.filetype=GSC_GENOTYPEFILE_UNKNOWN})
 
gsc_FileFormatSpec gsc_define_matrix_format_details(const GSC_LOGICVAL has_header, 
        const GSC_LOGICVAL markers_as_rows, const enum gsc_GenotypeFileCellStyle cell_style);
 
int gsc_randpoi(rnd_pcg_t* rng, double lambda);
 
gsc_DecimalMatrix gsc_generate_zero_dmatrix(const size_t r, const size_t c);
int           gsc_add_matrixvector_product_to_dmatrix(gsc_DecimalMatrix* result, const gsc_DecimalMatrix* a, 
                                                      const double* b);
int           gsc_add_doublematrixvector_product_to_dmatrix(gsc_DecimalMatrix* result, const gsc_DecimalMatrix* amat,
                                                            const double* avec,
                                                            const gsc_DecimalMatrix* bmat, const double* bvec);
 
struct gsc_TableSize gsc_get_file_dimensions(const char* filename, const char sep);
//int gsc_get_from_ordered_uint_list(const unsigned int target, const size_t listLen, const unsigned int* list);
GSC_LOCALX_T gsc_get_from_ordered_pedigree_list(const gsc_PedigreeID target, const GSC_LOCALX_T listLen, const gsc_PedigreeID* list);
size_t gsc_get_from_unordered_str_list(const char* target, const size_t listLen, const char** list);
size_t gsc_get_from_ordered_str_list(const char* target, const size_t listLen, const char** list);
 
 
void gsc_shuffle_up_to(rnd_pcg_t* rng, void* sequence, const size_t item_size, const size_t total_n, const size_t n_to_shuffle);
GSC_GLOBALX_T gsc_randomdraw_replacementrules(gsc_SimData* d, GSC_GLOBALX_T max, GSC_GLOBALX_T cap, 
                                              GSC_GLOBALX_T* member_uses, GSC_GLOBALX_T noCollision);
 
gsc_LabelID gsc_create_new_label(gsc_SimData* d, const int setTo);
void gsc_change_label_default(gsc_SimData* d, const gsc_LabelID whichLabel, const int newDefault);
void gsc_change_label_to(gsc_SimData* d, const gsc_GroupNum whichGroup, const gsc_LabelID whichLabel, const int setTo);
void gsc_change_label_by_amount(gsc_SimData* d, const gsc_GroupNum whichGroup, const gsc_LabelID whichLabel,
                                const int byValue);
void gsc_change_label_to_values(gsc_SimData* d, const gsc_GroupNum whichGroup, const GSC_GLOBALX_T startIndex, 
                                const gsc_LabelID whichLabel, const size_t n_values, const int* values);
void gsc_change_names_to_values(gsc_SimData* d, const gsc_GroupNum whichGroup, const GSC_GLOBALX_T startIndex, 
                                const size_t n_values, const char** values);
void gsc_change_allele_symbol(gsc_SimData* d, const char* which_marker, const char from, const char to);
 
_Bool gsc_change_eff_set_centres_to_values(gsc_SimData* d,
                                           const gsc_EffectID effset,
                                           const GSC_GENOLEN_T n_values,
                                           const double* values);
GSC_GENOLEN_T gsc_change_eff_set_centre_of_markers(gsc_SimData* d,
                                                   const gsc_EffectID effset,
                                                   const GSC_GENOLEN_T n_markers,
                                                   const char** marker_names,
                                                   const double* centres);
GSC_GENOLEN_T gsc_change_eff_set_centre_of_allele_count(gsc_SimData* d,
                                                        const gsc_EffectID effset,
                                                        const GSC_GENOLEN_T n_markers,
                                                        const char** marker_names,
                                                        const double* centres,
                                                        const char allele,
                                                        const _Bool reset_centres);
 
//static void gsc_set_names(gsc_AlleleMatrix* a, const char* prefix, const int suffix, const GSC_LOCALX_T from_index);
int gsc_get_integer_digits(const int i);
GSC_ID_T gsc_get_index_of_label( const gsc_SimData* d, const gsc_LabelID label );
GSC_ID_T gsc_get_index_of_eff_set( const gsc_SimData* d, const gsc_EffectID eff_set_id );
GSC_ID_T gsc_get_index_of_map( const gsc_SimData* d, const gsc_MapID map );
_Bool gsc_get_index_of_genetic_marker(const char* target, gsc_KnownGenome g, GSC_GENOLEN_T* out);
 
gsc_LabelID gsc_get_new_label_id( const gsc_SimData* d );
gsc_EffectID gsc_get_new_eff_set_id( const gsc_SimData* d );
gsc_MapID gsc_get_new_map_id( const gsc_SimData* d);
gsc_GroupNum gsc_get_next_free_group_num( const size_t n_existing_groups, const gsc_GroupNum* existing_groups, 
                                          size_t* cursor, gsc_GroupNum previous);
gsc_GroupNum gsc_get_new_group_num( gsc_SimData* d );
void gsc_get_n_new_group_nums( gsc_SimData* d, const size_t n, gsc_GroupNum* result);
void gsc_condense_allele_matrix( gsc_SimData* d);
//static void* gsc_malloc_wrap(const size_t size, char exitonfail);
 
//static int gsc_helper_simdata_pos_compare(const void *pp0, const void *pp1);
//static int gsc_helper_descending_double_comparer(const void* pp0, const void* pp1);
//static int gsc_helper_ascending_double_comparer(const void* pp0, const void* pp1);
// static int gsc_helper_alphabetical_str_comparer(const void* p0, const void* p1);
// static int gsc_helper_indirect_alphabetical_str_comparer(const void* p0, const void* p1);
// static int gsc_helper_mapfileunit_ascending_chr_comparer(const void* p0, const void* p1);
// static int gsc_helper_mapfileunit_ascending_d_comparer(const void* p0, const void* p1);
gsc_AlleleMatrix* gsc_create_empty_allelematrix(const GSC_GENOLEN_T n_markers, const GSC_ID_T n_labels, 
                                                const int* labelDefaults, const GSC_LOCALX_T n_genotypes);
gsc_SimData* gsc_create_empty_simdata(RND_U32 RNGseed);
void gsc_clear_simdata(gsc_SimData* d);
 
gsc_GroupNum gsc_load_genotypefile(SimData* d, const char* filename, const gsc_FileFormatSpec format);
// static struct gsc_GenotypeFile_MatrixFormat gsc_helper_genotypefile_matrix_detect_orientation(const SimData* d, 
        //const gsc_TableFileCell* cellqueue, const size_t firstrowlen, const size_t queuelen, 
        //struct gsc_GenotypeFile_MatrixFormat format, const char* filenameforlog);
// static struct gsc_GenotypeFile_MatrixFormat gsc_helper_genotypefile_matrix_detect_cellstyle(
        //const gsc_TableFileCell* cellqueue, const size_t firstrowlen, const size_t queuelen, 
        // struct gsc_GenotypeFile_MatrixFormat format, const char* filenameforlog);
// static enum gsc_GenotypeFileCellStyle gsc_helper_genotype_matrix_identify_cell_style(char* cell);
// static struct gsc_GenotypeFile_MatrixFormat gsc_helper_genotypefile_matrix_detect_header(
    //const gsc_TableFileCell* cellqueue, const size_t firstrowlen, const size_t queuelen, 
    // struct gsc_GenotypeFile_MatrixFormat format, const char* filenameforlog);
// static int gsc_helper_genotypefile_matrix_detect_cornercell_presence(const size_t ncellsfirstrow, 
    // const size_t ncellssecondrow, const int secondrowheaderisempty);
 
 
// static struct gsc_MultiIDSet gsc_load_genotypefile_matrix(gsc_SimData* d, const char* filename, const char* mapfile)
// static void gsc_helper_parse_genofile(char* filename, enum gsc_GenotypeFileType type, 
        //GSC_GENOLEN_T* n_markers, char*** marker_names, GSC_GLOBALX_T* n_lines, char*** line_names, 
        //struct gsc_GenotypeFileCell** cells)
 
// static int gsc_helper_genotypefile_matrix_check_markers_are_rows(gsc_SimData* d, int hasheader, 
        //gsc_TableFileCell* firstrow, size_t firstrowlen, gsc_TableFileCell secondrowcellone)
//static void gsc_helper_genotypecell_to_allelematrix(GenoLocation loc, GSC_GENOLEN_T markerix, 
        //enum gsc_GenotypeFileCellStyle style, char* cell, gsc_SimData* forrng)
 
gsc_MapID gsc_load_mapfile(gsc_SimData* d, const char* filename);
// static GSC_GENOLEN_T gsc_helper_sort_markerlist(GSC_GENOLEN_T n_markers, struct gsc_MapfileUnit* markerlist) 
// static GSC_GENOLEN_T gsc_helper_parse_mapfile(const char* filename, struct gsc_MultiTypeUnit** out)
// static gsc_MapID gsc_helper_insert_recombmap_into_simdata(gsc_SimData* d, gsc_RecombinationMap map)
// static GSC_GENOLEN_T gsc_helper_str_markerlist_leftjoin(gsc_KnownGenome g, GSC_GENOLEN_T n_markers_in_list, 
        //struct gsc_MapfileUnit** markerlist)
gsc_MapID gsc_create_recombmap_from_markerlist(gsc_SimData* d, GSC_GENOLEN_T n_markers, struct gsc_MapfileUnit* markerlist);
gsc_MapID gsc_create_uniformspaced_recombmap(gsc_SimData* d, GSC_GENOLEN_T n_markers, char** markernames, 
                                             double expected_n_recombinations);
gsc_MapID gsc_create_unlinked_recombmap(gsc_SimData* d, GSC_GENOLEN_T n_markers, char** markernames);
 
gsc_EffectID gsc_load_effectfile(gsc_SimData* d, const char* filename);
 
struct gsc_MultiIDSet gsc_load_data_files(gsc_SimData* d, const char* data_file, const char* map_file, 
                                          const char* effect_file, const gsc_FileFormatSpec format);
typedef struct {
    gsc_AlleleMatrix* localAM; 
    GSC_LOCALX_T localPos; 
} gsc_GenoLocation;
 
#define GSC_INVALID_GENO_LOCATION (gsc_GenoLocation){.localAM=0,.localPos=GSC_NA_LOCALX}
#define GSC_IS_VALID_LOCATION(g) (g.localAM != 0 && g.localPos != GSC_NA_LOCALX)
 
static inline int gsc_isValidLocation(const gsc_GenoLocation g) {
    // Either entry of INVALID_GENO_LOCATION is inappropriate in a valid gsc_GenoLocation
    return (g.localAM != INVALID_GENO_LOCATION.localAM &&
            g.localPos != INVALID_GENO_LOCATION.localPos);
}
 
 
typedef struct {
    gsc_GenoLocation loc; 
    GSC_ID_T mapindex; 
} gsc_ParentChoice;
 
typedef struct {
    gsc_AlleleMatrix* am; 
    const gsc_GroupNum group; 
    GSC_LOCALX_T localPos; 
    gsc_AlleleMatrix* cachedAM; 
    unsigned int cachedAMIndex; 
    _Bool atEnd; 
    _Bool atStart; 
} gsc_BidirectionalIterator;
 
struct gsc_GappyIterator {
    gsc_GenoLocation cursor;
    unsigned int cursorAMIndex;
};
 
struct gsc_EmptyListNavigator {
    gsc_SimData* d;
    gsc_GroupNum alloctogroup;
    gsc_PedigreeID currentid;
    gsc_AlleleMatrix* firstAM;
    gsc_AlleleMatrix* localAM;
    GSC_LOCALX_T localPos;
};
 
typedef struct {
    gsc_SimData* d; 
    const gsc_GroupNum group; 
    GSC_GLOBALX_T cacheSize; 
    gsc_GenoLocation* cache; 
    GSC_GLOBALX_T largestCached; 
    GSC_GLOBALX_T groupSize; 
} gsc_RandomAccessIterator;
 
gsc_BidirectionalIterator gsc_create_bidirectional_iter( gsc_SimData* d, const gsc_GroupNum group);
gsc_BidirectionalIterator gsc_create_bidirectional_iter_fromAM( gsc_AlleleMatrix* am, const gsc_GroupNum group);
gsc_RandomAccessIterator gsc_create_randomaccess_iter( gsc_SimData* d, const gsc_GroupNum group);
 
gsc_AlleleMatrix* gsc_get_nth_AlleleMatrix( gsc_AlleleMatrix* listStart, const unsigned int n);
 
gsc_GenoLocation gsc_set_bidirectional_iter_to_start(gsc_BidirectionalIterator* it);
gsc_GenoLocation gsc_set_bidirectional_iter_to_end(gsc_BidirectionalIterator* it);
gsc_GenoLocation gsc_next_forwards(gsc_BidirectionalIterator* it);
gsc_GenoLocation gsc_next_backwards(gsc_BidirectionalIterator* it);
gsc_GenoLocation gsc_next_get_nth(gsc_RandomAccessIterator* it, const GSC_GLOBALX_T n);
 
//static gsc_GenoLocation gsc_nextgappy_get_gap(struct gsc_GappyIterator* it);
//static gsc_GenoLocation gsc_nextgappy_get_nongap(struct gsc_GappyIterator* it);
//static gsc_GenoLocation gsc_nextgappy_valid_pos(struct gsc_GappyIterator* it);
 
// static struct gsc_EmptyListNavigator gsc_create_emptylistnavigator(SimData* d)
// static gsc_GenoLocation gsc_emptylistnavigator_get_first(struct gsc_EmptyListNavigator* it)
// static gsc_GenoLocation gsc_emptylistnavigator_get_next(struct gsc_EmptyListNavigator* it)
// static void gsc_emptylistnavigator_finaliselist(struct gsc_EmptyListNavigator* it)
static inline char* gsc_get_name(const gsc_GenoLocation loc) {
    return loc.localAM->names[loc.localPos];
}
 
static inline void gsc_set_name(const gsc_GenoLocation loc, char* name) {
    char* oldname = loc.localAM->names[loc.localPos];
    if (oldname != NULL) free(oldname);
    loc.localAM->names[loc.localPos] = name;
}
 
static inline char* gsc_get_alleles(const gsc_GenoLocation loc) {
    return loc.localAM->alleles[loc.localPos];
}
 
static inline gsc_PedigreeID gsc_get_first_parent(const gsc_GenoLocation loc) {
    return loc.localAM->pedigrees[0][loc.localPos];
}
 
static inline gsc_PedigreeID gsc_get_second_parent(const gsc_GenoLocation loc) {
    return loc.localAM->pedigrees[1][loc.localPos];
}
 
static inline gsc_PedigreeID gsc_get_id(const gsc_GenoLocation loc) {
    return loc.localAM->ids[loc.localPos];
}
 
static inline gsc_GroupNum gsc_get_group(const gsc_GenoLocation loc) {
    return loc.localAM->groups[loc.localPos];
}
 
static inline void gsc_set_group(const gsc_GenoLocation loc, const gsc_GroupNum group) {
    loc.localAM->groups[loc.localPos] = group;
}
 
//static inline int get_bv(GenotypeLocation loc) {}
 
static inline int gsc_get_label_value(const gsc_GenoLocation loc, const int labelIndex) {
    return loc.localAM->labels[labelIndex][loc.localPos];
}
char* gsc_get_name_of_id( const gsc_AlleleMatrix* start, const gsc_PedigreeID id);
int gsc_get_parents_of_id( const gsc_AlleleMatrix* start, const gsc_PedigreeID id, 
                                    gsc_PedigreeID output[static 2]);
void gsc_get_ids_of_names( const gsc_AlleleMatrix* start, const size_t n_names, const char** names, 
                          gsc_PedigreeID* output);
GSC_GLOBALX_T gsc_get_index_of_child( const gsc_AlleleMatrix* start, const gsc_PedigreeID parent1id, 
                                      const gsc_PedigreeID parent2id);
GSC_GLOBALX_T gsc_get_index_of_name( const gsc_AlleleMatrix* start, const char* name);
gsc_PedigreeID gsc_get_id_of_index( const gsc_AlleleMatrix* start, const GSC_GLOBALX_T index);
char* gsc_get_genes_of_index( const gsc_AlleleMatrix* start, const GSC_GLOBALX_T index);
GSC_GLOBALX_T gsc_get_group_size( const gsc_SimData* d, const gsc_GroupNum group_id);
GSC_GLOBALX_T gsc_get_group_genes( const gsc_SimData* d, const gsc_GroupNum group_id, GSC_GLOBALX_T group_size, char** output);
GSC_GLOBALX_T gsc_get_group_names( const gsc_SimData* d, const gsc_GroupNum group_id, GSC_GLOBALX_T group_size, char** output);
GSC_GLOBALX_T gsc_get_group_ids( const gsc_SimData* d, const gsc_GroupNum group_id, GSC_GLOBALX_T group_size, gsc_PedigreeID* output);
GSC_GLOBALX_T gsc_get_group_indexes( const gsc_SimData* d, const gsc_GroupNum group_id, 
                                    GSC_GLOBALX_T group_size, GSC_GLOBALX_T* output);
GSC_GLOBALX_T gsc_get_group_bvs( const gsc_SimData* d, const gsc_GroupNum group_id, const gsc_EffectID effID, 
                       GSC_GLOBALX_T group_size, double* output);
GSC_GLOBALX_T gsc_get_group_parent_ids( const gsc_SimData* d, const gsc_GroupNum group_id, GSC_GLOBALX_T group_size, 
                              const int whichParent, gsc_PedigreeID* output);
GSC_GLOBALX_T gsc_get_group_parent_names( const gsc_SimData* d, const gsc_GroupNum group_id, GSC_GLOBALX_T group_size, 
                                const int whichParent, char** output);
GSC_GLOBALX_T gsc_get_group_pedigrees( const gsc_SimData* d, const gsc_GroupNum group_id, GSC_GLOBALX_T group_size, char** output);
 
size_t gsc_get_existing_groups( gsc_SimData* d, gsc_GroupNum* output);
size_t gsc_get_existing_group_counts( gsc_SimData* d, gsc_GroupNum* out_groups, GSC_GLOBALX_T* out_sizes);
gsc_GroupNum gsc_combine_groups( gsc_SimData* d, const size_t list_len, const gsc_GroupNum* grouplist);
gsc_GroupNum gsc_make_group_from( gsc_SimData* d, const size_t index_list_len, const GSC_GLOBALX_T* genotype_indexes);
gsc_GroupNum gsc_split_by_label_value( gsc_SimData* d, const gsc_GroupNum group, 
                                       const gsc_LabelID whichLabel, const int valueToSplit);
gsc_GroupNum gsc_split_by_label_range( gsc_SimData* d, const gsc_GroupNum group, const gsc_LabelID whichLabel, 
                                       const int valueLowBound, const int valueHighBound);
 
// GENERIC
size_t gsc_scaffold_split_by_somequality( gsc_SimData* d, const gsc_GroupNum group_id,
        void* somequality_data,
        gsc_GroupNum (*somequality_tester)(gsc_GenoLocation, void*, size_t, size_t, gsc_GroupNum*),
        size_t maxentries_results, gsc_GroupNum* results);
// APPLICATIONS
size_t gsc_split_into_individuals( gsc_SimData* d, const gsc_GroupNum group_id, 
                                        size_t maxentries_results, gsc_GroupNum* results);
    //static gsc_GroupNum gsc_helper_split_by_quality_individuate(gsc_GenoLocation loc, void** datastore, 
        //size_t maxgroups, size_t groupsfound, gsc_GroupNum** results);
size_t gsc_split_into_families(gsc_SimData* d, const gsc_GroupNum group_id, size_t maxentries_results, 
                                     gsc_GroupNum* results);
    //static gsc_GroupNum gsc_helper_split_by_quality_family(gsc_GenoLocation loc, void** datastore, 
        //size_t maxgroups, size_t groupsfound, gsc_GroupNum** results);
size_t gsc_split_into_halfsib_families( gsc_SimData* d, const gsc_GroupNum group_id, 
                                              const int parent, size_t maxentries_results, gsc_GroupNum* results);
    //static gsc_GroupNum gsc_helper_split_by_quality_halfsib1(gsc_GenoLocation loc, void** datastore, 
        // size_t maxgroups, size_t groupsfound, gsc_GroupNum* results);
    //static gsc_GroupNum gsc_helper_split_by_quality_halfsib2(gsc_GenoLocation loc, void** datastore, 
        // size_t maxgroups, size_t groupsfound, gsc_GroupNum* results);
    //static gsc_GroupNum gsc_helper_split_by_quality_halfsibtemplate(gsc_GenoLocation loc, void** datastore, 
        //size_t maxgroups, size_t groupsfound, gsc_GroupNum* results, 
        //gsc_PedigreeID (*getparent)(gsc_GenoLocation));
 
// GENERIC
size_t gsc_scaffold_split_by_someallocation(gsc_SimData* d, const gsc_GroupNum group_id, void* someallocator_data,
        gsc_GroupNum (*someallocator)(gsc_GenoLocation, gsc_SimData*, void*, size_t, size_t*, gsc_GroupNum*),
        size_t n_outgroups, gsc_GroupNum* outgroups);
// APPLICATIONS
gsc_GroupNum gsc_split_evenly_into_two(gsc_SimData* d, const gsc_GroupNum group_id);
    //static gsc_GroupNum gsc_helper_split_by_allocator_knowncounts(gsc_GenoLocation loc, gsc_SimData* d, 
        //void* datastore, size_t n_outgroups, size_t* subgroupsfound, gsc_GroupNum* outgroups)
size_t gsc_split_evenly_into_n(gsc_SimData* d, const gsc_GroupNum group_id, 
                                     const size_t n, gsc_GroupNum* results);
size_t gsc_split_into_buckets(gsc_SimData* d, const gsc_GroupNum group_id, const size_t n, 
                                    const GSC_GLOBALX_T* counts, gsc_GroupNum* results);
gsc_GroupNum gsc_split_randomly_into_two(gsc_SimData* d, const gsc_GroupNum group_id);
size_t gsc_split_randomly_into_n(gsc_SimData* d, const gsc_GroupNum group_id, 
                                       const size_t n, gsc_GroupNum* results);
    //static gsc_GroupNum gsc_helper_split_by_allocator_equalprob(gsc_GenoLocation loc, gsc_SimData* d, 
        //void* datastore, size_t n_outgroups, size_t* subgroupsfound, gsc_GroupNum* outgroups);
size_t gsc_split_by_probabilities(gsc_SimData* d, const gsc_GroupNum group_id, 
                                        const size_t n, const double* probs, gsc_GroupNum* results);
    //static gsc_GroupNum gsc_helper_split_by_allocator_unequalprob(gsc_GenoLocation loc, gsc_SimData* d, 
        //void* datastore, size_t n_outgroups, size_t* subgroupsfound, gsc_GroupNum* outgroups);
 
void gsc_generate_gamete(gsc_SimData* d, const char* parent_genome, char* output, const GSC_ID_T mapindex);
void gsc_generate_doubled_haploid(gsc_SimData* d, const char* parent_genome, char* output, const GSC_ID_T mapindex);
void gsc_generate_clone(gsc_SimData* d, const char* parent_genome, char* output);
// SUPPORTER FUNCS FOR GENOPTIONS OPTIONS
// static FILE* gsc_helper_genoptions_save_pedigrees_setup(const gsc_GenOptions g);
// static FILE* gsc_helper_genoptions_save_bvs_setup(const gsc_SimData* d, const gsc_GenOptions g, int* effIndexp);
// static FILE* gsc_helper_genoptions_save_genotypes_setup(const gsc_SimData* d, const gsc_GenOptions g);
// static void gsc_helper_genoptions_save_pedigrees(FILE* fp, gsc_SimData* d, gsc_AlleleMatrix* tosave);
// static void gsc_helper_genoptions_save_bvs(FILE* fe, gsc_MarkerEffects* effMatrices, int effIndex, 
        //gsc_AlleleMatrix* tosave);
// static void gsc_helper_genoptions_save_genotypes(FILE* fg, gsc_AlleleMatrix* tosave);
// static void gsc_helper_genoptions_give_names_and_ids(gsc_AlleleMatrix* am, gsc_SimData* d, 
        //const gsc_GenOptions g);
 
// PARAMETER FUNCTIONS FOR THE FOLLOWING GENERIC
// static void gsc_helper_make_offspring_cross(gsc_SimData* d, union gsc_datastore_make_genotype* datastore, 
        //gsc_ParentChoice parents[static 2], gsc_GenoLocation putHere);
// static void gsc_helper_make_offspring_self_n_times(gsc_SimData* d, union gsc_datastore_make_genotype* datastore, 
        //gsc_ParentChoice parents[static 2], gsc_GenoLocation putHere);
// static void gsc_helper_make_offspring_doubled_haploids(gsc_SimData* d, union gsc_datastore_make_genotype* datastore, 
        //gsc_ParentChoice parents[static 2], gsc_GenoLocation putHere);
// static void gsc_helper_make_offspring_clones(gsc_SimData* d, union gsc_datastore_make_genotype* datastore, 
        //gsc_ParentChoice parents[static 2], gsc_GenoLocation putHere);
 
// static int gsc_helper_parentchooser_cross_randomly(void* parentIterator, 
        //union gsc_datastore_make_genotype* datastore, unsigned int* counter, gsc_ParentChoice parents[static 2]);
// static int gsc_helper_parentchooser_cross_randomly_between(void* parentIterator, 
        //union gsc_datastore_make_genotype* datastore, unsigned int* counter, gsc_ParentChoice parents[static 2]);
// static int gsc_helper_parentchooser_cross_targeted(void* parentIterator, 
        //union gsc_datastore_make_genotype* datastore, unsigned int* counter, gsc_ParentChoice parents[static 2]);
// static int gsc_helper_parentchooser_selfing(void* parentIterator, 
        //union gsc_datastore_make_genotype* datastore, unsigned int* counter, gsc_ParentChoice parents[static 2]);
// static int gsc_helper_parentchooser_cloning(void* parentIterator, 
        //union gsc_datastore_make_genotype* datastore, unsigned int* counter, gsc_ParentChoice parents[static 2]);
 
// static int gsc_helper_random_cross_checks(gsc_SimData* d, const gsc_GroupNum from_group, 
        // const unsigned int n_crosses, const int cap);
 
// GENERIC
union gsc_datastore_make_genotypes;
gsc_GroupNum gsc_scaffold_make_new_genotypes(gsc_SimData* d, const gsc_GenOptions g,
        void* parentIterator, union gsc_datastore_make_genotypes* datastore,
        int (*parentChooser)(void*, union gsc_datastore_make_genotypes*, GSC_GLOBALX_T*, gsc_ParentChoice[static 2]),
        void (*offspringGenerator)(gsc_SimData*, union gsc_datastore_make_genotypes*, gsc_ParentChoice[static 2], 
                                   gsc_GenoLocation));
// APPLICATIONS
gsc_GroupNum gsc_make_random_crosses(gsc_SimData* d, const gsc_GroupNum from_group, const GSC_GLOBALX_T n_crosses,
                                     const GSC_GLOBALX_T cap, const gsc_MapID which_map, const gsc_GenOptions g);
gsc_GroupNum gsc_make_random_crosses_between(gsc_SimData*d, const gsc_GroupNum group1, const gsc_GroupNum group2,
                                             const GSC_GLOBALX_T n_crosses, const GSC_GLOBALX_T cap1, 
                                             const GSC_GLOBALX_T cap2,
                                             const gsc_MapID map1, const gsc_MapID map2, const gsc_GenOptions g);
gsc_GroupNum gsc_make_targeted_crosses(gsc_SimData* d, const size_t n_combinations,
                                       const GSC_GLOBALX_T* firstParents, const GSC_GLOBALX_T* secondParents,
                                       const gsc_MapID map1, const gsc_MapID map2, const gsc_GenOptions g);
gsc_GroupNum gsc_self_n_times(gsc_SimData* d, const unsigned int n, const gsc_GroupNum group, 
                              const gsc_MapID which_map, const gsc_GenOptions g);
gsc_GroupNum gsc_make_doubled_haploids(gsc_SimData* d, const gsc_GroupNum group, 
                                       const gsc_MapID which_map, const gsc_GenOptions g);
gsc_GroupNum gsc_make_clones(gsc_SimData* d, const gsc_GroupNum group, 
                             const _Bool inherit_names, const gsc_GenOptions g);
 
gsc_GroupNum gsc_make_all_unidirectional_crosses(gsc_SimData* d, const gsc_GroupNum from_group, 
                                                 const gsc_MapID mapID, const gsc_GenOptions g);
gsc_GroupNum gsc_make_crosses_from_file(gsc_SimData* d, const char* input_file, 
                                        const gsc_MapID map1, const gsc_MapID map2, const gsc_GenOptions g);
gsc_GroupNum gsc_make_double_crosses_from_file(gsc_SimData* d, const char* input_file, 
                                        const gsc_MapID map1, const gsc_MapID map2, const gsc_GenOptions g);
gsc_GroupNum gsc_split_by_bv(gsc_SimData* d, const gsc_GroupNum group, const gsc_EffectID effID,
                             const GSC_GLOBALX_T top_n, const _Bool lowIsBest);
gsc_DecimalMatrix gsc_calculate_bvs( const gsc_SimData* d, const gsc_GroupNum group, const gsc_EffectID effID);
gsc_DecimalMatrix gsc_calculate_utility_bvs(gsc_BidirectionalIterator* targets, const gsc_MarkerEffects* effset);
gsc_DecimalMatrix gsc_calculate_utility_local_bvs(gsc_BidirectionalIterator* targets, 
                                                  gsc_MarkerBlocks b,
                                                  gsc_MarkerEffects e);
gsc_DecimalMatrix gsc_calculate_allele_counts(const gsc_SimData* d, 
                                              const gsc_GroupNum group, 
                                              const char allele);
gsc_MarkerBlocks gsc_create_evenlength_blocks_each_chr(const gsc_SimData* d, const gsc_MapID mapid, const GSC_ID_T n);
gsc_MarkerBlocks gsc_load_blocks(const gsc_SimData* d, const char* block_file);
gsc_DecimalMatrix gsc_calculate_local_bvs(const gsc_SimData* d, 
                                                const gsc_GroupNum group,
                                                const gsc_MarkerBlocks b, 
                                                const gsc_EffectID effID); 
void gsc_calculate_optimal_haplotype(const gsc_SimData* d, 
                                      const gsc_EffectID effID, 
                                      const char symbol_na,
                                      char* opt_haplotype);
void gsc_calculate_optimal_possible_haplotype(const gsc_SimData* d, 
                                               const gsc_GroupNum group, 
                                               const gsc_EffectID effID,
                                               const char symbol_na,
                                               char* opt_haplotype);
double gsc_calculate_optimal_bv(const gsc_SimData* d, const gsc_EffectID effID);
double gsc_calculate_optimal_possible_bv(const gsc_SimData* d, const gsc_GroupNum group, const gsc_EffectID effID);
double gsc_calculate_minimal_bv(const gsc_SimData* d, const gsc_EffectID effID);
void gsc_delete_group(gsc_SimData* d, const gsc_GroupNum group_id);
void gsc_delete_label(gsc_SimData* d, const gsc_LabelID whichLabel);
void gsc_delete_genome(gsc_KnownGenome* g);
void gsc_delete_recombination_map(SimData* d, const gsc_MapID whichMap);
void gsc_delete_recombination_map_nointegrity(gsc_RecombinationMap* m);
void gsc_delete_allele_matrix(gsc_AlleleMatrix* m);
void gsc_delete_effects_table(gsc_MarkerEffects* m);
void gsc_delete_eff_set(gsc_SimData* d, gsc_EffectID whichID);
void gsc_delete_simdata(gsc_SimData* m);
void gsc_delete_markerblocks(gsc_MarkerBlocks* b);
void gsc_delete_dmatrix(gsc_DecimalMatrix* m);
void gsc_delete_bidirectional_iter(gsc_BidirectionalIterator* it);
void gsc_delete_randomaccess_iter(gsc_RandomAccessIterator* it);
 
void gsc_move_genotype(gsc_GenoLocation from, gsc_GenoLocation to, int* label_defaults);
 
// User-facing saving functions
void gsc_save_markerblocks(const char* fname, const gsc_SimData* d, const gsc_MarkerBlocks b, 
                           const gsc_MapID labelMapID);
void gsc_save_genotypes(const char* fname, const gsc_SimData* d, const gsc_GroupNum groupID, 
                        const _Bool markers_as_rows);
void gsc_save_allele_counts(const char* fname, 
                            const gsc_SimData* d, 
                            const gsc_GroupNum groupID, 
                            const char allele, 
                            const _Bool markers_as_rows);
void gsc_save_pedigrees(const char* fname, const gsc_SimData* d, const gsc_GroupNum groupID, 
                        const _Bool full_pedigree);
void gsc_save_bvs(const char* fname, const gsc_SimData* d, const gsc_GroupNum groupID, const gsc_EffectID effID);
void gsc_save_local_bvs(const char* fname, 
                        const gsc_SimData* d, 
                        const gsc_GroupNum groupID, 
                        const gsc_MarkerBlocks b,
                        const gsc_EffectID effID, 
                        const _Bool headers);
 
// Utility and helper saving functions
void gsc_save_utility_markerblocks(FILE* f, const gsc_MarkerBlocks b, const GSC_GENOLEN_T n_markers, 
        char** const marker_names, const gsc_RecombinationMap* map);
void gsc_save_utility_genotypes(FILE* f, gsc_BidirectionalIterator* targets, const GSC_GENOLEN_T n_markers,
        char** const marker_names, const _Bool markers_as_rows);
void gsc_save_utility_allele_counts(FILE* f, 
                                    gsc_BidirectionalIterator* targets,
                                    GSC_GENOLEN_T n_markers, 
                                    char** const marker_names, 
                                    const _Bool markers_as_rows, 
                                    const char allele);
void gsc_save_utility_pedigrees(FILE* f, gsc_BidirectionalIterator* targets,
        const _Bool full_pedigree, const gsc_AlleleMatrix* parent_pedigree_store);
void gsc_save_utility_bvs(FILE* f, gsc_BidirectionalIterator* targets, const gsc_MarkerEffects* eff);
 
void gsc_save_utility_dmatrix(FILE* f, DecimalMatrix* dec, char** row_headers, char** col_headers, _Bool dim1_is_columns);
 
// static GSC_LOGICVAL gsc_helper_is_marker_in_chr(const GSC_GENOLEN_T markerix, const gsc_LinkageGroup chr, double* pos);
 
// static void gsc_scaffold_save_genotype_info(FILE* f, gsc_BidirectionalIterator* targets, 
//        GSC_GENOLEN_T n_markers, char** const marker_names, const _Bool markers_as_rows,
//        void (*bodycell_printer)(FILE*, gsc_GenoLocation, size_t, void*), void* bodycell_printer_data);
// static void gsc_helper_output_genotypematrix_cell(FILE* f, gsc_GenoLocation loc, GSC_GENOLEN_T markerix, void* NA);
// static void gsc_helper_output_countmatrix_cell(FILE* f, gsc_GenoLocation loc, GSC_GENOLEN_T markerix, void* data);
 
// static void gsc_scaffold_save_ancestry_of(const gsc_AlleleMatrix* m, gsc_PedigreeID p1, gsc_PedigreeID p2,
//        void (*strprinter)(char*, size_t, void*), void (*intprinter)(int, void*), void* printer_data);
// static void gsc_helper_ancestry_strprinter_file(char* str, size_t strlen, void* data);
// static void gsc_helper_ancestry_intprinter_file(int i, void* data);
 
int* gsc_calculate_min_recombinations_fw1(gsc_SimData* d, gsc_MapID mapid, 
                                          char* parent1, unsigned int p1num, 
                                          char* parent2, unsigned int p2num, 
                                          char* offspring, int certain); // forward filling, window size 1
int* gsc_calculate_min_recombinations_fwn(gsc_SimData* d, gsc_MapID mapid, 
                                          char* parent1, unsigned int p1num, 
                                          char* parent2, unsigned int p2num, 
                                          char* offspring, int window_size, 
                                          int certain); // forward filling, window size n
 
static inline int gsc_has_same_alleles(const char* p1, const char* p2, const size_t i) {
    return (p1[i<<1] == p2[i<<1] || p1[(i<<1) + 1] == p2[i] || p1[i] == p2[(i<<1) + 1]);
}
// w is window length, i is start value
static inline int gsc_has_same_alleles_window(const char* g1, const char* g2, const size_t start, const size_t w) {
    int same = GSC_TRUE;
    int i;
    for (int j = 0; j < w; ++j) {
        i = start + j;
        same = same && (g1[i<<1] == g2[i<<1] || g1[(i<<1) + 1] == g2[i] || g1[i] == g2[(i<<1) + 1]);
    }
    return same;
}
 
int gsc_calculate_recombinations_from_file(gsc_SimData* d, const char* input_file, const char* output_file,
        int window_len, int certain);
#endif