public double[] Precs(double μ0_final, double σ0_final)
{
double[] precs = new double[2];
double[] precValues = DistributionSelection.PrecValues(StandardSelection.InverseProcessValue(μ0_final), σ0_final);
precs[0] = pub_function.resolution_getReso(StandardSelection.ProcessValue(precValues[0]), 0.000001);
precs[1] = pub_function.resolution_getReso(StandardSelection.ProcessValue(precValues[1]), 0.000001);
return(precs);
}
public OutputParameters GetResult(double[] xArray, int[] vArray)
{
for (int i = 0; i < xArray.Length; i++)
{
xArray[i] = StandardSelection.InverseProcessValue(xArray[i]);
}
OutputParameters outputParameters = DistributionSelection.DotDistribution(xArray, vArray);
outputParameters.μ0_final = StandardSelection.GetAvgValue(outputParameters.μ0_final);
return(outputParameters);
}
public OutputParameters GetResult(double[] xArray, int[] vArray)
{
for (int i = 0; i < xArray.Length; i++)
{
xArray[i] = StandardSelection.InverseProcessValue(xArray[i]);
}
var outputParameters = DistributionSelection.MLS_getMLS(xArray, vArray);
DistributionSelection.Interval_estimation(xArray, vArray, ref outputParameters);
outputParameters.μ0_final = StandardSelection.GetAvgValue(outputParameters.μ0_final);
return(outputParameters);
}
public List <IntervalEstimation> ResponsePointIntervalEstimate(double[] x, int[] v, double reponseProbability, double confidenceLevel, double fq, double favg, double fsigma)
{
List <IntervalEstimation> intervalEstimations = new List <IntervalEstimation>();
if (fq != 0)
{
reponseProbability = DistributionSelection.PointIntervalDistribution(StandardSelection.InverseProcessValue(fq), StandardSelection.InverseProcessValue(favg), fsigma);
}
var Single = SingleSideEstimation(x, v, reponseProbability, confidenceLevel);
intervalEstimations.Add(GetIntervalEstimationValue(Single));
var Double = DoubleSideEstimation(x, v, reponseProbability, confidenceLevel);
intervalEstimations.Add(GetIntervalEstimationValue(Double));
return(intervalEstimations);
}
public SideReturnData BatchIntervalCalculate(double Y_Ceiling, double Y_LowerLimit, int Y_PartitionNumber, double ConfidenceLevel, double favg, double fsigma, double[] xArray, int[] vArray, int intervalChoose)
{
SideReturnData sideReturnData = new SideReturnData();
double Y_ScaleLength = (DistributionSelection.QnormAndQlogisDistribution(Y_Ceiling) - DistributionSelection.QnormAndQlogisDistribution(Y_LowerLimit)) / Y_PartitionNumber;
sideReturnData.responseProbability = new double[Y_PartitionNumber + 1];
for (int i = 0; i <= Y_PartitionNumber; i++)
{
if (i == 0)
{
sideReturnData.responseProbability[i] = Y_LowerLimit;
}
else
{
sideReturnData.responseProbability[i] = DistributionSelection.PointIntervalDistribution(DistributionSelection.QnormAndQlogisDistribution(Y_LowerLimit) + i * Y_ScaleLength, 0, 1);
}
}
sideReturnData.Y_Ceilings = new double[sideReturnData.responseProbability.Length];
sideReturnData.Y_LowerLimits = new double[sideReturnData.responseProbability.Length];
sideReturnData.responsePoints = new double[sideReturnData.responseProbability.Length];
for (int i = 0; i < sideReturnData.responseProbability.Length; i++)
{
IntervalEstimation ie = new IntervalEstimation();
if (intervalChoose == 0)
{
ie = SingleSideEstimation(xArray, vArray, sideReturnData.responseProbability[i], ConfidenceLevel);
}
else
{
ie = DoubleSideEstimation(xArray, vArray, sideReturnData.responseProbability[i], ConfidenceLevel);
}
sideReturnData.Y_LowerLimits[i] = ie.Confidence.Down;
sideReturnData.Y_Ceilings[i] = ie.Confidence.Up;
double fq = sideReturnData.responseProbability[i];
sideReturnData.responsePoints[i] = StandardSelection.ProcessValue(StandardSelection.InverseProcessValue(favg) + (DistributionSelection.QnormAndQlogisDistribution(fq) * fsigma));
}
return(sideReturnData);
}
public string Discription()
{
return(DistributionSelection.DistributionSelection() + StandardSelection.StandardSelection());
}
public double CorrectionAlgorithm(double fsigma, int count) => DistributionSelection.CorrectionDistribution(count) * fsigma;
public IntervalEstimation DoubleSideEstimation(double[] xArray, int[] vArray, double reponseProbability, double confidenceLevel) => DistributionSelection.IntervalDistribution(StandardSelection.InverseProcessArray(xArray), vArray, reponseProbability, confidenceLevel);
public double ResponseProbabilityCalculate(double fq, double favg, double fsigma) => DistributionSelection.PointIntervalDistribution(StandardSelection.InverseProcessValue(fq), StandardSelection.InverseProcessValue(favg), fsigma);
public double ResponsePointCalculate(double fq, double favg, double fsigma) => StandardSelection.ProcessValue(StandardSelection.InverseProcessValue(favg) + (DistributionSelection.QnormAndQlogisDistribution(fq) * fsigma));
private void GetDistribution(double[] xArray, int[] vArray, double mumin, double mumax, double reso, ref OutputParameters outputParameters, out double z, double sigmaguess)
{
mumin = StandardSelection.InverseProcessValue(mumin);
mumax = StandardSelection.InverseProcessValue(mumax);
xArray = StandardSelection.InverseProcessArray(xArray);
if (xArray.Length == 0)
{
pub_function.resolution_getReso((mumin + mumax) / 2, reso, out z);
outputParameters.μ0_final = 0;
outputParameters.σ0_final = 0;
}
else
{
int sum = 0;
for (int j = 0; j < xArray.Length; j++)
{
sum += vArray[j];
}
if (sum == 0 || sum == xArray.Length)
{
z = xArray[xArray.Length - 1];
double[] sumi = { (mumin + z) / 2, z - 2 * sigmaguess, 2 * z - xArray[0] };
double[] sum0 = { (mumax + z) / 2, z + 2 * sigmaguess, 2 * z - xArray[0] };
if (sum == xArray.Length)
{
pub_function.resolution_getReso(pub_function.MIN_getMin(sumi), reso, out z);
}
else
{
pub_function.resolution_getReso(pub_function.MAX_getMax(sum0), reso, out z);
}
outputParameters.μ0_final = 0;
outputParameters.σ0_final = 0;
}
else
{
double[] xArray_change = new double[xArray.Length];
int[] vArray_change = new int[xArray.Length];
int ij;
for (ij = 0; ij < xArray.Length; ij++)
{
xArray_change[ij] = xArray[ij];
vArray_change[ij] = vArray[ij];
}
outputParameters.Maxf = pub_function.MAX_getMax(pub_function.getF(xArray_change, vArray_change));
outputParameters.Mins = pub_function.MIN_getMin(pub_function.S_getS(xArray_change, vArray_change));
double[] FZ = pub_function.getF(xArray_change, vArray_change); //失败的刺激量
double[] SZ = pub_function.S_getS(xArray_change, vArray_change); //成功的刺激量
double Diff = outputParameters.Mins - outputParameters.Maxf;
if (DopDistributionSelection.IsValueSize(Diff, sigmaguess))
{
pub_function.resolution_getReso((outputParameters.Mins + outputParameters.Maxf) / 2, reso, out z);
outputParameters.μ0_final = z;
outputParameters.σ0_final = 0;
}
else
{
if (outputParameters.Mins > outputParameters.Maxf)
{
outputParameters.μ0_final = (outputParameters.Mins + outputParameters.Maxf) / 2;
outputParameters.σ0_final = 0;
pub_function.resolution_getReso(DopDistributionSelection.Fisher_getZ_new(xArray_change, vArray_change, outputParameters.μ0_final, sigmaguess), reso, out z);
outputParameters.sigmaguess = 0.8 * sigmaguess;
}
else
{
outputParameters = DistributionSelection.MLS_getMLS(xArray_change, vArray_change);
outputParameters.sigmaguess = sigmaguess;
pub_function.resolution_getReso(DopDistributionSelection.Fisher_getZ_new(xArray_change, vArray_change, outputParameters.μ0_final, outputParameters.σ0_final), reso, out z);
}
}
}
}
DistributionSelection.Interval_estimation(xArray, vArray, ref outputParameters);
}
public string Discription() => DistributionSelection.DistributionSelection() + StandardSelection.StandardSelection();