Implement a new function of Cross-Immunity

[thienktran]

Description

We want to implement a new function of Cross-Immunity.

Possible Solution

Use the cross-immunity model from L&L paper

The main difference between L&L and jhudd's paper is

• jhudd's paper has a max on x_j (the max is across all time points)
• jhudd's paper has a specific form of the cross-immunity distance (exp(- ...))

This difference exists because each strain only appears in one timepoint in the L&L method and its frequency is calculated in a single time bin.

[matsen]

All we need to do is to have a function that maps the number of mismatches between the sequences to a number between 0 and 1, which will be the risk of infection given an immune history.

Proposal:

• say we have a potentially infecting strain x and an immune history h1, ... , h_n.
• for each h_i, let's define a function f(x, h_i) that describes the risk of infection for someone with only h_i as their immune history
• for a full immune history, take the product of f(x, h_i) across all i

What is f(x, h_i)?

Two options:

• Linear: a + b*d, where d is the Hamming distance between x and h_i. Note that a and b need to be set so that f stays in the range [0, 1] (think about d's maximum value)
• Exponential: something like 1-exp(-(a + b*d))... but we can nail down the specifics later

The details don't matter much but we need to be able to allow a few functional forms, and each one should have some coefficients associated with it.

[thienktran]

Linear:

Map input numbers in the range [0, dMax] to output range [0, 1] where dMax = the length of the sequence

int input = this.distance(h_i); // hamming distance of x and h_i

int input_start = 0 // The lowest number of the range input. 
int input_end = Parameters.sequence.length(); // The largest number of the range input. 

int output_start = 0; // The lowest number of the range output. 
int output_end = 1; // The largest number of the range output. 

double slope = (double) (output_end - output_start) / (input_end - input_start) 
double output = output_start + Math.round(slope * (input - input_start))

a: output_start b: (input - input_start) x: slope

Since all sequences are the same length, slope only needs to be calculated once.

Exponential:

Something similar to what I wrote above, but using this equation instead?

Ideas to allow a few functional forms in riskOfInfection()

• Lambda functions (Java 8)
• Switch statements

@matsen