int maxArray(vector<int>& nums, int left, int right, int& maxV){
if (left > right){
return INT_MIN;
}
int mid = left + (right - left) / 2;
int lmax = maxArray(nums, left, mid-1, maxV);
int rmax = maxArray(nums, mid+1, right, maxV);
maxV = max(lmax, maxV);
maxV = max(rmax, maxV);
int lsum = 0;
int mlmax = 0;
for (int i = mid-1; i >= left; i--){
lsum += nums[i];
if (lsum > mlmax){
mlmax = lsum;
}
}
int rsum = 0;
int mrmax = 0;
for (int i = mid+1; i <= right; i++){
rsum += nums[i];
if (rsum > mrmax){
mrmax = rsum;
}
}
maxV = max(maxV, mlmax + mrmax + nums[mid]);
return maxV;
}
int maxArray(int *a, int size)
{
if (size < 0)
{
return MIN_INT;
}
return a[size-1] > maxArray(a, size-1)
? a[size-1] : maxArray(a, size-1);
}
shared_ptr <JSONExport::JSONObject> serializeAccessor(JSONAccessor* accessor, void *context)
{
shared_ptr <JSONObject> accessorObject = shared_ptr<JSONObject>(new JSONObject());
accessorObject->setUnsignedInt32("byteStride", (unsigned int)accessor->getByteStride());
accessorObject->setUnsignedInt32("byteOffset", (unsigned int)accessor->getByteOffset());
accessorObject->setUnsignedInt32("elementsPerValue", (unsigned int)accessor->getElementsPerVertexAttribute());
accessorObject->setUnsignedInt32("count", (unsigned int)accessor->getCount());
accessorObject->setString("elementType", JSONUtils::getStringForType(accessor->getElementType()));
JSONBuffer* buffer = context ? (JSONBuffer*)context : accessor->getBuffer().get();
accessorObject->setString("buffer", buffer->getID());
const double* min = accessor->getMin();
if (min) {
shared_ptr <JSONExport::JSONArray> minArray(new JSONExport::JSONArray());
accessorObject->setValue("min", minArray);
for (size_t i = 0 ; i < accessor->getElementsPerVertexAttribute() ; i++) {
minArray->appendValue(shared_ptr <JSONExport::JSONNumber> (new JSONExport::JSONNumber(min[i])));
}
}
const double* max = accessor->getMax();
if (max) {
shared_ptr <JSONExport::JSONArray> maxArray(new JSONExport::JSONArray());
accessorObject->setValue("max", maxArray);
for (size_t i = 0 ; i < accessor->getElementsPerVertexAttribute() ; i++) {
maxArray->appendValue(shared_ptr <JSONExport::JSONNumber> (new JSONExport::JSONNumber(max[i])));
}
}
return accessorObject;
}
shared_ptr <GLTF::JSONObject> serializeMeshAttribute(GLTFMeshAttribute* meshAttribute, void *context)
{
shared_ptr <JSONObject> meshAttributeObject = shared_ptr<JSONObject>(new JSONObject());
meshAttributeObject->setUnsignedInt32("byteStride", (unsigned int)meshAttribute->getByteStride());
meshAttributeObject->setUnsignedInt32("byteOffset", (unsigned int)meshAttribute->getByteOffset());
meshAttributeObject->setUnsignedInt32("componentsPerAttribute", (unsigned int)meshAttribute->getElementsPerVertexAttribute());
meshAttributeObject->setUnsignedInt32("count", (unsigned int)meshAttribute->getCount());
meshAttributeObject->setString("componentType", GLTFUtils::getStringForGLType(meshAttribute->getComponentType()));
void** buffers = (void**)context;
GLTFBufferView *bufferView = context ? (GLTFBufferView*)buffers[0] : meshAttribute->getBufferView().get();
meshAttributeObject->setString("bufferView", bufferView->getID());
const double* min = meshAttribute->getMin();
if (min) {
shared_ptr <GLTF::JSONArray> minArray(new GLTF::JSONArray());
meshAttributeObject->setValue("min", minArray);
for (size_t i = 0 ; i < meshAttribute->getElementsPerVertexAttribute() ; i++) {
minArray->appendValue(shared_ptr <GLTF::JSONNumber> (new GLTF::JSONNumber(min[i])));
}
}
const double* max = meshAttribute->getMax();
if (max) {
shared_ptr <GLTF::JSONArray> maxArray(new GLTF::JSONArray());
meshAttributeObject->setValue("max", maxArray);
for (size_t i = 0 ; i < meshAttribute->getElementsPerVertexAttribute() ; i++) {
maxArray->appendValue(shared_ptr <GLTF::JSONNumber> (new GLTF::JSONNumber(max[i])));
}
}
return meshAttributeObject;
}
int main(void)
{
int a[8]={4,7,3,6,8,1,9,2};
int result=maxArray(a, 8);
printf("biggest int: %d\n", result);
printf("18th number in Fibonacci sequence: %d", Fibonacci(18));
return 0;
}
void Analysis::collect(const Mat& feature)
{
int nl = feature.rows;
int nc = feature.cols;
float max, min;
pair<int, int> s;
maxArray(feature, max, s);
minArray(feature, min, s);
printf("max: %f, min: %f\n", max, min, sum(feature)[0]);
}
int maxArray(int A[], int left, int right, int& maxV)
{
//如果超过了，就返回INT_MIN，这样和别人比较的时候就没意义了
if(left>right)
return INT_MIN;
//左右中
int mid = (left+right)/2;
int lmax = maxArray(A, left, mid -1, maxV);
int rmax = maxArray(A, mid + 1, right, maxV);
//maxV是左右最大的
maxV = max(maxV, lmax);
maxV = max(maxV, rmax);
//中间的左半部分，求最大
int sum = 0, mlmax = 0;
for(int i= mid -1; i>=left; i--)
{
sum += A[i];
if(sum > mlmax)
mlmax = sum;
}
//中间的右半部分，求最大
sum = 0; int mrmax = 0;
for(int i = mid +1; i<=right; i++)
{
sum += A[i];
if(sum > mrmax)
mrmax = sum;
}
//求左中右最大
maxV = max(maxV, mlmax + mrmax + A[mid]);
return maxV;
}
double* Color::getHSL() const {
double max, min, c;
double rgb[3], * hsl = new double[3];
for (int i = 0; i < 3; i++)
rgb[i] = (double)color[i] / 255;
max = maxArray(rgb, 3);
min = minArray(rgb, 3);
c = max - min;
if (c == 0)
hsl[0] = 0;
else if (max == rgb[RGB_RED]) {
hsl[0] = (rgb[RGB_GREEN] - rgb[RGB_BLUE]) / c;
while (hsl[0] > 6)
hsl[0] = hsl[0] - 6;
} else if (max == rgb[RGB_GREEN])
hsl[0] = (rgb[RGB_BLUE] - rgb[RGB_RED]) / c + 2.0;
else if (max == rgb[RGB_BLUE])
hsl[0] = (rgb[RGB_RED] - rgb[RGB_GREEN]) / c + 4.0;
hsl[0] = 60 * hsl[0];
hsl[2] = (max + min) / 2;
if (c == 0)
hsl[1] = 0;
/* this part does not work */
//else
// hsl[1] = c / (1.0 - abs(2.0 * hsl[2] - 1.0));
else if (hsl[2] < .5)
hsl[1] = c / (max + min);
else
hsl[1] = c / (2.0 - max - min);
return hsl;
}
void test2() {
double s = maxArray(n, a);
printf("maxArray=%lf\n", s);
}
TTree* execute()
{
// q is simply a prefix for values which are a branch on the TTree
TTree * dataTree = new TTree("treeData", "treeData");
float qChargeValues[7];
float qTotalCharge;
float qMeasurementTimes[7];
float qCurrentValues[7];
float qVoltageValuesPreNoise[7];
float qVoltageValuesPostNoise[7];
int qDigitalReadoutValues[7];
float qFitShiftingTime;
float qFitScalingFactor;
int qTotalDigitalReadoutValue;
int qDifferenceDigitalReadoutValue;
float qIntegralReadoutValue;
dataTree->Branch("qChargeValues", qChargeValues, "qChargeValues[7]/F");
dataTree->Branch("qTotalCharge", &qTotalCharge, "qTotalCharge/F");
dataTree->Branch("qMeasurementTimes", qMeasurementTimes, "qMeasurementTimes[7]/F");
dataTree->Branch("qCurrentValues", qCurrentValues, "qCurrentValues[7]/F");
dataTree->Branch("qVoltageValuesPreNoise", qVoltageValuesPreNoise, "qVoltageValuesPreNoise[7]/F");
dataTree->Branch("qVoltageValuesPostNoise", qVoltageValuesPostNoise, "qVoltageValuesPostNoise[7]/F");
dataTree->Branch("qDigitalReadoutValues", qDigitalReadoutValues, "qDigitalReadoutValues[7]/I");
dataTree->Branch("qFitShiftingTime", &qFitShiftingTime, "qFitShiftingTime/F");
dataTree->Branch("qFitScalingFactor", &qFitScalingFactor, "qFitScalingFactor/F");
dataTree->Branch("qTotalDigitalReadoutValue", &qTotalDigitalReadoutValue, "qTotalDigitalReadoutValue/I");
dataTree->Branch("qDifferenceDigitalReadoutValue", &qDifferenceDigitalReadoutValue, "qDifferenceDigitalReadoutValue/I");
dataTree->Branch("qIntegralReadoutValue", &qIntegralReadoutValue, "qIntegralReadoutValue/F");
const int numTrials = 10000; // Set number of trials
const float shapingTime = 40.0;
const float shapingPower = 1.0;
ElectronSimulation * eSim = new ElectronSimulation();
for (int i = 0; i < numTrials; ++i)
{
TrialDataSet eSimData;
eSim->simulate(eSimData, shapingTime, shapingPower);
qTotalCharge = sumArray(eSimData.chargeValues, 7);
qTotalDigitalReadoutValue = sumArray(eSimData.digitalReadoutValues, 7);
qDifferenceDigitalReadoutValue = maxArray(eSimData.digitalReadoutValues, 7) - eSimData.digitalReadoutValues[0];
TF1 * fittedFunction = eSim->computeFunctionFit(eSimData);
qFitShiftingTime = fittedFunction->GetParameter(0);
qFitScalingFactor = fittedFunction->GetParameter(1);
qIntegralReadoutValue = eSim->integrateFunc(qFitScalingFactor);
fittedFunction->Draw();
for (int j = 0; j<7; ++j)
{
qChargeValues[j] = eSimData.chargeValues[j];
qMeasurementTimes[j] = eSimData.measurementTimes[j];
qCurrentValues[j] = eSimData.currentValues[j];
qVoltageValuesPreNoise[j] = eSimData.voltageValuesPreNoise[j];
qVoltageValuesPostNoise[j] = eSimData.voltageValuesPostNoise[j];
qDigitalReadoutValues[j] = eSimData.digitalReadoutValues[j];
}
dataTree->Fill();
}
return dataTree;
}
int maxSubArray(int A[], int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
int maxV = INT_MIN;
return maxArray(A, 0, n-1, maxV);
}
int maxSubArray(vector<int>& nums) {
int n = nums.size();
int maxV = INT_MIN;
return maxArray(nums, 0, n-1, maxV);
}
