Skip to main content

rsomics_call/
model.rs

1use std::num::NonZeroU8;
2
3use smallvec::SmallVec;
4
5use crate::{CallError, Result};
6
7#[derive(Clone, Debug, PartialEq, Eq, Hash)]
8pub struct Allele(SmallVec<[u8; 8]>);
9
10impl Allele {
11    pub fn new(value: impl AsRef<[u8]>) -> Result<Self> {
12        let value = value.as_ref();
13        let symbolic = value.len() > 2
14            && value.starts_with(b"<")
15            && value.ends_with(b">")
16            && value[1..value.len() - 1]
17                .iter()
18                .all(|byte| byte.is_ascii_alphanumeric() || b"*_:.-".contains(byte));
19        let valid = !value.is_empty()
20            && (value == b"*"
21                || symbolic
22                || value
23                    .iter()
24                    .all(|base| matches!(base, b'A' | b'C' | b'G' | b'T' | b'N')));
25        if valid {
26            Ok(Self(SmallVec::from_slice(value)))
27        } else {
28            Err(CallError::InvalidAllele(
29                String::from_utf8_lossy(value).into_owned(),
30            ))
31        }
32    }
33
34    pub fn as_bytes(&self) -> &[u8] {
35        &self.0
36    }
37}
38
39#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
40pub struct Ploidy(NonZeroU8);
41
42impl Ploidy {
43    pub fn new(value: u8) -> Result<Self> {
44        NonZeroU8::new(value)
45            .map(Self)
46            .ok_or(CallError::InvalidPloidy)
47    }
48
49    pub fn get(self) -> u8 {
50        self.0.get()
51    }
52}
53
54#[derive(Clone, Debug, PartialEq)]
55pub struct SampleAnnotations {
56    forward_allele_depths: SmallVec<[u32; 5]>,
57    reverse_allele_depths: SmallVec<[u32; 5]>,
58    allele_quality_means: SmallVec<[u32; 5]>,
59    strand_bias: u32,
60    soft_clipped_reads: u32,
61}
62
63impl SampleAnnotations {
64    pub fn new(
65        forward_allele_depths: impl IntoIterator<Item = u32>,
66        reverse_allele_depths: impl IntoIterator<Item = u32>,
67        allele_quality_means: impl IntoIterator<Item = u32>,
68        strand_bias: u32,
69        soft_clipped_reads: u32,
70    ) -> Result<Self> {
71        let forward_allele_depths = forward_allele_depths.into_iter().collect::<SmallVec<_>>();
72        let reverse_allele_depths = reverse_allele_depths.into_iter().collect::<SmallVec<_>>();
73        let allele_quality_means = allele_quality_means.into_iter().collect::<SmallVec<_>>();
74        if forward_allele_depths.is_empty()
75            || reverse_allele_depths.len() != forward_allele_depths.len()
76            || allele_quality_means.len() != forward_allele_depths.len()
77        {
78            return Err(CallError::InvalidLikelihoodDimensions);
79        }
80        Ok(Self::from_generated(
81            forward_allele_depths,
82            reverse_allele_depths,
83            allele_quality_means,
84            strand_bias,
85            soft_clipped_reads,
86        ))
87    }
88
89    pub(crate) fn from_generated(
90        forward_allele_depths: SmallVec<[u32; 5]>,
91        reverse_allele_depths: SmallVec<[u32; 5]>,
92        allele_quality_means: SmallVec<[u32; 5]>,
93        strand_bias: u32,
94        soft_clipped_reads: u32,
95    ) -> Self {
96        Self {
97            forward_allele_depths,
98            reverse_allele_depths,
99            allele_quality_means,
100            strand_bias,
101            soft_clipped_reads,
102        }
103    }
104
105    pub fn forward_allele_depths(&self) -> &[u32] {
106        &self.forward_allele_depths
107    }
108
109    pub fn reverse_allele_depths(&self) -> &[u32] {
110        &self.reverse_allele_depths
111    }
112
113    pub fn allele_quality_means(&self) -> &[u32] {
114        &self.allele_quality_means
115    }
116
117    pub fn strand_bias(&self) -> u32 {
118        self.strand_bias
119    }
120
121    pub fn soft_clipped_reads(&self) -> u32 {
122        self.soft_clipped_reads
123    }
124
125    fn select(&self, indices: &[usize]) -> Result<Self> {
126        let select = |values: &[u32]| {
127            indices
128                .iter()
129                .map(|&index| {
130                    values
131                        .get(index)
132                        .copied()
133                        .ok_or(CallError::InvalidLikelihoodDimensions)
134                })
135                .collect::<Result<Vec<_>>>()
136        };
137        Self::new(
138            select(&self.forward_allele_depths)?,
139            select(&self.reverse_allele_depths)?,
140            select(&self.allele_quality_means)?,
141            self.strand_bias,
142            self.soft_clipped_reads,
143        )
144    }
145}
146
147#[derive(Clone, Debug, PartialEq)]
148pub struct SampleEvidence {
149    depth: u32,
150    allele_depths: SmallVec<[u32; 5]>,
151    allele_quality_sums: SmallVec<[u32; 5]>,
152    annotations: Option<SampleAnnotations>,
153}
154
155impl SampleEvidence {
156    pub fn new(
157        depth: u32,
158        allele_depths: impl IntoIterator<Item = u32>,
159        allele_quality_sums: impl IntoIterator<Item = u32>,
160    ) -> Result<Self> {
161        let allele_depths = allele_depths.into_iter().collect::<SmallVec<_>>();
162        let allele_quality_sums = allele_quality_sums.into_iter().collect::<SmallVec<_>>();
163        if allele_depths.is_empty() || allele_quality_sums.len() != allele_depths.len() {
164            return Err(CallError::InvalidLikelihoodDimensions);
165        }
166        Ok(Self::from_generated(
167            depth,
168            allele_depths,
169            allele_quality_sums,
170        ))
171    }
172
173    pub(crate) fn from_generated(
174        depth: u32,
175        allele_depths: SmallVec<[u32; 5]>,
176        allele_quality_sums: SmallVec<[u32; 5]>,
177    ) -> Self {
178        Self {
179            depth,
180            allele_depths,
181            allele_quality_sums,
182            annotations: None,
183        }
184    }
185
186    pub fn with_annotations(mut self, annotations: SampleAnnotations) -> Result<Self> {
187        if annotations.forward_allele_depths.len() != self.allele_depths.len() {
188            return Err(CallError::InvalidLikelihoodDimensions);
189        }
190        if self
191            .allele_depths
192            .iter()
193            .zip(&annotations.forward_allele_depths)
194            .zip(&annotations.reverse_allele_depths)
195            .any(|((&depth, &forward), &reverse)| forward.checked_add(reverse) != Some(depth))
196        {
197            return Err(CallError::InvalidLikelihoodDimensions);
198        }
199        self.annotations = Some(annotations);
200        Ok(self)
201    }
202
203    pub(crate) fn with_generated_annotations(mut self, annotations: SampleAnnotations) -> Self {
204        self.annotations = Some(annotations);
205        self
206    }
207
208    pub fn empty(allele_count: usize) -> Result<Self> {
209        Self::new(
210            0,
211            std::iter::repeat_n(0, allele_count),
212            std::iter::repeat_n(0, allele_count),
213        )
214    }
215
216    pub fn allele_depths(&self) -> &[u32] {
217        &self.allele_depths
218    }
219
220    pub fn allele_quality_sums(&self) -> &[u32] {
221        &self.allele_quality_sums
222    }
223
224    pub fn depth(&self) -> u32 {
225        self.depth
226    }
227
228    pub fn annotations(&self) -> Option<&SampleAnnotations> {
229        self.annotations.as_ref()
230    }
231
232    pub(crate) fn select(&self, indices: &[usize]) -> Result<Self> {
233        let select = |values: &[u32]| {
234            indices
235                .iter()
236                .map(|&index| {
237                    values
238                        .get(index)
239                        .copied()
240                        .ok_or(CallError::InvalidLikelihoodDimensions)
241                })
242                .collect::<Result<Vec<_>>>()
243        };
244        let mut evidence = Self::new(
245            self.depth,
246            select(&self.allele_depths)?,
247            select(&self.allele_quality_sums)?,
248        )?;
249        if let Some(annotations) = &self.annotations {
250            evidence = evidence.with_annotations(annotations.select(indices)?)?;
251        }
252        Ok(evidence)
253    }
254
255    pub(crate) fn set_depth(&mut self, depth: u32) {
256        self.depth = depth;
257    }
258}
259
260#[derive(Clone, Debug, PartialEq)]
261pub struct SampleLikelihood {
262    ploidy: Ploidy,
263    phred_likelihoods: Option<SmallVec<[u32; 15]>>,
264    evidence: SampleEvidence,
265}
266
267impl SampleLikelihood {
268    pub fn new(
269        ploidy: Ploidy,
270        phred_likelihoods: Option<Box<[u32]>>,
271        evidence: SampleEvidence,
272    ) -> Result<Self> {
273        if phred_likelihoods.as_ref().is_some_and(|likelihoods| {
274            genotype_count(evidence.allele_depths.len(), ploidy.get())
275                .is_none_or(|count| count != likelihoods.len())
276        }) {
277            return Err(CallError::InvalidLikelihoodDimensions);
278        }
279        Ok(Self {
280            ploidy,
281            phred_likelihoods: phred_likelihoods.map(|values| values.into_vec().into()),
282            evidence,
283        })
284    }
285
286    pub fn observed(
287        ploidy: Ploidy,
288        phred_likelihoods: impl IntoIterator<Item = u32>,
289        evidence: SampleEvidence,
290    ) -> Result<Self> {
291        let phred_likelihoods = phred_likelihoods.into_iter().collect::<SmallVec<_>>();
292        if genotype_count(evidence.allele_depths.len(), ploidy.get())
293            .is_none_or(|count| count != phred_likelihoods.len())
294        {
295            return Err(CallError::InvalidLikelihoodDimensions);
296        }
297        Ok(Self {
298            ploidy,
299            phred_likelihoods: Some(phred_likelihoods),
300            evidence,
301        })
302    }
303
304    pub(crate) fn observed_generated(
305        ploidy: Ploidy,
306        phred_likelihoods: SmallVec<[u32; 15]>,
307        evidence: SampleEvidence,
308    ) -> Self {
309        Self {
310            ploidy,
311            phred_likelihoods: Some(phred_likelihoods),
312            evidence,
313        }
314    }
315
316    pub fn missing(allele_count: usize, ploidy: Ploidy) -> Result<Self> {
317        Self::new(ploidy, None, SampleEvidence::empty(allele_count)?)
318    }
319
320    pub fn ploidy(&self) -> Ploidy {
321        self.ploidy
322    }
323
324    pub fn phred_likelihoods(&self) -> Option<&[u32]> {
325        self.phred_likelihoods.as_deref()
326    }
327
328    pub fn evidence(&self) -> &SampleEvidence {
329        &self.evidence
330    }
331}
332
333#[derive(Clone, Copy, Debug, PartialEq)]
334pub struct IndelSummary {
335    maximum_support: u32,
336    maximum_fraction: f32,
337}
338
339impl IndelSummary {
340    pub fn new(maximum_support: u32, maximum_fraction: f32) -> Result<Self> {
341        if !maximum_fraction.is_finite() || !(0.0..=1.0).contains(&maximum_fraction) {
342            return Err(CallError::InvalidIndelSummary);
343        }
344        Ok(Self {
345            maximum_support,
346            maximum_fraction,
347        })
348    }
349
350    pub fn maximum_support(self) -> u32 {
351        self.maximum_support
352    }
353
354    pub fn maximum_fraction(self) -> f32 {
355        self.maximum_fraction
356    }
357}
358
359#[derive(Clone, Debug, PartialEq, Eq)]
360pub struct PriorAlleleCounts {
361    total: u32,
362    alternates: Box<[u32]>,
363}
364
365impl PriorAlleleCounts {
366    pub fn new(total: u32, alternates: impl Into<Box<[u32]>>) -> Result<Self> {
367        let alternates = alternates.into();
368        let alternate_total = alternates.iter().try_fold(0u32, |sum, &count| {
369            sum.checked_add(count)
370                .ok_or(CallError::InvalidPriorAlleleCounts)
371        })?;
372        if alternate_total > total {
373            return Err(CallError::InvalidPriorAlleleCounts);
374        }
375        Ok(Self { total, alternates })
376    }
377
378    pub fn total(&self) -> u32 {
379        self.total
380    }
381
382    pub fn alternates(&self) -> &[u32] {
383        &self.alternates
384    }
385
386    pub(crate) fn select(&self, retained: &[usize]) -> Self {
387        let reference = self.total - self.alternates.iter().sum::<u32>();
388        let alternates = retained
389            .iter()
390            .skip(1)
391            .map(|&index| self.alternates[index - 1])
392            .collect::<Box<[_]>>();
393        Self {
394            total: reference + alternates.iter().sum::<u32>(),
395            alternates,
396        }
397    }
398}
399
400#[derive(Clone, Debug, PartialEq)]
401pub struct SiteAnnotations {
402    raw_depth: u32,
403    auxiliary: [f32; 16],
404    variant_distance_bias: Option<f32>,
405    read_position_bias: Option<f32>,
406    mapping_quality_bias: Option<f32>,
407    base_quality_bias: Option<f32>,
408    mapping_quality_strand_bias: Option<f32>,
409    mismatch_bias: Option<f32>,
410    soft_clip_bias: Option<f32>,
411    strand_bias: Option<f32>,
412    segregation_bias: Option<f32>,
413    zero_mapping_quality_fraction: f32,
414    average_mismatches: Option<[f32; 2]>,
415}
416
417pub(crate) struct SiteAnnotationValues {
418    pub(crate) raw_depth: u32,
419    pub(crate) auxiliary: [f32; 16],
420    pub(crate) variant_distance_bias: Option<f32>,
421    pub(crate) read_position_bias: Option<f32>,
422    pub(crate) mapping_quality_bias: Option<f32>,
423    pub(crate) base_quality_bias: Option<f32>,
424    pub(crate) mapping_quality_strand_bias: Option<f32>,
425    pub(crate) mismatch_bias: Option<f32>,
426    pub(crate) soft_clip_bias: Option<f32>,
427    pub(crate) strand_bias: Option<f32>,
428    pub(crate) segregation_bias: Option<f32>,
429    pub(crate) zero_mapping_quality_fraction: f32,
430    pub(crate) average_mismatches: Option<[f32; 2]>,
431}
432
433impl SiteAnnotations {
434    pub(crate) fn new(values: SiteAnnotationValues) -> Result<Self> {
435        let SiteAnnotationValues {
436            raw_depth,
437            auxiliary,
438            variant_distance_bias,
439            read_position_bias,
440            mapping_quality_bias,
441            base_quality_bias,
442            mapping_quality_strand_bias,
443            mismatch_bias,
444            soft_clip_bias,
445            strand_bias,
446            segregation_bias,
447            zero_mapping_quality_fraction,
448            average_mismatches,
449        } = values;
450        let finite = auxiliary.iter().all(|value| value.is_finite())
451            && [
452                variant_distance_bias,
453                read_position_bias,
454                mapping_quality_bias,
455                base_quality_bias,
456                mapping_quality_strand_bias,
457                mismatch_bias,
458                soft_clip_bias,
459                strand_bias,
460                segregation_bias,
461            ]
462            .into_iter()
463            .flatten()
464            .all(f32::is_finite)
465            && zero_mapping_quality_fraction.is_finite()
466            && (0.0..=1.0).contains(&zero_mapping_quality_fraction)
467            && average_mismatches.is_none_or(|values| values.into_iter().all(f32::is_finite));
468        if !finite {
469            return Err(CallError::InvalidLikelihoodAnnotations);
470        }
471        Ok(Self {
472            raw_depth,
473            auxiliary,
474            variant_distance_bias,
475            read_position_bias,
476            mapping_quality_bias,
477            base_quality_bias,
478            mapping_quality_strand_bias,
479            mismatch_bias,
480            soft_clip_bias,
481            strand_bias,
482            segregation_bias,
483            zero_mapping_quality_fraction,
484            average_mismatches,
485        })
486    }
487
488    pub fn raw_depth(&self) -> u32 {
489        self.raw_depth
490    }
491
492    pub fn auxiliary(&self) -> &[f32; 16] {
493        &self.auxiliary
494    }
495
496    pub fn variant_distance_bias(&self) -> Option<f32> {
497        self.variant_distance_bias
498    }
499
500    pub fn read_position_bias(&self) -> Option<f32> {
501        self.read_position_bias
502    }
503
504    pub fn mapping_quality_bias(&self) -> Option<f32> {
505        self.mapping_quality_bias
506    }
507
508    pub fn base_quality_bias(&self) -> Option<f32> {
509        self.base_quality_bias
510    }
511
512    pub fn mapping_quality_strand_bias(&self) -> Option<f32> {
513        self.mapping_quality_strand_bias
514    }
515
516    pub fn mismatch_bias(&self) -> Option<f32> {
517        self.mismatch_bias
518    }
519
520    pub fn soft_clip_bias(&self) -> Option<f32> {
521        self.soft_clip_bias
522    }
523
524    pub fn strand_bias(&self) -> Option<f32> {
525        self.strand_bias
526    }
527
528    pub fn segregation_bias(&self) -> Option<f32> {
529        self.segregation_bias
530    }
531
532    pub fn zero_mapping_quality_fraction(&self) -> f32 {
533        self.zero_mapping_quality_fraction
534    }
535
536    pub fn average_mismatches(&self) -> Option<[f32; 2]> {
537        self.average_mismatches
538    }
539}
540
541#[derive(Clone, Debug, PartialEq)]
542pub struct LikelihoodSite {
543    reference_sequence_id: usize,
544    position: u64,
545    reference: Allele,
546    alternates: SmallVec<[Allele; 4]>,
547    allele_quality_sums: SmallVec<[f32; 5]>,
548    samples: SmallVec<[SampleLikelihood; 1]>,
549    indel_summary: Option<IndelSummary>,
550    annotations: Option<SiteAnnotations>,
551    prior_allele_counts: Option<PriorAlleleCounts>,
552}
553
554impl LikelihoodSite {
555    pub fn new(
556        reference_sequence_id: usize,
557        position: u64,
558        reference: Allele,
559        alternates: impl IntoIterator<Item = Allele>,
560        allele_quality_sums: impl IntoIterator<Item = f32>,
561        samples: impl IntoIterator<Item = SampleLikelihood>,
562    ) -> Result<Self> {
563        let alternates = alternates.into_iter().collect::<SmallVec<[Allele; 4]>>();
564        if alternates.is_empty()
565            || alternates.iter().any(|allele| allele == &reference)
566            || alternates
567                .iter()
568                .enumerate()
569                .any(|(index, allele)| alternates[..index].contains(allele))
570        {
571            return Err(CallError::InvalidLikelihoodDimensions);
572        }
573        let allele_count = alternates.len() + 1;
574        let allele_quality_sums = allele_quality_sums
575            .into_iter()
576            .collect::<SmallVec<[f32; 5]>>();
577        if allele_quality_sums.len() != allele_count
578            || allele_quality_sums
579                .iter()
580                .any(|value| !value.is_finite() || *value < 0.0)
581        {
582            return Err(CallError::InvalidLikelihoodDimensions);
583        }
584        let samples = samples
585            .into_iter()
586            .collect::<SmallVec<[SampleLikelihood; 1]>>();
587        if samples.iter().any(|sample| {
588            sample.evidence().allele_depths().len() != allele_count
589                || sample.phred_likelihoods().is_some_and(|likelihoods| {
590                    genotype_count(allele_count, sample.ploidy().get())
591                        .is_none_or(|count| count != likelihoods.len())
592                })
593        }) {
594            return Err(CallError::InvalidLikelihoodDimensions);
595        }
596        Ok(Self::from_generated(
597            reference_sequence_id,
598            position,
599            reference,
600            alternates,
601            allele_quality_sums,
602            samples,
603        ))
604    }
605
606    pub(crate) fn from_generated(
607        reference_sequence_id: usize,
608        position: u64,
609        reference: Allele,
610        alternates: SmallVec<[Allele; 4]>,
611        allele_quality_sums: SmallVec<[f32; 5]>,
612        samples: SmallVec<[SampleLikelihood; 1]>,
613    ) -> Self {
614        Self {
615            reference_sequence_id,
616            position,
617            reference,
618            alternates,
619            allele_quality_sums,
620            samples,
621            indel_summary: None,
622            annotations: None,
623            prior_allele_counts: None,
624        }
625    }
626
627    pub fn with_indel_summary(mut self, summary: IndelSummary) -> Self {
628        self.indel_summary = Some(summary);
629        self
630    }
631
632    pub fn with_annotations(mut self, annotations: SiteAnnotations) -> Self {
633        self.annotations = Some(annotations);
634        self
635    }
636
637    pub fn with_prior_allele_counts(mut self, counts: PriorAlleleCounts) -> Result<Self> {
638        if counts.alternates.len() != self.alternates.len() {
639            return Err(CallError::InvalidPriorAlleleCounts);
640        }
641        self.prior_allele_counts = Some(counts);
642        Ok(self)
643    }
644
645    pub fn reference_sequence_id(&self) -> usize {
646        self.reference_sequence_id
647    }
648
649    pub fn position(&self) -> u64 {
650        self.position
651    }
652
653    pub fn reference(&self) -> &Allele {
654        &self.reference
655    }
656
657    pub fn alternates(&self) -> &[Allele] {
658        &self.alternates
659    }
660
661    pub fn allele_quality_sums(&self) -> &[f32] {
662        &self.allele_quality_sums
663    }
664
665    pub fn samples(&self) -> &[SampleLikelihood] {
666        &self.samples
667    }
668
669    pub fn indel_summary(&self) -> Option<IndelSummary> {
670        self.indel_summary
671    }
672
673    pub fn annotations(&self) -> Option<&SiteAnnotations> {
674        self.annotations.as_ref()
675    }
676
677    pub fn prior_allele_counts(&self) -> Option<&PriorAlleleCounts> {
678        self.prior_allele_counts.as_ref()
679    }
680}
681
682fn genotype_count(allele_count: usize, ploidy: u8) -> Option<usize> {
683    let ploidy = usize::from(ploidy);
684    let n = allele_count.checked_add(ploidy)?.checked_sub(1)?;
685    let k = ploidy.min(n.checked_sub(ploidy)?);
686    (1..=k).try_fold(1usize, |value, divisor| {
687        value
688            .checked_mul(n.checked_sub(k)?.checked_add(divisor)?)
689            .map(|value| value / divisor)
690    })
691}
692
693#[cfg(test)]
694mod tests {
695    use super::*;
696
697    #[test]
698    fn sample_dimensions_follow_vcf_genotype_order() {
699        let diploid = Ploidy::new(2).unwrap();
700        let evidence = SampleEvidence::new(8, [3, 4, 1], [30, 40, 10]).unwrap();
701        assert!(SampleLikelihood::observed(diploid, [0, 1, 2, 3, 4, 5], evidence.clone()).is_ok());
702        assert_eq!(
703            SampleLikelihood::observed(diploid, [0, 1, 2], evidence),
704            Err(CallError::InvalidLikelihoodDimensions)
705        );
706        assert_eq!(
707            SampleLikelihood::missing(3, diploid)
708                .unwrap()
709                .phred_likelihoods(),
710            None
711        );
712    }
713
714    #[test]
715    fn sites_reject_duplicate_alleles() {
716        let reference = Allele::new(&b"A"[..]).unwrap();
717        let alternate = Allele::new(&b"G"[..]).unwrap();
718        let evidence = SampleEvidence::new(5, [4, 1], [40, 10]).unwrap();
719        let sample =
720            SampleLikelihood::observed(Ploidy::new(2).unwrap(), [0, 10, 20], evidence).unwrap();
721        assert!(
722            LikelihoodSite::new(0, 9, reference.clone(), [alternate], [1.0, 0.2], [sample]).is_ok()
723        );
724        assert_eq!(
725            LikelihoodSite::new(0, 9, reference.clone(), [reference], [1.0, 0.0], []),
726            Err(CallError::InvalidLikelihoodDimensions)
727        );
728    }
729
730    #[test]
731    fn allele_and_missing_sample_boundaries_are_checked() {
732        assert!(Allele::new(&b"<NON_REF>"[..]).is_ok());
733        assert_eq!(
734            Allele::new(&b"<>"[..]),
735            Err(CallError::InvalidAllele("<>".to_owned()))
736        );
737        assert_eq!(
738            SampleLikelihood::missing(0, Ploidy::new(2).unwrap()),
739            Err(CallError::InvalidLikelihoodDimensions)
740        );
741        assert_eq!(
742            SampleEvidence::new(1, [1, 0], [20]),
743            Err(CallError::InvalidLikelihoodDimensions)
744        );
745        assert_eq!(
746            LikelihoodSite::new(
747                0,
748                9,
749                Allele::new(&b"A"[..]).unwrap(),
750                [Allele::new(&b"G"[..]).unwrap()],
751                [1.0, f32::NAN],
752                []
753            ),
754            Err(CallError::InvalidLikelihoodDimensions)
755        );
756
757        assert_eq!(
758            PriorAlleleCounts::new(3, [2, 2]),
759            Err(CallError::InvalidPriorAlleleCounts)
760        );
761        let counts = PriorAlleleCounts::new(4, [1, 1]).unwrap();
762        let site = LikelihoodSite::new(
763            0,
764            9,
765            Allele::new(&b"A"[..]).unwrap(),
766            [Allele::new(&b"G"[..]).unwrap()],
767            [1.0, 1.0],
768            [],
769        )
770        .unwrap();
771        assert_eq!(
772            site.with_prior_allele_counts(counts),
773            Err(CallError::InvalidPriorAlleleCounts)
774        );
775    }
776}