Struct bed_reader::BedBuilder

pub struct BedBuilder { /* private fields */ }

Builder for Bed.

Implementations

impl BedBuilder

pub fn build(&self) -> Result<Bed, BedErrorPlus>

Create Bed from the builder.

See Bed::builder for more details and examples.

pub fn fid<I: IntoIterator<Item = T>, T: AsRef<str>>(self, fid: I) -> Self

Override the family id (fid) values found in the .fam file.

By default, if fid values are needed and haven’t already been found, they will be read from the .fam file. Providing them here avoids that file read and provides a way to give different values.

pub fn iid<I: IntoIterator<Item = T>, T: AsRef<str>>(self, iid: I) -> Self

Override the individual id (iid) values found in the .fam file.

By default, if iid values are needed and haven’t already been found, they will be read from the .fam file. Providing them here avoids that file read and provides a way to give different values.

use ndarray as nd;
use bed_reader::{Bed, assert_eq_nan, sample_bed_file};
let file_name = sample_bed_file("small.bed")?;
use bed_reader::ReadOptions;

let mut bed = Bed::builder(file_name)
   .iid(["sample1", "sample2", "sample3"])
   .build()?;
println!("{:?}", bed.iid()?); // Outputs ndarray ["sample1", "sample2", "sample3"]

pub fn father<I: IntoIterator<Item = T>, T: AsRef<str>>(self, father: I) -> Self

Override the father values found in the .fam file. nd By default, if father values are needed and haven’t already been found, they will be read from the .fam file. Providing them here avoids that file read and provides a way to gi&ve different values.

pub fn mother<I: IntoIterator<Item = T>, T: AsRef<str>>(self, mother: I) -> Self

Override the mother values found in the .fam file.

By default, if mother values are needed and haven’t already been found, they will be read from the .fam file. Providing them here avoids that file read and provides a way to give different values.

pub fn sex<I: IntoIterator<Item = i32>>(self, sex: I) -> Self

Override the sex values found in the .fam file.

By default, if sex values are needed and haven’t already been found, they will be read from the .fam file. Providing them here avoids that file read and provides a way to give different values.

pub fn pheno<I: IntoIterator<Item = T>, T: AsRef<str>>(self, pheno: I) -> Self

Override the phenotype values found in the .fam file.

Note that the phenotype values in the .fam file are seldom used. By default, if phenotype values are needed and haven’t already been found, they will be read from the .fam file. Providing them here avoids that file read and provides a way to give different values.

pub fn chromosome<I: IntoIterator<Item = T>, T: AsRef<str>>(
    self,
    chromosome: I
) -> Self

Override the chromosome values found in the .bim file.

By default, if chromosome values are needed and haven’t already been found, they will be read from the .bim file. Providing them here avoids that file read and provides a way to give different values.

pub fn sid<I: IntoIterator<Item = T>, T: AsRef<str>>(self, sid: I) -> Self

Override the SNP id (sid) values found in the .fam file.

By default, if sid values are needed and haven’t already been found, they will be read from the .bim file. Providing them here avoids that file read and provides a way to give different values.

use ndarray as nd;
use bed_reader::{Bed, ReadOptions, assert_eq_nan, sample_bed_file};
let file_name = sample_bed_file("small.bed")?;

let mut bed = Bed::builder(file_name)
   .sid(["SNP1", "SNP2", "SNP3", "SNP4"])
   .build()?;
println!("{:?}", bed.sid()?); // Outputs ndarray ["SNP1", "SNP2", "SNP3", "SNP4"]

pub fn cm_position<I: IntoIterator<Item = f32>>(self, cm_position: I) -> Self

Override the centimorgan position values found in the .bim file.

By default, if centimorgan position values are needed and haven’t already been found, they will be read from the .bim file. Providing them here avoids that file read and provides a way to give different values.

pub fn bp_position<I: IntoIterator<Item = i32>>(self, bp_position: I) -> Self

Override the base-pair position values found in the .bim file.

By default, if base-pair position values are needed and haven’t already been found, they will be read from the .bim file. Providing them here avoids that file read and provides a way to give different values.

pub fn allele_1<I: IntoIterator<Item = T>, T: AsRef<str>>(
    self,
    allele_1: I
) -> Self

Override the allele 1 values found in the .bim file.

By default, if allele 1 values are needed and haven’t already been found, they will be read from the .bim file. Providing them here avoids that file read and provides a way to give different values.

pub fn allele_2<I: IntoIterator<Item = T>, T: AsRef<str>>(
    self,
    allele_2: I
) -> Self

Override the allele 2 values found in the .bim file.

By default, if allele 2 values are needed and haven’t already been found, they will be read from the .bim file. Providing them here avoids that file read and provides a way to give different values.

pub fn iid_count(self, count: usize) -> Self

Set the number of individuals (samples) in the data.

By default, if this number is needed, it will be found and remembered by opening the .fam file and quickly counting the number of lines. Providing the number thus avoids a file read.

pub fn sid_count(self, count: usize) -> Self

Set the number of SNPs in the data.

By default, if this number is needed, it will be found and remembered by opening the .bim file and quickly counting the number of lines. Providing the number thus avoids a file read.

pub fn skip_early_check(self) -> Self

Don’t check the header of the .bed file until and unless the file is actually read.

By default, when a Bed struct is created, the .bed file header is checked. This stops that early check.

pub fn fam_path<P: AsRef<Path>>(self, path: P) -> Self

Set the path to the .fam file.

If not set, the .fam file will be assumed to have the same name as the .bed file, but with the extension .fam.

Example:

Read .bed, .fam, and .bim files with non-standard names.

use bed_reader::{Bed, ReadOptions, sample_files};
let deb_maf_mib = sample_files(["small.deb", "small.maf", "small.mib"])?;
let mut bed = Bed::builder(&deb_maf_mib[0])
   .fam_path(&deb_maf_mib[1])
   .bim_path(&deb_maf_mib[2])
   .build()?;
println!("{:?}", bed.iid()?); // Outputs ndarray ["iid1", "iid2", "iid3"]
println!("{:?}", bed.sid()?); // Outputs ndarray ["sid1", "sid2", "sid3", "sid4"]

pub fn bim_path<P: AsRef<Path>>(self, path: P) -> Self

Set the path to the .bim file.

If not set, the .bim file will be assumed to have the same name as the .bed file, but with the extension .bim.

Example:

Read .bed, .fam, and .bim files with non-standard names.

use bed_reader::{Bed, ReadOptions, sample_files};
let deb_maf_mib = sample_files(["small.deb", "small.maf", "small.mib"])?;
let mut bed = Bed::builder(&deb_maf_mib[0])
   .fam_path(&deb_maf_mib[1])
   .bim_path(&deb_maf_mib[2])
   .build()?;
println!("{:?}", bed.iid()?); // Outputs ndarray ["iid1", "iid2", "iid3"]
println!("{:?}", bed.sid()?); // Outputs ndarray ["sid1", "sid2", "sid3", "sid4"]

pub fn skip_fid(self) -> Self

Don’t read the fid information from the .fam file.

By default, when the .fam is read, the fid (the family id) is recorded. This stops that recording. This is useful if the fid is not needed. Asking for the fid after skipping it results in an error.

pub fn skip_iid(self) -> Self

Don’t read the iid information from the .fam file.

By default, when the .fam is read, the iid (the individual id) is recorded. This stops that recording. This is useful if the iid is not needed. Asking for the iid after skipping it results in an error.

pub fn skip_father(self) -> Self

Don’t read the father information from the .fam file.

By default, when the .fam is read, the father id is recorded. This stops that recording. This is useful if the father id is not needed. Asking for the father id after skipping it results in an error.

pub fn skip_mother(self) -> Self

Don’t read the mother information from the .fam file.

By default, when the .fam is read, the mother id is recorded. This stops that recording. This is useful if the mother id is not needed. Asking for the mother id after skipping it results in an error.

pub fn skip_sex(self) -> Self

Don’t read the sex information from the .fam file.

By default, when the .fam is read, the sex is recorded. This stops that recording. This is useful if sex is not needed. Asking for sex after skipping it results in an error.

pub fn skip_pheno(self) -> Self

Don’t read the phenotype information from the .fam file.

Note that the phenotype information in the .fam file is seldom used.

By default, when the .fam is read, the phenotype is recorded. This stops that recording. This is useful if this phenotype information is not needed. Asking for the phenotype after skipping it results in an error.

pub fn skip_chromosome(self) -> Self

Don’t read the chromosome information from the .bim file.

By default, when the .bim is read, the chromosome is recorded. This stops that recording. This is useful if the chromosome is not needed. Asking for the chromosome after skipping it results in an error.

pub fn skip_sid(self) -> Self

Don’t read the SNP id information from the .bim file.

By default, when the .bim is read, the sid (SNP id) is recorded. This stops that recording. This is useful if the sid is not needed. Asking for the sid after skipping it results in an error.

pub fn skip_cm_position(self) -> Self

Don’t read the centimorgan position information from the .bim file.

By default, when the .bim is read, the cm position is recorded. This stops that recording. This is useful if the cm position is not needed. Asking for the cm position after skipping it results in an error.

pub fn skip_bp_position(self) -> Self

Don’t read the base-pair position information from the .bim file.

By default, when the .bim is read, the bp position is recorded. This stops that recording. This is useful if the bp position is not needed. Asking for the cp position after skipping it results in an error.

pub fn skip_allele_1(self) -> Self

Don’t read the allele 1 information from the .bim file.

By default, when the .bim is read, allele 1 is recorded. This stops that recording. This is useful if allele 1 is not needed. Asking for allele 1 after skipping it results in an error.

pub fn skip_allele_2(self) -> Self

Don’t read the allele 2 information from the .bim file.

By default, when the .bim is read, allele 2 is recorded. This stops that recording. This is useful if allele 2 is not needed. Asking for allele 2 after skipping it results in an error.

pub fn metadata(self, metadata: &Metadata) -> Self

Override the metadata in the .fam and .bim files with info merged in from a Metadata.

Example

In the example, we create a Metadata with iid and sid arrays. Next, we use BedBuilder to override the fid array and an iid array. Then, we add the metadata to the BedBuilder, overwriting iid (again) and overriding sid. Finally, we print these three arrays and chromosome. Chromosome was never overridden so it is read from the *.bim file.

 use ndarray as nd;
 use bed_reader::{Bed, Metadata, sample_bed_file};

 let file_name = sample_bed_file("small.bed")?;
 let metadata = Metadata::builder()
     .iid(["i1", "i2", "i3"])
     .sid(["s1", "s2", "s3", "s4"])
     .build()?;
 let mut bed = Bed::builder(file_name)
     .fid(["f1", "f2", "f3"])
     .iid(["x1", "x2", "x3"])
     .metadata(&metadata)
     .build()?;
 println!("{0:?}", bed.fid()?);  // Outputs ndarray ["f1", "f2", "f3"]
 println!("{0:?}", bed.iid()?);  // Outputs ndarray ["i1", "i2", "i3"]
 println!("{0:?}", bed.sid()?);  // Outputs ndarray ["s1", "s2", "s3", "s4"]
 println!("{0:?}", bed.chromosome()?);  // Outputs ndarray ["1", "1", "5", "Y"]

Trait Implementations

impl Clone for BedBuilder

fn clone(&self) -> BedBuilder

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for BedBuilder

fn default() -> Self

Returns the “default value” for a type.