void PreCharge(u8 batNum)
{
if(getDiffTickFromNow(gChargingTimeTick[batNum-1]) > BAT_CHARGING_PRE_MAX_TIME)
{
gBatStateBuf[batNum] &= ~CHARGE_STATE_PRE;
gBatStateBuf[batNum] |= CHARGE_STATE_ERROR;
gChargingTimeTick[batNum-1] = 0;
}
else
{
gBatVoltArray[batNum-1][0] = getVbatAdc(batNum);
if(gBatVoltArray[batNum-1][0] >= CHARGING_PRE_END_VOLT )
{
if(batNum<3)
gBatVoltArray[batNum-1][0] = getAverage(CHANNEL_TEMP_1);
else
gBatVoltArray[batNum-1][0] = getAverage(CHANNEL_TEMP_2);
if(gBatVoltArray[batNum-1][0]>ADC_TEMP_MAX && gBatVoltArray[batNum-1][0] <ADC_TEMP_MIN)
{
gChargingTimeTick[batNum-1] = 0;
gBatStateBuf[batNum] &= ~CHARGE_STATE_PRE;
gBatStateBuf[batNum] |= CHARGE_STATE_FAST;
}
else
{
gChargingTimeTick[batNum-1] = 0;
gBatStateBuf[batNum] &= ~CHARGE_STATE_PRE;
gBatStateBuf[batNum] |= CHARGE_STATE_TRICK;
}
}
}
}
u16 getVbatAdc(u8 channel)
{
u16 tempV;
switch(channel)
{
case 1:
channel = CHANNEL_VBAT_1;break;
case 2:
channel = CHANNEL_VBAT_2;break;
case 3:
channel = CHANNEL_VBAT_3;break;
case 4:
channel = CHANNEL_VBAT_4;break;
default:
break;
}
gChargeCurrent= getAverage(CHANNEL_20_RES);
tempV = getAverage(channel);
// sendStr(tempStr1);
// send(gChargeCurrent);
// sendStr(tempStr2);
// send(temp2);
if(tempV < gChargeCurrent)
{
gChargeCurrent = 0;
return 0;
}
return (tempV-gChargeCurrent);
unsigned int RigidPointICP::calcNextStep(AbstractMesh& source, AbstractMesh const& dest)
{
// Select points
auto sourcePoints = selectPoints(source);
auto nearestPoints = m_nearestNeighbor.getAllNearest(sourcePoints, source, dest);
// Sort out edge points on dest
if((m_selectionMethod & NO_EDGES))
{
for (unsigned int i = 0; i < nearestPoints.size(); i++)
{
if (nearestPoints[i].isEdge)
{
nearestPoints.erase(nearestPoints.begin() + i);
sourcePoints.erase(sourcePoints.begin() + i);
}
}
}
// Calc averages
auto srcAvg = getAverage(sourcePoints);
auto destAvg = getAverage(nearestPoints);
auto amountOfPoints = sourcePoints.size();
Eigen::MatrixXd X(3, amountOfPoints);
Eigen::MatrixXd Y(3, amountOfPoints);
// Fill X and Y
for(unsigned int i = 0; i < amountOfPoints; i++)
{
auto srcVertex = sourcePoints[i].coords;
auto corSrcVertex = srcVertex - srcAvg;
X(0,i) = corSrcVertex.x();
X(1,i) = corSrcVertex.y();
X(2,i) = corSrcVertex.z();
auto destVertex = nearestPoints[i].coords;
auto corDestVertex = destVertex - destAvg;
Y(0, i) = corDestVertex.x();
Y(1, i) = corDestVertex.y();
Y(2, i) = corDestVertex.z();
}
// Calculate optimal rotation
auto XYT = X * Y.transpose();
Eigen::JacobiSVD<Eigen::MatrixXd> svd(XYT, Eigen::ComputeThinU | Eigen::ComputeThinV);
auto R = svd.matrixV() * svd.matrixU().transpose();
// Translation
auto t = destAvg - R * srcAvg;
// Apply values to all vertices of source
for (unsigned int i = 0; i < source.getAmountOfVertices(); i++)
{
auto vertex = source.getVertex(i);
auto coords = R * vertex.coords + t;
// Should be okay to use the same R for normal since the inverse of a rotation matrix
// is its transpose. Thus the correct matrix is transpose(transpose(R)) = R.
auto normal = R * vertex.normal;
source.setVertex(i, coords, normal);
}
// Clear nearest neighbor cache
m_nearestNeighbor.clearCache();
return sourcePoints.size();
}
float VelocityTracker::getVelocityX() {
float meanX = getAverage(this->meanX, numSamples);
float meanTime = (float) (getAverage(this->meanTime, numSamples) / 1000);
if (meanTime == 0) {
return 0;
}
else {
return meanX / meanTime;
}
}
float VelocityTracker::getVelocityY() {
float meanY = getAverage(this->meanY, numSamples);
float meanTime = (float) (getAverage(this->meanTime, numSamples) / 1000);
// CCLog("meanY: %f, meanTime")
if (meanTime == 0) {
return 0;
}
else {
return meanY / meanTime;
}
}
int main()
{
float avg1, avg3;
person A[100];
generateList(A);
oneQueue(A);
threeQueue(A);
avg3=getAverage(A, 3);
avg1=getAverage(A, 1);
std::cout<<"one queue average "<<avg1<<" three queue average "<<avg3<<std::endl;
}
/* main */
int main() {
char file_name[20]; // file name
int row; // counts the number of rows
double avgA, avgB; // average values
char choce[1]; //
while (1) {
/* clear old data */
memset(file_name, 0, sizeof file_name);
memset(subA, 0, sizeof subA);
memset(subB, 0, sizeof subB);
passCounter = 1;
row = 0, avgA = 0, avgB = 0;
for (int i = 0; i < limit; i++) { // clears all old cash
memset(passed[i], 0, sizeof passed[i]);
memset(data[i], 0, sizeof data[i]);
}
printf("\nPlease enter the student info file you wish to evaluate?\n");
scanf("%s", file_name); // takes file name
extract_once(file_name); // will extract file validity
row = process_once(); // split people who passed and sub A and B into separate double array
sort(row); // will sort the data sheet
avgA = getAverage(subA, row); // finds average
avgB = getAverage(subB, row);
print_once(row, passCounter, avgA, avgB, passed);
/* options */
printf("do you want to run another file type 'y' else 'n' to exit\n");
scanf("%s", choce);
if (choce[0] == 'n') {
break;
}
}
return 0;
} // end main
void SolverPCA::getAnaliticAverage()
{
double *mass; // массив значений концентраций для компонента
QHash<QString,unsigned int>::iterator iterator;
// ItemInSample item_1;
double average = 0; // средняя концентрация для компонента по анализируемым пробам
QVector<double> vec_values;
int length = 0; // длина массива для нахождения среднего и диспесрисии
// QHash<unsigned int, ItemInSample> *items_in_sample = new QHash<unsigned int, ItemInSample>();
// для всех компонентов находится среднее по анализируемомму типу вод
for (iterator = Names::params->begin(); iterator != Names::params->end(); iterator ++)
{
length = 0;
average = 0;
// получить все значения концентраций компонента для анализируемого типа вод
vec_values = pickValues(iterator.value(),Names::analitic_id);
length = vec_values.size();
mass = new double [length];
// преобразование вектора значений в массив
for (int i = 0; i < length; i ++)
{
mass[i] = vec_values[i];
}
// определение среднего для компонента в пробах анализируемого типа
average = getAverage(mass, length);
qDebug()<<"item name: "<<iterator.key()<<" | item average: "<< average;
analitic_average->insert(iterator.value(),average);
}
}
/*
* Created on: Oct 17, 2013
* Author: C15Brandon.Belcher
* Description: Main.c to test out my movingAverages calculator.
* Documentation: C2C Bentley explained how to use the functions in main so
* that they can be tested. I then coded everything on my own.
*/
int main(void) {
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
int i;
int j;
volatile int maxNumberInArray;
volatile int minNumberInArray;
volatile unsigned int rangeOfNumbersInArray;
int output[10];
int input[10] = {174, 162, 149, 85, 130, 149, 153, 164, 169, 173};
int samples[SAMPLE_SIZE];
for (i = 0; i < SAMPLE_SIZE; i++) {
samples[i] = 0;
}
for (j = 0; j < 10; j++) {
addSample(input[j], samples, SAMPLE_SIZE);
output[j] = getAverage(samples, SAMPLE_SIZE);
}
maxNumberInArray = max(input, 10);
minNumberInArray = min(input, 10);
rangeOfNumbersInArray = range(input, 10);
while(1){
}
}
PRFloat64 getVariance(VarianceState* inVariance)
/*
** Determine the variance based on the given state.
*/
{
PRFloat64 retval = 0.0;
if(NULL != inVariance && 1 < inVariance->mCount)
{
PRFloat64 count;
PRFloat64 squaredSum;
PRFloat64 avg;
PRFloat64 squaredAvg;
PRInt64 isquaredSum;
/*
** Avoids a compiler error (not impl) under MSVC.
*/
isquaredSum = inVariance->mSquaredSum;
count = (PRFloat64)inVariance->mCount;
LL_L2F(squaredSum, isquaredSum);
avg = getAverage(inVariance);
squaredAvg = avg * avg;
retval = (squaredSum - (count * squaredAvg)) / (count - 1.0);
}
return retval;
}
void Plot::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
// std::cout << "painting" << painter << std::endl;
painter->setPen(averagePen);
qreal av = boundingRect().height()-((plotter!=NULL)?getAverage()*plotter->getScale():getAverage());
QString avg = "Avg: ";
avg += QString::number(getAverage());
painter->drawText(QPointF(5,av-5),avg);
painter->drawLine(0,av,boundingRect().width(),av);
painter->setPen(plotPen);
QPolygonF poly(QVector<QPointF>::fromList(getPoints()));
painter->drawPolyline(poly);
}
int main(){
int array[] = {100,200,300,400,500,600,700};
float floatArray[] = { 1.55f,5.44f,12.36f};
//Used for pointer based calls
std::cout << getAveragePtr(&array[0],7) << '\n';
std::cout << getAveragePtr(&floatArray[0],4) << '\n';
//Used for array based calls
std::cout << getAverage(array,7) << '\n';
std::cout << getAverage(floatArray,4) << '\n';
//Templates that return value
std::cout << printTwice(2) << '\n';
std::cout << printTwice(2.44) << '\n';
std::cout << printTwice(printTwice(2.44)) << '\n';
//Templates with void return type
printThrice(2);
printThrice(2.44);
//Template that alter the reference value
int a = 4;
float b = 2.5f;
std::cout <<"a :" << a << '\n';
std::cout <<"b :" << b << '\n';
TwiceRef(a);
TwiceRef(b);
std::cout <<"a :" << a << '\n';
std::cout <<"b :" << b << '\n';
//Setting the max value to zero
int x = 50;
int y = 64;
std::cout <<"x : "<<x<<"y : "<<y<<'\n';
GetMax(x,y) = 0;
std::cout <<"x : "<<x<<"y : "<<y<<'\n';
return 0;
}
float RunningAverage::getVariance()
{
if (_cnt == 0) return 0;
float var = 0;
float avg = getAverage();
for (int i=0; i<_size; i++) {
var += ( _ar[i] - avg ) * ( _ar[i] - avg );
}
return var/_size;
}
int main (void)
{
int i;
int highs[TEMPS] = { 80, 72, 60, 72, 74, 76, 78 }, lows[TEMPS] = { 53, 63, 39, 43, 50, 53, 55 };
printf( "The high and low temperatures are: \n\n" );
for (i = 0; i < TEMPS; i++)
printf( "Day %2i: %3i and %3i.\n", i+1, highs[i], lows[i] );
printf( "\nThe average high is %.2lf, and the average low is %.2lf.\n\n", getAverage (highs), getAverage (lows) );
return 0;
}
float StDev::getStDev() const {
float average = getAverage();
float stdev = 0;
for (int i = 0; i < _sampleCount; i++) {
stdev += powf(_data[i] - average, 2);
}
if (_sampleCount > 1)
return sqrt(stdev / (float)(_sampleCount - 1.0f));
else
return 0;
}
void statsRecorder::drawAverage( int x_, int y_, int lastNVals, float scaleH, float scaleW )
{
float average = getAverage(lastNVals);
float x1 = x_;
float y1 = y_-average*scaleH;
float x2 = x_+maxValues*scaleW+10;
float y2 = y_-average*scaleH;
ofLine(x1,y1,x2,y2);
}
long read(long value)
{
total -= readings[index]; // subtract the last reading:
readings[index] = value;
total += readings[index];
index++;
if (index >= NUM_READINGS)
index = 0;
return getAverage();
}
/*
void SupCharge(u8 batLabel)
{
}
*/
void TrickCharge(u8 batNum)
{
if(gBatStateBuf[batNum] & CHARGE_STATE_FULL)
{
}
else
{
if(batNum < 3)
gBatVoltArray[batNum-1][0] = getAverage(CHANNEL_TEMP_1);
else
gBatVoltArray[batNum-1][0] = getAverage(CHANNEL_TEMP_2);
if(gBatVoltArray[batNum-1][0]>ADC_TEMP_MAX && gBatVoltArray[batNum-1][0] <ADC_TEMP_MIN)
{
gBatStateBuf[batNum] &= ~CHARGE_STATE_TRICK;
gBatStateBuf[batNum] |= CHARGE_STATE_FAST;
gBatStateBuf[batNum] &= ~CHARGE_STATE_FULL;
gChargingTimeTick[batNum-1] = 0;
gChargingIntervalTick[batNum-1] = 0;
}
}
}
void AVERAGER_GetAverage(AVERAGER * pAverager, void * pResult)
{
if (pAverager && pResult)
{
switch(pAverager->type)
{
case S8:
*(int8_t*)pResult = (int8_t)getAverage(pAverager);
break;
case U8:
*(uint8_t*)pResult = (uint8_t)getAverage(pAverager);
break;
case S16:
*(int16_t*)pResult = (int16_t)getAverage(pAverager);
break;
case U16:
*(uint16_t*)pResult = (uint16_t)getAverage(pAverager);
break;
#ifdef INCLUDE_32BIT_AVERAGER
case S32:
*(int32_t*)pResult = (int32_t)getAverage(pAverager);
break;
case U32:
*(uint32_t*)pResult = (uint32_t)getAverage(pAverager);
break;
#endif
}
}
}
void inline unitTestKMeansRandomly(Group &test, std::ofstream &output) {
// 数据归一化
// normaliztion(test);
// 输出读入的数据
// puts("Print Input Data:");
// puts("=====================================");
// test.display();
// puts("=====================================\n");
// k 值
const unsigned k = 3;
/** 准备测试数据 */
// KMeans++
// std::vector<Group> centroid = buildInitialPointRandomly(k, test);
// Kmeans + Density initialize
// std::vector<Group> centroid = buildInitialPointDensity(k, test);
// KMeans
// std::vector<Group> centroid = buildInitialPoint(k, test);
output << "===============================================" << std::endl;
output << "buildInitialPointRandomly" << std::endl;
output << "===============================================" << std::endl;
// 重复运行测试
std::vector<Group> result;
std::vector<double> avg(k);
double SSE = 0;
// 记录每次的 SSE 值
std::vector<double> vecSSE;
time_t start = std::clock();
// 重复实验的次数
for (unsigned i = 0; i < TIMES; ++i) {
printf("running: %d\r", i);
result = KMeans(test, k, buildInitialPointRandomly(k, test), false);
SSE = 0;
for (unsigned j = 0; j < result.size(); ++j) {
SSE += result[j].getSumOfEuclideanDistance();
vecSSE.push_back(SSE / result.size());
}
}
time_t end = std::clock();
output << "The average of SSE = " << getAverage(vecSSE) << std::endl;
output << "The variance of SSE = " << getVariance(vecSSE) << std::endl;
output << "The running time is: " << double(end - start) / CLOCKS_PER_SEC << std::endl;
// printf("The average of SSE = %lf\n", getAverage(vecSSE));
// printf("The variance of SSE = %lf\n", getVariance(vecSSE));
printf("the running time is : %f\n", double(end - start) / CLOCKS_PER_SEC);
output << "===============================================" << std::endl;
// puts("===============================================");
// KMedoids(test, k, centroid);
}
int main ()
{
/* 带有 5 个元素的整型数组 */
int balance[5] = {1000, 2, 3, 17, 50};
double avg;
/* 传递一个指向数组的指针作为参数 */
avg = getAverage( balance, 5 ) ;
/* 输出返回值 */
printf( "平均值是： %f ", avg );
return 0;
}
int main(void)
{
const int nelem = 10;
int *array;
array = (int *)malloc(nelem*sizeof(int));
/* Initialize the arrays */
for (indx = 0; indx < nelem; indx++)
{
array[indx] = 0;
}
/* Replace initial values of array elements */
populateArray(nelem, array);
/* Print the elements of the unsorted array */
printf("The sequence of elements in the unsorted array are: [ ");
for (indx = 0; indx < nelem; indx++)
{
printf("%d ", array[indx]);
}
printf("]\n\n");
/* Sort the array of integers */
sortArray(nelem, array, ascending);
/* Print the elements of the sorted array */
printf("The sequence of elements in the sorted array are: [ ");
for (indx = 0; indx < nelem; indx++)
{
printf("%d ", array[indx]);
}
printf("]\n\n");
/* Compute average value of elements in array */
getAverage(nelem, array);
/* Print sum of elements in array */
printf("The sum of the %d elements in the array is: %d\n\n ", nelem, sum);
/* Print average */
/* printf("The average value of the array elements is: %f\n\n ", getAverage(nelem, array)); */
free(array);
return 0;
}
u16 getBatTemp(u8 batNum)
{
u16 tempT;
return 2000;
PBT4 = 0; //output
if(batNum <3)
{
PB4 = 1;
tempT = getAverage(CHANNEL_TEMP_1);
}
else
{
PB4 = 0;
tempT = getAverage(CHANNEL_TEMP_2);
}
PB4 =0;
PBT4 = 1; //input
return tempT;
int Mic::optimizeSensitivity()
{
double average = getAverage();
for(int i = 0; i < 10; i++)
{
if(average <= mapping[i])
{
sensitivity = mapping[i];
Serial.println(sensitivity);
break;
}
}
return sensitivity;
}
int main() {
/* an int array with 5 elements */
int size = 5;
int balance[size];
double avg;
/* pass pointer to the array as an argument */
avg = getAverage(balance, 5);
/* output the returned value */
printf("Average value is: %f ", avg);
return 0;
}
std::string CSimpleStat::toStr(const std::string& unitString) const
{
std::stringstream ss;
if ((mBufPos <= 0) && !mHasWrapped)
ss << "No data";
else
{
double avg = getAverage();
double stdev = getStdev();
ss.setf(std::ios::fixed,std::ios::floatfield);
ss.precision(2);
ss << "Avg: " << avg << unitString << "\tStdev: " << stdev << unitString << " (" << 100.0*stdev/avg << "%)\tMin: " << getMinimum() << unitString << "\tMax:" << getMaximum() << unitString;
}
return ss.str();
}
int main()
{
int n,m;
int i;
int t;
while(scanf("%d%d",&n,&m)==2)
{
t=getAverage(n,m);
for(i=0;i<t-1;++i)
{
printf("%d ",average[i]);
}
printf("%d\n",average[i]);
}
return 0;
}
int main ()
{
/* an int array with 5 elements */
int balance[5] = {1000, 2, 3, 17, 50};
double avg;
char *s = "mera";
/* pass pointer to the array as an argument */
getAverage( balance, 5 ) ;
//char *p= bbb(s);
bbb(&s);
/* output the returned value */
printf("Average value is: %d\n %s", balance[0],s );
return 0;
}
int main ()
{
/* an int array with 5 elements */
int a[] = {1000, 2, 3, 17, 50,1000,123};
double avg;
int size;
size = sizeof(a)/sizeof(a[0]);
printf(" SIze2 %d\n",sizeof(a));
/* pass pointer to the array as an argument */
avg = getAverage( a) ;
/* output the returned value */
printf( "Average value is: %f ", avg );
return 0;
}
/*
* main.c
*/
int main(void) {
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
int arrayLength = 10;
int array[]={45, 42, 41,40, 43, 45, 46, 47, 49, 45};
int average;
int max;
int min;
int range;
average = getAverage(array, arrayLength);
max = max(array, arrayLength);
min = min(array, arrayLength);
range = range (array, arrayLength);
return 0;
}
