{

public:

py::function function;

Library(const py::function function){

this->function = function;

};

void setOutput(py::tuple& result, std::vector<double>& output, double *outputSize)

{

int nRows = 0, idx = 0;

for (py::handle rowHandle : result[0])

{

py::list rows = py::cast<py::list>(rowHandle);

for (py::handle value : rows)

{

output.push_back(py::cast<double>(value));

idx++;

}

nRows++;

}

outputSize[0] = nRows;

outputSize[1] = (nRows == 0) ? 0 : idx / nRows;

}

// Domain overload

void invoke(std::vector<double>& params, std::vector<double>& bulkIn, std::vector<double>& bulkOut,

int contrast, int domainNumber, std::vector<double>& output, double *outputSize, double *roughness)

{

auto f = py::cast<std::function<py::tuple(py::list, py::list, py::list, int, int)>>(this->function);

auto result = f(py::cast(params), py::cast(bulkIn), py::cast(bulkOut), contrast, domainNumber);

*roughness = py::cast<double>(result[1]);

setOutput(result, output, outputSize);

};

// Non-Domain overload

void invoke(std::vector<double>& params, std::vector<double>& bulkIn, std::vector<double>& bulkOut,

int contrast, std::vector<double>& output, double *outputSize, double *roughness)

{

auto f = py::cast<std::function<py::tuple(py::list, py::list, py::list, int)>>(this->function);

auto result = f(py::cast(params), py::cast(bulkIn), py::cast(bulkOut), contrast);

*roughness = py::cast<double>(result[1]);

setOutput(result, output, outputSize);

};

{

public:

std::unique_ptr<dylib> library;

std::string functionName;

DylibEngine(std::string libName, std::string functionName)

{

this->functionName = functionName;

this->library = std::unique_ptr<dylib>(new dylib(libName));

if (!library)

{

std::cerr << "dynamic libray failed to load" << std::endl;

return;

}

};

~DylibEngine(){};

py::tuple invoke(std::vector<double>& params, std::vector<double>& bulkIn, std::vector<double>& bulkOut, int contrast, int domain=DEFAULT_DOMAIN)

{

try{

std::vector<double> tempOutput;

double *outputSize = new double[2];

double roughness = 0.0;

if (domain != -1) {

auto func = library->get_function<void(std::vector<double>&, std::vector<double>&, std::vector<double>&,

int, int, std::vector<double>&, double*, double*)>(functionName);

func(params, bulkIn, bulkOut, contrast, domain, tempOutput, outputSize, &roughness);

}

else {

auto func = library->get_function<void(std::vector<double>&, std::vector<double>&, std::vector<double>&,

int, std::vector<double>&, double*, double*)>(functionName);

func(params, bulkIn, bulkOut, contrast, tempOutput, outputSize, &roughness);

}

py::list output;

for (int32_T idx1{0}; idx1 < outputSize[0]; idx1++)

{

py::list rows;

for (int32_T idx2{0}; idx2 < outputSize[1]; idx2++)

{

rows.append(tempOutput[(int32_T)outputSize[1] * idx1 + idx2]);

}

output.append(rows);

}

return py::make_tuple(output, roughness);

}catch (const dylib::symbol_error &) {

throw std::runtime_error("failed to get dynamic libray symbol for ***functionName");

}

};

{

py::list reflectivity;

py::list shiftedData;

py::list sldProfiles;

py::list allLayers;

py::array_t<double> ssubs;

py::array_t<double> resample;

py::array_t<double> dataPresent;

std::string modelType;

{

public:

std::unique_ptr<dylib> library;

py::function callback;

EventBridge(py::function callback)

{

std::string filename = "eventManager" + std::string(dylib::extension);

this->library = std::unique_ptr<dylib>(new dylib(std::getenv("RAT_PATH"), filename.c_str()));

if (!library)

{

std::cerr << "event manager dynamic libray failed to load" << std::endl;

return;

}

this->callback = callback;

};

py::list unpackDataToCell(int rows, int cols, double* data, double* nData,

double* data2, double* nData2, int dataCol)

{

py::list allResults;

int dims[2] = {0, dataCol};

int offset = 0;

for (int i = 0; i < rows; i++){

py::list rowList;

dims[0] = (int)nData[i] / dataCol;

auto result = py::array_t<double, py::array::f_style>({dims[0], dims[1]});

std::memcpy(result.request().ptr, data + offset, result.nbytes());

offset += result.size();

rowList.append(result);

allResults.append(rowList);

}

if (data2 != NULL && nData2 != NULL)

{

// This is used to unpack the domains data into the second column

offset = 0;

for ( int i = 0; i < rows; i++){

dims[0] = (int)nData2[i] / dataCol;

auto result = py::array_t<double, py::array::f_style>({dims[0], dims[1]});

std::memcpy(result.request().ptr, data2 + offset, result.nbytes());

offset += result.size();

auto rowList = allResults[i].cast<py::list>();

rowList.append(result);

}

}

return allResults;

};

void eventCallback(const baseEvent& event)

{

if (event.type == EventTypes::Message) {

messageEvent* mEvent = (messageEvent*)&event;

this->callback(event.type, mEvent->msg);

} else if (event.type == EventTypes::Plot){

plotEvent* pEvent = (plotEvent*)&event;

PlotEventData eventData;

eventData.modelType = std::string(pEvent->data->modelType);

eventData.ssubs = py::array_t<double>(pEvent->data->nContrast);

std::memcpy(eventData.ssubs.request().ptr, pEvent->data->ssubs, eventData.ssubs.nbytes());

eventData.resample = py::array_t<double>(pEvent->data->nContrast);

std::memcpy(eventData.resample.request().ptr, pEvent->data->resample, eventData.resample.nbytes());

eventData.dataPresent = py::array_t<double>(pEvent->data->nContrast);

std::memcpy(eventData.dataPresent.request().ptr, pEvent->data->dataPresent, eventData.dataPresent.nbytes());

eventData.reflectivity = unpackDataToCell(pEvent->data->nContrast, 1,

pEvent->data->reflect, pEvent->data->nReflect, NULL, NULL, 2);

eventData.shiftedData = unpackDataToCell(pEvent->data->nContrast, 1,

pEvent->data->shiftedData, pEvent->data->nShiftedData, NULL, NULL, 3);

eventData.sldProfiles = unpackDataToCell(pEvent->data->nContrast, (pEvent->data->nSldProfiles2 == NULL) ? 1 : 2,

pEvent->data->sldProfiles, pEvent->data->nSldProfiles,

pEvent->data->sldProfiles2, pEvent->data->nSldProfiles2, 2);

eventData.allLayers = unpackDataToCell(pEvent->data->nContrast, (pEvent->data->nLayers2 == NULL) ? 1 : 2,

pEvent->data->layers, pEvent->data->nLayers,

pEvent->data->layers2, pEvent->data->nLayers, 2);

this->callback(event.type, eventData);

}

};

void registerEvent(EventTypes eventType)

{

std::function<void(const baseEvent& event)> caller = std::bind(&EventBridge::eventCallback, this, std::placeholders::_1);

auto addListener = library->get_function<void(EventTypes, std::function<void(const baseEvent&)>)>("addListener");

addListener(eventType, caller);

};

void clear()

{

auto clearListeners = library->get_function<void(void)>("clearListeners");

clearListeners();

};

{

py::list refPredInts;

py::list sldPredInts;

py::list refXdata;

py::list sldXdata;

py::array_t<real_T> sampleChi;

{

py::list ref;

py::list sld;

real_T chi;

py::list data;

{

py::array_t<real_T> par95;

py::array_t<real_T> par65;

py::array_t<real_T> mean;

{

real_T logZ;

py::array_t<real_T> nestSamples;

py::array_t<real_T> postSamples;

{

real_T d;

real_T N;

real_T T;

boolean_T parallel;

real_T CPU;

real_T lambda;

real_T pUnitGamma;

real_T nCR;

real_T delta;

real_T steps;

real_T zeta;

std::string outlier;

boolean_T adaptPCR;

real_T thinning;

real_T epsilon;

boolean_T ABC;

boolean_T IO;

boolean_T modout;

boolean_T restart;

boolean_T save;

py::array_t<real_T> R;

{

real_T Y;

real_T N;

{

py::array_t<real_T> outlier;

real_T runtime;

DREAMPars DREAMPar;

MeasInfo Meas_info;

real_T iteration;

real_T iloc;

real_T fx;

py::array_t<real_T> AR;

py::array_t<real_T> R_stat;

py::array_t<real_T> CR;

{

py::array_t<real_T> allChains;

DreamOutput dreamOutput;

NestOutput nestOutput;

{

BestFitsMean bestFitsMean;

Predlims predlims;

ParConfInts parConfInts;

py::array_t<real_T> bestPars;

BayesOutput bayesRes;

py::array_t<real_T> chain;

{

py::list param;

py::list backgroundParam;

py::list resolutionParam;

py::list bulkIn;

py::list bulkOut;

py::list qzshift;

py::list scalefactor;

py::list domainRatio;

py::list priorNames;

py::array_t<real_T> priorValues;

py::array_t<real_T> fitParam;

py::array_t<real_T> fitBackgroundParam;

py::array_t<real_T> fitQzshift;

py::array_t<real_T> fitScalefactor;

py::array_t<real_T> fitBulkIn;

py::array_t<real_T> fitBulkOut;

py::array_t<real_T> fitResolutionParam;

py::array_t<real_T> fitDomainRatio;

{

py::array_t<real_T> allChis;

real_T sumChi;

{

py::array_t<real_T> ssubs;

py::array_t<real_T> backgroundParams;

py::array_t<real_T> qzshifts;

py::array_t<real_T> scalefactors;

py::array_t<real_T> bulkIn;

py::array_t<real_T> bulkOut;

py::array_t<real_T> resolutionParams;

Calculation calculations {};

py::array_t<real_T> allSubRough;

py::array_t<real_T> resample;

py::list f1;

py::list f2;

py::list f3;

py::list f4;

py::list f5;

py::list f6;

py::array_t<real_T> param;

py::array_t<real_T> backgroundParam;

py::array_t<real_T> scalefactor;

py::array_t<real_T> qzshift;

py::array_t<real_T> bulkIn;

py::array_t<real_T> bulkOut;

py::array_t<real_T> resolutionParam;

py::array_t<real_T> domainRatio;

py::list f1;

py::list f2;

py::list f3;

py::list f4;

py::list f5;

py::list f6;

py::list f7;

py::list f8;

py::list f9;

py::list f10;

py::list f11;

py::list f12;

py::list f13;

py::list f14;

py::list f15;

py::list f16;

py::list f17;

py::list f18;

py::list f19;

py::list f20;

py::array_t<real_T> contrastBackgrounds;

py::array_t<real_T> contrastBackgroundsType;

std::string TF {};

py::array_t<real_T> resample;

py::array_t<real_T> dataPresent;

py::array_t<real_T> oilChiDataPresent;

real_T numberOfContrasts;

std::string geometry {};

bool useImaginary {};

py::array_t<real_T> contrastQzshifts;

py::array_t<real_T> contrastScalefactors;

py::array_t<real_T> contrastBulkIns;

py::array_t<real_T> contrastBulkOuts;

py::array_t<real_T> contrastResolutions;

py::array_t<real_T> backgroundParams;

py::array_t<real_T> qzshifts;

py::array_t<real_T> scalefactors;

py::array_t<real_T> bulkIn;

py::array_t<real_T> bulkOut;

py::array_t<real_T> resolutionParams;

py::array_t<real_T> params;

real_T numberOfLayers {};

std::string modelType {};

py::array_t<real_T> contrastCustomFiles;

py::array_t<real_T> contrastDomainRatios;

py::array_t<real_T> domainRatio;

real_T numberOfDomainContrasts {};

py::array_t<real_T> fitParams;

py::array_t<real_T> otherParams;

py::array_t<real_T> fitLimits;

py::array_t<real_T> otherLimits;

std::string parallel {};

std::string procedure {};

std::string display {};

real_T tolX {};

real_T tolFun {};

real_T maxFunEvals {};

real_T maxIter {};

real_T populationSize {};

real_T fWeight {};

real_T crossoverProbability {};

real_T targetValue {};

real_T numGenerations {};

real_T strategy {};

real_T Nlive {};

real_T Nmcmc {};

real_T propScale {};

real_T nsTolerance {};

boolean_T calcSldDuringFit {};

py::array_t<real_T> resamPars;

real_T updateFreq {};

real_T updatePlotFreq {};

real_T nSamples {};

real_T nChains {};

real_T jumpProbability {};

real_T pUnitGamma {};

std::string boundHandling {};

boolean_T adaptPCR;

Checks checks {};

{

result_size[0] = 1;

result_size[1] = value.length();

for (int32_T idx1{0}; idx1 < value.length(); idx1++) {

result_data[idx1] = value[idx1];

}

{

result.set_size(1, value.length());

for (int32_T idx{0}; idx < value.length(); idx++) {

result[idx] = value[idx];

}

{

coder::array<real_T, 2U> result;

py::buffer_info buffer_info = value.request();

if (buffer_info.size == 0)

return result;

if (buffer_info.ndim != 1)

throw std::runtime_error("Number of dimensions must be 1");

result.set_size(1, buffer_info.shape[0]);

for (int32_T idx0{0}; idx0 < buffer_info.shape[0]; idx0++) {

result[idx0] = value.at(idx0);

}

return result;

{

coder::bounded_array<real_T, 10U, 2U> result {};

py::buffer_info buffer_info = value.request();

if (buffer_info.size == 0)

return result;

if (buffer_info.ndim != 1)

throw std::runtime_error("Number of dimensions must be 1");

result.size[0] = 1;

result.size[1] = buffer_info.shape[0];

for (int32_T idx0{0}; idx0 < buffer_info.shape[0]; idx0++) {

result.data[idx0] = value.at(idx0);

}

return result;

{

coder::array<real_T, 2U> result;

py::buffer_info buffer_info = value.request();

if (buffer_info.size == 0)

return result;

if (buffer_info.ndim != 2)

throw std::runtime_error("Number of dimensions must be 2");

result.set_size(buffer_info.shape[0], buffer_info.shape[1]);

int32_T idx {0};

for (int32_T idx0{0}; idx0 < buffer_info.shape[0]; idx0++) {

for (int32_T idx1{0}; idx1 < buffer_info.shape[1]; idx1++) {

idx = idx0 + result.size(0) * idx1;

result[idx] = value.at(idx0, idx1);

}

}

return result;

{

coder::array<RAT::cell_0, 1U> result;

result.set_size(values.size());

int32_T idx {0};

for (py::handle list: values)

{

py::list value = py::cast<py::list>(list);

if (py::len(list) != 4)

throw std::runtime_error("Number of dimensions for each row must be 4");

stringToRatCharArray(value[0].cast<std::string>(), result[idx].f1);

stringToRatCharArray(value[1].cast<std::string>(), result[idx].f2);

result[idx].f3 = value[2].cast<real_T>();

result[idx].f4 = value[3].cast<real_T>();

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_1, 1U> result;

result.set_size(values.size());

int32_T idx {0};

for (py::handle list: values)

{

std::string value = py::cast<std::string>(list);

//TODO: validate dimension

stringToRatCharArray(value, result[idx].f1);

idx++;

}

return result;

{

RAT::struct0_T problem_struct;

problem_struct.useImaginary = problem.useImaginary;

problem_struct.numberOfLayers = problem.numberOfLayers;

problem_struct.numberOfDomainContrasts = problem.numberOfDomainContrasts;

problem_struct.numberOfContrasts = problem.numberOfContrasts;

stringToRatArray(problem.modelType, problem_struct.modelType.data, problem_struct.modelType.size);

stringToRatArray(problem.geometry, problem_struct.geometry.data, problem_struct.geometry.size);

stringToRatArray(problem.TF, problem_struct.TF.data, problem_struct.TF.size);

problem_struct.contrastBackgrounds = pyArrayToRatArray1d(problem.contrastBackgrounds);

problem_struct.contrastBackgroundsType = pyArrayToRatArray1d(problem.contrastBackgroundsType);

problem_struct.resample = pyArrayToRatArray1d(problem.resample);

problem_struct.dataPresent = pyArrayToRatArray1d(problem.dataPresent);

problem_struct.oilChiDataPresent = pyArrayToRatArray1d(problem.oilChiDataPresent);

problem_struct.contrastQzshifts = pyArrayToRatArray1d(problem.contrastQzshifts);

problem_struct.contrastScalefactors = pyArrayToRatArray1d(problem.contrastScalefactors);

problem_struct.contrastBulkIns = pyArrayToRatArray1d(problem.contrastBulkIns);

problem_struct.contrastBulkOuts = pyArrayToRatArray1d(problem.contrastBulkOuts);

problem_struct.contrastResolutions = pyArrayToRatArray1d(problem.contrastResolutions);

problem_struct.backgroundParams = pyArrayToRatArray1d(problem.backgroundParams);

problem_struct.qzshifts = pyArrayToRatArray1d(problem.qzshifts);

problem_struct.scalefactors = pyArrayToRatArray1d(problem.scalefactors);

problem_struct.bulkIn = pyArrayToRatArray1d(problem.bulkIn);

problem_struct.bulkOut = pyArrayToRatArray1d(problem.bulkOut);

problem_struct.resolutionParams = pyArrayToRatArray1d(problem.resolutionParams);

problem_struct.params = pyArrayToRatArray1d(problem.params);

problem_struct.contrastCustomFiles = pyArrayToRatArray1d(problem.contrastCustomFiles);

problem_struct.contrastDomainRatios = pyArrayToRatArray1d(problem.contrastDomainRatios);

problem_struct.domainRatio = pyArrayToRatArray1d(problem.domainRatio);

problem_struct.fitParams = pyArrayToRatArray1d(problem.fitParams);

problem_struct.otherParams = pyArrayToRatArray1d(problem.otherParams);

problem_struct.fitLimits = pyArrayToRatArray2d(problem.fitLimits);

problem_struct.otherLimits = pyArrayToRatArray2d(problem.otherLimits);

return problem_struct;

{

RAT::struct1_T limits_struct;

limits_struct.param = pyArrayToRatArray2d(limits.param);

limits_struct.backgroundParam = pyArrayToRatArray2d(limits.backgroundParam);

limits_struct.qzshift = pyArrayToRatArray2d(limits.qzshift);

limits_struct.scalefactor = pyArrayToRatArray2d(limits.scalefactor);

limits_struct.bulkIn = pyArrayToRatArray2d(limits.bulkIn);

limits_struct.bulkOut = pyArrayToRatArray2d(limits.bulkOut);

limits_struct.resolutionParam = pyArrayToRatArray2d(limits.resolutionParam);

limits_struct.domainRatio = pyArrayToRatArray2d(limits.domainRatio);

return limits_struct;

{

RAT::struct3_T checks_struct;

checks_struct.fitParam = pyArrayToRatArray1d(checks.fitParam);

checks_struct.fitBackgroundParam = pyArrayToRatArray1d(checks.fitBackgroundParam);

checks_struct.fitQzshift = pyArrayToRatArray1d(checks.fitQzshift);

checks_struct.fitScalefactor = pyArrayToRatArray1d(checks.fitScalefactor);

checks_struct.fitBulkIn = pyArrayToRatArray1d(checks.fitBulkIn);

checks_struct.fitBulkOut = pyArrayToRatArray1d(checks.fitBulkOut);

checks_struct.fitResolutionParam = pyArrayToRatArray1d(checks.fitResolutionParam);

checks_struct.fitDomainRatio = pyArrayToRatArray1d(checks.fitDomainRatio);

return checks_struct;

{

RAT::struct4_T priors_struct;

priors_struct.param = pyListToUnboundedCell0(priors.param);

priors_struct.backgroundParam = pyListToUnboundedCell0(priors.backgroundParam);

priors_struct.resolutionParam = pyListToUnboundedCell0(priors.resolutionParam);

priors_struct.qzshift = pyListToUnboundedCell0(priors.qzshift);

priors_struct.scalefactor = pyListToUnboundedCell0(priors.scalefactor);

priors_struct.bulkIn = pyListToUnboundedCell0(priors.bulkIn);

priors_struct.bulkOut = pyListToUnboundedCell0(priors.bulkOut);

priors_struct.domainRatio = pyListToUnboundedCell0(priors.domainRatio);

priors_struct.priorNames = pyListToUnboundedCell1(priors.priorNames);

priors_struct.priorValues = pyArrayToRatArray2d(priors.priorValues);

return priors_struct;

{

coder::array<RAT::cell_wrap_2, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

py::array_t<real_T> casted_array = py::cast<py::array>(array);

result[idx].f1[0] = casted_array.at(0);

result[idx].f1[1] = casted_array.at(1);

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_3, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

py::array_t<real_T> casted_array = py::cast<py::array>(array);

result[idx].f1 = pyArrayToRatArray2d(casted_array);

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_4, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

py::array_t<real_T> casted_array = py::cast<py::array>(array);

result[idx].f1 = pyArrayToRatArray1d(casted_array);

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_5, 1U> result;

result.set_size(values.size());

int32_T idx {0};

for (py::handle array: values)

{

py::array_t<real_T> casted_array = py::cast<py::array>(array);

result[idx].f1 = pyArrayToRatBoundedArray(casted_array);

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_6, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

std::string name = py::cast<std::string>(array);

stringToRatArray(name, result[idx].f1.data, result[idx].f1.size);

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_6, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

auto func = py::cast<py::function>(array);

std::string func_ptr = convertPtr2String<CallbackInterface>(new Library(func));

stringToRatArray(func_ptr, result[idx].f1.data, result[idx].f1.size);

idx++;

}

return result;

{

RAT::cell_7 cells_struct;

cells_struct.f1 = pyListToRatCellWrap2(cells.f1);

cells_struct.f2 = pyListToRatCellWrap3(cells.f2);

cells_struct.f3 = pyListToRatCellWrap2(cells.f3);

cells_struct.f4 = pyListToRatCellWrap2(cells.f4);

cells_struct.f5 = pyListToRatCellWrap4(cells.f5);

cells_struct.f6 = pyListToRatCellWrap5(cells.f6);

cells_struct.f7 = pyListToRatCellWrap6(cells.f7);

cells_struct.f8 = pyListToRatCellWrap6(cells.f8);

cells_struct.f9 = pyListToRatCellWrap6(cells.f9);

cells_struct.f10 = pyListToRatCellWrap6(cells.f10);

cells_struct.f11 = pyListToRatCellWrap6(cells.f11);

cells_struct.f12 = pyListToRatCellWrap6(cells.f12);

cells_struct.f13 = pyListToRatCellWrap6(cells.f13);

cells_struct.f14 = py_function_array_to_rat_cell_wrap_6(cells.f14);

cells_struct.f15 = pyListToRatCellWrap6(cells.f15);

cells_struct.f16 = pyListToRatCellWrap6(cells.f16);

cells_struct.f17 = pyListToRatCellWrap3(cells.f17);

cells_struct.f18 = pyListToRatCellWrap2(cells.f18);

cells_struct.f19 = pyListToRatCellWrap4(cells.f19);

cells_struct.f20 = pyListToRatCellWrap6(cells.f20);

return cells_struct;

{

RAT::struct2_T control_struct;

control_struct.tolFun = control.tolFun;

control_struct.maxFunEvals = control.maxFunEvals;

control_struct.maxIter = control.maxIter;

control_struct.populationSize = control.populationSize;

control_struct.fWeight = control.fWeight;

control_struct.crossoverProbability = control.crossoverProbability;

control_struct.targetValue = control.targetValue;

control_struct.numGenerations = control.numGenerations;

control_struct.strategy = control.strategy;

control_struct.Nlive = control.Nlive;

control_struct.Nmcmc = control.Nmcmc;

control_struct.propScale = control.propScale;

control_struct.nsTolerance = control.nsTolerance;

control_struct.calcSldDuringFit = control.calcSldDuringFit;

control_struct.updateFreq = control.updateFreq;

control_struct.updatePlotFreq = control.updatePlotFreq;

control_struct.nSamples = control.nSamples;

control_struct.nChains = control.nChains;

control_struct.jumpProbability = control.jumpProbability;

control_struct.pUnitGamma = control.pUnitGamma;

stringToRatArray(control.parallel, control_struct.parallel.data, control_struct.parallel.size);

stringToRatArray(control.procedure, control_struct.procedure.data, control_struct.procedure.size);

stringToRatArray(control.display, control_struct.display.data, control_struct.display.size);

control_struct.tolX = control.tolX;

control_struct.resamPars[0] = control.resamPars.at(0);

control_struct.resamPars[1] = control.resamPars.at(1);

stringToRatArray(control.boundHandling, control_struct.boundHandling.data, control_struct.boundHandling.size);

control_struct.adaptPCR = control.adaptPCR;

control_struct.checks = createStruct3(control.checks);

return control_struct;

{

auto size = (array.size(0) > 1) ? array.size(0) : array.size(1);

auto result_array = py::array_t<real_T>(size);

std::memcpy(result_array.request().ptr, array.data(), result_array.nbytes());

return result_array;

{

auto result_array = py::array_t<real_T, py::array::f_style>({array.size(0), array.size(1)});

std::memcpy(result_array.request().ptr, array.data(), result_array.nbytes());

return result_array;

{

py::list outer_list_1;

for (int32_T idx0{0}; idx0 < results[0].f1.size(0); idx0++) {

py::list inner_list;

for (int32_T idx1{0}; idx1 < results[0].f1.size(1); idx1++) {

auto tmp = results[0].f1[idx0 + results[0].f1.size(0) * idx1];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

inner_list.append(array);

}

outer_list_1.append(inner_list);

}

py::list outer_list_2;

for (int32_T idx0{0}; idx0 < results[1].f1.size(0); idx0++) {

py::list inner_list;

for (int32_T idx1{0}; idx1 < results[1].f1.size(1); idx1++) {

auto tmp = results[1].f1[idx0 + results[1].f1.size(0) * idx1];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

inner_list.append(array);

}

outer_list_2.append(inner_list);

}

py::list outer_list_3;

for (int32_T idx0{0}; idx0 < results[2].f1.size(0); idx0++) {

py::list inner_list;

for (int32_T idx1{0}; idx1 < results[2].f1.size(1); idx1++) {

auto tmp = results[2].f1[idx0 + results[2].f1.size(0) * idx1];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

inner_list.append(array);

}

outer_list_3.append(inner_list);

}

py::list outer_list_4;

for (int32_T idx0{0}; idx0 < results[3].f1.size(0); idx0++) {

py::list inner_list;

for (int32_T idx1{0}; idx1 < results[3].f1.size(1); idx1++) {

auto tmp = results[3].f1[idx0 + results[3].f1.size(0) * idx1];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

inner_list.append(array);

}

outer_list_4.append(inner_list);

}

py::list outer_list_5;

for (int32_T idx0{0}; idx0 < results[4].f1.size(0); idx0++) {

py::list inner_list;

for (int32_T idx1{0}; idx1 < results[4].f1.size(1); idx1++) {

auto tmp = results[4].f1[idx0 + results[4].f1.size(0) * idx1];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

inner_list.append(array);

}

outer_list_5.append(inner_list);

}

py::list outer_list_6;

for (int32_T idx0{0}; idx0 < results[5].f1.size(0); idx0++) {

py::list inner_list;

for (int32_T idx1{0}; idx1 < results[5].f1.size(1); idx1++) {

auto tmp = results[5].f1[idx0 + results[5].f1.size(0) * idx1];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

inner_list.append(array);

}

outer_list_6.append(inner_list);

}

py::list output_result;

output_result.append(outer_list_1);

output_result.append(outer_list_2);

output_result.append(outer_list_3);

output_result.append(outer_list_4);

output_result.append(outer_list_5);

output_result.append(outer_list_6);

return output_result;

{

// Copy problem to output

ContrastParams output_problem;

output_problem.ssubs = py::array_t<real_T>(problem.ssubs.size(0));

auto buffer = output_problem.ssubs.request();

std::memcpy(buffer.ptr, problem.ssubs.data(), output_problem.ssubs.size()*sizeof(real_T));

output_problem.backgroundParams = py::array_t<real_T>(problem.backgroundParams.size(0));

buffer = output_problem.backgroundParams.request();

std::memcpy(buffer.ptr, problem.backgroundParams.data(), output_problem.backgroundParams.size()*sizeof(real_T));

output_problem.qzshifts = py::array_t<real_T>(problem.qzshifts.size(0));

buffer = output_problem.qzshifts.request();

std::memcpy(buffer.ptr, problem.qzshifts.data(), output_problem.qzshifts.size()*sizeof(real_T));

output_problem.scalefactors = py::array_t<real_T>(problem.scalefactors.size(0));

buffer = output_problem.scalefactors.request();

std::memcpy(buffer.ptr, problem.scalefactors.data(), output_problem.scalefactors.size()*sizeof(real_T));

output_problem.bulkIn = py::array_t<real_T>(problem.bulkIn.size(0));

buffer = output_problem.bulkIn.request();

std::memcpy(buffer.ptr, problem.bulkIn.data(), output_problem.bulkIn.size()*sizeof(real_T));

output_problem.bulkOut = py::array_t<real_T>(problem.bulkOut.size(0));

buffer = output_problem.bulkOut.request();

std::memcpy(buffer.ptr, problem.bulkOut.data(), output_problem.bulkOut.size()*sizeof(real_T));

output_problem.resolutionParams = py::array_t<real_T>(problem.resolutionParams.size(0));

buffer = output_problem.resolutionParams.request();

std::memcpy(buffer.ptr, problem.resolutionParams.data(), output_problem.resolutionParams.size()*sizeof(real_T));

output_problem.calculations.sumChi = problem.calculations.sumChi;

output_problem.calculations.allChis = py::array_t<real_T>(problem.calculations.allChis.size(0));

buffer = output_problem.calculations.allChis.request();

std::memcpy(buffer.ptr, problem.calculations.allChis.data(), output_problem.calculations.allChis.size()*sizeof(real_T));

output_problem.allSubRough = py::array_t<real_T>(problem.allSubRough.size(0));