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}