palisade | based security , authorization , and filtering utilities | Authorization library

CKKS, which is also available in PALISADE, would be a much better option for your scenario as it supports approximate (floating-point-like) arithmetic and does not require high precision (large plaintext modulus). BFV performs all operations exactly (mod plaintext modulus). You would have to use a really large plaintext modulus to make sure your result does not wrap around the plaintext modulus. This gets much worse as you increase the depth, e.g., two chained multiplications.

For matrix-vector multiplication, you could use the techniques described in https://eprint.iacr.org/2019/223, https://eprint.iacr.org/2018/254, and the supplemental information of https://eprint.iacr.org/2020/563. The main idea is to choose the right encoding and take advantage of SIMD packing. You would work with a power-of-two vector size and could pack the matrix either as 64xY (multiple rows) per ciphertext or a part of each row per ciphertext, depending on which one is more efficient.

I have some experience with the SEAL library which also uses the BFV encryption scheme. The BFV scheme uses modular arithmetic and is able to encrypt integers (not real numbers).

For the parameters you're asking about:

• The Plaintext Modulus is an upper bound for the input integers. If this parameter is too low, it might cause your integers to overflow (depending on how large they are of course)
• The Sigma is the distribution parameter for Gaussian noise generation
• The Depth is the circuit depth which is the maximum number of multiplications on a path

Also for the Packed Plaintext, you should use vectors not arrays. Maybe that will fix your problem. If not, try lowering the size and make several vectors if necessary.

INSTR might be one option; I presumed that you want any "co" string, regardless its letter case (that's why I used lower function). If you don't need it, remove it.

Give this a try:

\s*CTN\d{1,2}:[\S\s]*?(?=\s+CTN|\Z)

https://regex101.com/r/ElfRn6/1

Change this:

Take another look at the @RISK documentation that you linked to and the docstring for numpy.random.lognormal. The @RISK function whose parameters match those of numpy.random.lognormal is RiskLognorm2. The parameters for numpy.random.lognormal and RiskLognorm2 are the mean and standard deviation of the underlying normal distribution. In other words, they describe the distribution of the logarithm of the data.

The @RISK documentation explains that the parameters for RiskLognorm are the mean and standard distribution of the log-normal distribution itself. It gives the formulas for translating between the two methods of parametrizing the distribution.

If you are sure that the parameters in the @RISK code are correct, then you will have to translate those parameters to the form used by numpy.random.lognormal. Given the values mean and stddev as the parameters used by RiskLognorm, you can get the parameters mu and sigma of numpy.random.lognormal as follows:

This should do the trick, it will apply the as.character function to each column of the dataframe. The apply function will return a matrix, so it just needs to be coerced to a dataframe by wrapping it with as.data.frame

I think this should work: