/**
* TODO: unit test channel_pow_stats::update_pbs_avg
*/
bool channel_pow_stats::update_bps_avg( uint64_t bytes_recv, const pow_hash& msg_pow )
{
// normalize the proof of work for the message size
fc::bigint msg( &msg_pow, sizeof(msg_pow) );
msg *= ( (bytes_recv / 1024) + 1); // give the average work per kb
// for the purposes of this calculation, there is no such thing as a message less than
// 1 KB in size.
if( bytes_recv < 1024 ) bytes_recv = 1024;
// first check the work, if it is valid we can work it into our
// POW average, otherwise we will ignore it.
if( msg_pow > target_pow ) return false;
// how much time has elapsed since the last bytes that passed
auto ellapsed_us = (fc::time_point::now() - last_recv).count();
last_recv = fc::time_point::now();
// prevent long delays between message from biasing the average too much
// also protects against OS time changes
if( ellapsed_us > BITCHAT_BANDWIDTH_WINDOW_US )
{
ellapsed_us = BITCHAT_BANDWIDTH_WINDOW_US/32;
}
// calculate the weighted average for the bitrate
auto total = avg_bits_per_usec*BITCHAT_BANDWIDTH_WINDOW_US + (8 * bytes_recv * ellapsed_us);
avg_bits_per_usec = total / (BITCHAT_BANDWIDTH_WINDOW_US + ellapsed_us);
// use the same weighting factors to weight the update to the average POW
fc::bigint avg( &average_pow, sizeof(average_pow) );
fc::bigint wsum = (avg * BITCHAT_BANDWIDTH_WINDOW_US + msg*ellapsed_us)
/
(BITCHAT_BANDWIDTH_WINDOW_US+ellapsed_us);
fc::bigint tar( &target_pow, sizeof(target_pow) );
if( avg_bits_per_usec >= target_bits_per_usec )
{
tar *= wsum * bigint( 990000ll);
tar /= bigint(1000000ll);
}
else
{
// increase target (making it easier to get under)
tar = wsum * bigint(1010000ll);
tar /= bigint(1000000ll);
}
std::vector<char> tarw(tar);
std::vector<char> avgw(wsum);
target_pow = pow_hash();
memcpy( (char*)&target_pow + sizeof(pow_hash)-tarw.size(),
tarw.data(), tarw.size() );
memcpy( (char*)&average_pow + sizeof(pow_hash)-avgw.size(),
avgw.data(), avgw.size() );
return true;
}
int main() {
int a[]={1,2,3,4,5,6,7,8,9,0};//[MAX_SIZE];
int n=7, opcija;
do {
printf(" Opcije:\n\n");
printf("\t1. Unos elemenata niza.\n");
printf("\t2. Izracunavanje sume.\n");
printf("\t3. Racunanje srednje vrednosti.\n");
printf("\t4. Ispis niza.\n");
printf("\t5. Izlaz iz programa.\n ");
printf("\n\t>> ");
scanf("%d", &opcija);
switch( opcija ) {
case 1: unosNiza(a, &n); break;
case 2: printf("Suma je: %d.\n\n", suma(a, n)); break;
case 3: printf("Srednja vrednost je: %lf.\n\n", avg(a, n)); break;
case 4: ispis(a, n); break;
}
} while ( opcija != 5);
return 0;
}
/* double avg(double*, int) */
static PyObject* py_avg(PyObject* self, PyObject* args)
{
PyObject* bufobj;
Py_buffer view;
double result;
if (!PyArg_ParseTuple(args, "O", &bufobj)) {
return NULL;
}
if (PyObject_GetBuffer(bufobj, &view, PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) == -1) {
return NULL;
}
if (view.ndim != 1) {
PyErr_SetString(PyExc_TypeError, "Expected a 1-dimensional array");
PyBuffer_Release(&view);
return NULL;
}
if (strcmp(view.format, "d") != 0) {
PyErr_SetString(PyExc_TypeError, "Expected an array of doubles");
PyBuffer_Release(&view);
return NULL;
}
result = avg(view.buf, view.shape[0]);
PyBuffer_Release(&view);
return Py_BuildValue("d", result);
}
void Twirl::update(float time)
{
int i, j;
Vec2 c = _position;
for (i = 0; i < (_gridSize.width+1); ++i)
{
for (j = 0; j < (_gridSize.height+1); ++j)
{
Vec3 v = getOriginalVertex(Vec2(i ,j));
Vec2 avg(i-(_gridSize.width/2.0f), j-(_gridSize.height/2.0f));
float r = avg.getLength();
float amp = 0.1f * _amplitude * _amplitudeRate;
float a = r * cosf( (float)M_PI/2.0f + time * (float)M_PI * _twirls * 2 ) * amp;
Vec2 d(
sinf(a) * (v.y-c.y) + cosf(a) * (v.x-c.x),
cosf(a) * (v.y-c.y) - sinf(a) * (v.x-c.x));
v.x = c.x + d.x;
v.y = c.y + d.y;
setVertex(Vec2(i ,j), v);
}
}
}
Average(const TConstIter begin, const TConstIter end):
count_(0u),
avg_(0.0),
stdDev_(0.0)
{
// vector of data will be needed any way later for precise computations
std::vector<FP> tmp(begin, end);
// count number of elements
count_=tmp.size();
// compute the average
std::sort( tmp.begin(), tmp.end() );
avg_=arraySumFastFP<FP>( tmp.begin(), tmp.end() )/count();
// special case
if(count_==1u)
{
stdDev_=0;
return;
}
// compute standard deviation
assert( count()>1u );
for(typename std::vector<FP>::iterator it=tmp.begin(); it!=tmp.end(); ++it)
*it=std::pow(*it-avg(), 2);
std::sort( tmp.begin(), tmp.end() );
stdDev_=std::sqrt( arraySumFastFP<FP>( tmp.begin(), tmp.end() ) / ( count()-1 ) );
}
int main(){
int A[MAX],n,i,b;
printf("Unesite broj clanova niza: ");
scanf("%d",&n);
printf("Unesite clanove niza: \n");
for(i=0;i<n;i++)scanf("%d",&A[i]);
do{
printf("\n");
printf("Opcije: \n\n");
printf("\t 1. Izracunavanje sume.\n");
printf("\t 2. Racunanje srednje vrednosti.\n");
printf("\t 3. Nalazenje minimuma.\n");
printf("\t 4. Nalazenje maksimuma.\n");
printf("\t 5. Ispis elemenata.\n");
printf("\n\t>>");
scanf("%d", &b);
switch(b) {
case 1: printf("Suma svih elemenata u nizu je: %d\n", suma(A,n)); break;
case 2: printf("Aritmeticka sredina niza je: %.2f\n", avg(A,n)); break;
case 3: printf("Minimalna vrednost u nizu je: %d\n", min(A,n)); break;
case 4: printf("Maximalna vrednost u nizu je: %d\n", max(A,n)); break;
case 5: ispis(A,n); break;
}
}while(b!=5);
return 0;
}
// Analysis_TimeCorr::CalculateAverages()
std::vector<double> Analysis_Timecorr::CalculateAverages(DataSet_Vector const& vIn,
AvgResults& avgOut)
{
std::vector<double> R3i;
R3i.reserve(vIn.Size());
Vec3 avg(0.0, 0.0, 0.0);
avgOut.rave_ = 0.0;
avgOut.r3iave_ = 0.0;
avgOut.r6iave_ = 0.0;
// Loop over all vectors
for (DataSet_Vector::const_iterator vec = vIn.begin();
vec != vIn.end(); ++vec)
{
const Vec3& VXYZ = *vec;
// Calc vector length
double len = sqrt( VXYZ.Magnitude2() );
// Update avgcrd, rave, r3iave, r6iave
avg += VXYZ;
avgOut.rave_ += len;
double r3i = 1.0 / (len*len*len);
avgOut.r3iave_ += r3i;
avgOut.r6iave_ += r3i*r3i;
R3i.push_back( r3i );
}
// Normalize averages
double dnorm = 1.0 / (double)vIn.Size();
avgOut.rave_ *= dnorm;
avgOut.r3iave_ *= dnorm;
avgOut.r6iave_ *= dnorm;
avgOut.avgr_ = sqrt(avg.Magnitude2()) * dnorm;
return R3i;
}
static void do_average_spillmap_blue_fac(bNode *node, float* out, float *in, float *fac)
{
NodeColorspill *ncs;
ncs=node->storage;
out[0] = *fac * (in[0]-(ncs->limscale * avg(in[0], in[1]) ));
}
static int __init avg_init(void)
{
printk("I am in init module\n");
a=avg(par1,par2);
printk("avg of numbers is:%d\n",a);
return(0);
}
/* Actually do the work of printing out the human-readable message. */
static CARD32 dmxStatCallback(OsTimerPtr timer, CARD32 t, pointer arg)
{
int i, j;
static int header = 0;
int limit = dmxNumScreens;
if (!dmxNumScreens) {
header = 0;
return DMX_STAT_INTERVAL;
}
if (!header++ || !(header % 10)) {
dmxLog(dmxDebug,
" S SyncCount Sync/s avSync mxSync avPend mxPend | "
"<10ms <1s >1s\n");
}
if (dmxStatDisplays && dmxStatDisplays < limit) limit = dmxStatDisplays;
for (i = 0; i < limit; i++) {
DMXScreenInfo *dmxScreen = &dmxScreens[i];
DMXStatInfo *s = dmxScreen->stat;
unsigned long aSync, mSync;
unsigned long aPend, mPend;
if (!s) continue;
aSync = avg(&s->usec, &mSync);
aPend = avg(&s->pending, &mPend);
dmxLog(dmxDebug, "%2d %9lu %7lu %6lu %6lu %6lu %6lu |",
i, /* S */
s->syncCount, /* SyncCount */
(s->syncCount
- s->oldSyncCount) * 1000 / dmxStatInterval, /* Sync/s */
aSync, /* us/Sync */
mSync, /* max/Sync */
aPend, /* avgPend */
mPend); /* maxPend */
for (j = 0; j < DMX_STAT_BINS; j++)
dmxLogCont(dmxDebug, " %5lu", s->bins[j]);
dmxLogCont(dmxDebug, "\n");
/* Reset/clear */
s->oldSyncCount = s->syncCount;
for (j = 0; j < DMX_STAT_BINS; j++) s->bins[j] = 0;
}
return DMX_STAT_INTERVAL; /* Place on queue again */
}
void naive_smooth(int dim, pixel *src, pixel *dst)
{
int i, j;
for (i = 0; i < dim; i++)
for (j = 0; j < dim; j++)
dst[RIDX(i, j, dim)] = avg(dim, i, j, src);
}
void show_scores(const int arr[], const int size)
{
for(int i = 0; i < size; i++)
std::cout << arr[i] << ", ";
std::cout << "Average: " << avg(arr ,size) << std::endl;
}
double WaveformUtilities::Eccentricity_rDot(const std::vector<double>& t, const std::vector<double>& rDot,
const double r0, const double Omega0, double& DeltarDot, double& DeltaPhiDot) {
//// Do the fit to the model:
//// rDot(t) = vbar0 + arbar0*t + Br*cos(omegar*t+phir)
//// First fit to rDotDot to find phase, frequency, and amplitude
std::vector<double> rDotDot = dydx(rDot, t);
std::vector<double> aDotDotGuesses(3);
aDotDotGuesses[0] = 0.5*(max(rDotDot)-min(rDotDot));
aDotDotGuesses[1] = Omega0;
aDotDotGuesses[2] = 0.0;
std::vector<double> rDotDotMinusAvg = rDotDot-avg(rDotDot);
std::vector<double> TrivialSigmas(t.size(), 1.0);
Eccentricity_rDotDotFit e_dd;
FitNonlinear<Eccentricity_rDotDotFit> rDotDotFit(t, rDotDotMinusAvg, TrivialSigmas, aDotDotGuesses, e_dd, 1.e-8);
rDotDotFit.hold(0, aDotDotGuesses[0]);
rDotDotFit.hold(1, aDotDotGuesses[1]);
rDotDotFit.fit();
rDotDotFit.free(1);
rDotDotFit.fit();
rDotDotFit.free(0);
rDotDotFit.fit();
//// Next fit to rDot to find all parameters
std::vector<double> aDotGuesses(5);
aDotGuesses[0] = avg(rDot);
aDotGuesses[1] = avg(rDotDot);
aDotGuesses[2] = rDotDotFit.a[0] / rDotDotFit.a[1];
aDotGuesses[3] = rDotDotFit.a[1];
aDotGuesses[4] = rDotDotFit.a[2];
Eccentricity_rDotFit e_d;
FitNonlinear<Eccentricity_rDotFit> rDotFit(t, rDot, TrivialSigmas, aDotGuesses, e_d, 1.e-8);
rDotFit.fit();
//// Adjust the parameters
//double& vbar0 = rDotFit.a[0];
//double& arbar0 = rDotFit.a[1];
double& Br = rDotFit.a[2];
double& omegar = rDotFit.a[3];
double& phir = rDotFit.a[4];
DeltarDot = -Br * cos(phir); // Eq. (71) of arXiv:1012.1549
DeltaPhiDot = Br * omegar * sin(phir) / (2* r0 * Omega0); // Eq. (73) of arXiv:1012.1549
//// Return the measured eccentricity
return -Br / (r0 * omegar);
}
MatrixXd DoPCA( MatrixXd &model ){
int N = ( int )model.cols();
MatrixXd avg( model.rows(), 1 );
for( int i = 0; i < avg.rows(); ++i ){
avg( i ) = model.row( i ).mean();
}
for( int i = 0; i < avg.cols(); ++i ){
model.col( i ) -= avg;
}
JacobiSVD< MatrixXd > svd( model.transpose(), Eigen::ComputeThinU | Eigen::ComputeThinV );
return svd.matrixV();
}
///driver function to generate, insert and search rb hash tree
void random_runner() {
clock_t start, end;
double insert_array[10], search_array[10];
for ( int i = 0; i < 10; i++ ) {
generate_random();
start = ((double)clock()*1000)/CLOCKS_PER_SEC;
insert_random();
end = ((double)clock()*1000)/CLOCKS_PER_SEC;
insert_array[i] = end - start;
start = ((double)clock()*1000)/CLOCKS_PER_SEC;
search_random();
end = ((double)clock()*1000)/CLOCKS_PER_SEC;
search_array[i] = end - start;
make_root_null();
}
cout << avg ( insert_array ) << " " << avg ( search_array ) << endl;
}
void testRunningAverage()
{
std::cerr << "Starting Aut::testRunningAverage()\n";
RunningAverage<float> avg(3, std::chrono::milliseconds(750));
assert (avg.capacity() == 3);
assert (avg.window() == std::chrono::milliseconds(750));
// Without assuming what kind of average Aut::RunningAverage implements
// (e.g., it might be weighted or not) we can still test that the
// running average of one number added multiple times is that number.
avg.add(10.0);
assert (avg() == 10.0);
avg.add(10.0);
assert (avg() == 10.0);
avg.add(10.0);
assert (avg() == 10.0);
avg.add(10.0);
assert (avg() == 10.0);
avg.add(11.0);
assert (avg() != 10.0);
// But if we wait longer than time window and add a different number,
// then the running average should ignore all the previous additions
// and return just the new number.
std::this_thread::sleep_for(std::chrono::seconds(2));
avg.add(12.0);
assert (avg() == 12.0);
std::cerr << "ok\n";
}
void testFunction(){
assert(sameCase('a', 'b'));
assert(!(sameCase('a', 'B')));
assert(sameCase('A','B'));
assert(numberOfDigits(123)==3);
assert(numberOfDigits(123456)==6);
assert(!(numberOfDigits(123)==5));
assert(fabs(avg(30, 40)-((30+40)/2)<0.0000001));
}
double var(double *x, int n) {
double x_avg = avg(x, n);
double sum = 0.0;
for (int i = 0; i < n; i++) {
double dx = x[i] - x_avg;
sum += dx * dx;
}
return (sum / n);
}
void PCPolyhedron::unifyVertexs() {
vertexs.clear();
struct VertexInPCPolygon
{
VertexInPCPolygon(PCPolygon* pcp, int vertex) : pcp(pcp), vertex(vertex) { }
PCPolygon* pcp;
int vertex;
};
vector<VertexInPCPolygon> updateVertexs;
for (vector<PCPolygonPtr>::iterator nextIter = pcpolygons.begin(); nextIter != pcpolygons.end();) {
vector<PCPolygonPtr>::iterator iter = nextIter++;
Polygon* polygon = (*iter)->getPolygonModelObject();
if (polygon == NULL) {
// No model object is available yet, quit!
return;
}
for (int j = 0; j < polygon->getMathModel().getVertexs().size(); j++) {
updateVertexs.clear();
VertexInPCPolygon vpp(iter->get(), j);
updateVertexs.push_back(vpp);
ofVec3f v(polygon->getMathModel().getVertexs()[j]);
for (vector<PCPolygonPtr>::iterator iter2 = iter; iter2 != pcpolygons.end(); iter2++) {
Polygon* polygon2 = (*iter2)->getPolygonModelObject();
for (int k = 0; k < polygon2->getMathModel().getVertexs().size(); k++) {
ofVec3f v2(polygon2->getMathModel().getVertexs()[k]);
if (!(v == v2)
&& polygon->getMathModel().getVertexs()[j].distance(polygon2->getMathModel().getVertexs()[k]) <= Constants::OBJECT_VERTEX_UNIFYING_DISTANCE()) {
VertexInPCPolygon vpp2(iter2->get(), k);
updateVertexs.push_back(vpp2);
}
}
}
if (updateVertexs.size() > 1) {
ofVec3f avg(0, 0, 0);
for (int i = 0; i < updateVertexs.size(); i++) {
avg += updateVertexs.at(i).pcp->getPolygonModelObject()->getMathModel().getVertexs()[updateVertexs.at(i).vertex];
}
avg /= updateVertexs.size();
for (int i = 0; i < updateVertexs.size(); i++) {
updateVertexs.at(i).pcp->getPolygonModelObject()->setVertex(updateVertexs.at(i).vertex, avg);
//vx.Polygons.push_back(PCPolygonPtr(updateVertexs.at(i).pcp));
}
this->vertexs.push_back(avg);
//vx.setPoint(avg);
//vertexs.push_back(vx);
}
}
}
saveCloud("UnifiedVertex.pcd", vertexs);
}
Vector3<float> Drive::averageAccelerometer() {
Vector3<float> avg(0.0f, 0.0f, 0.0f);
for (int i = 0; i < mSmoothing; ++i)
avg += mAccelValue[i];
avg.x /= mSmoothing;
avg.y /= mSmoothing;
avg.z /= mSmoothing;
return avg;
}
Duration MultiplexedSocket::averageReceiveLatency() const {
Duration avg(Duration::zero());
uint32 nsockets = (uint32)mSockets.size();
for(uint32 ii = 0; ii < nsockets; ++ii) {
avg += mSockets[ii].averageReceiveLatency();
}
return avg / (float)nsockets;
}
double avg(List *l,int sum,int lgth){
if(l->next->next ==NULL){
//printf("I am here: %d %f ||||| %d ",lgth,(sum+l->info))/((double)(lgth+1),l->info);
//printf("here %lf ||| %d",(double)(sum+l->info+l->next->info)/(double)(lgth+2),l->info);
return (sum+l->info+l->next->info)/(lgth+2);
}
return avg(l->next,sum+(l->info),lgth+1);
}
void PPCA::center(){
for(int i=0; i<data.rows(); i++){
double av = avg(data, i);
for(int j=0; j<data.cols(); j++){
data(i,j).x -= av;
}
}
}
int main() {
int x, y;
puts("Enter the first number:");
scanf("%d", &x);
puts("Enter the second number:");
scanf("%d", &y);
printf("The average is %.2f\n", avg(x,y));
return 0;
}
Vector3<float> Drive::averageGyroscope() {
Vector3<float> avg(0.0f, 0.0f, 0.0f);
for (int i = 0; i < mSmoothing; ++i)
avg += mGyroValue[i];
avg.x /= mSmoothing;
avg.y /= mSmoothing;
avg.z /= mSmoothing;
return avg;
}
int main(void) {
float src[64], dstv[64], dsts[64];
int i;
for(i=0; i<64; ++i)
src[i] = i-32;
zlimit (0, src, dsts, 64);
zlimit (1, src, dstv, 64);
for (i = 0; i < 64; ++i)
assert(dstv[i] == dsts[i]);
uint8_t srci_a[16], srci_b[16], dstvi[16], dstsi[16];
for(i=0; i<16; ++i) {
srci_a[i] = i;
srci_b[i] = i+10;
}
avg (0, srci_a, srci_b, dstsi);
avg (1, srci_a, srci_b, dstvi);
for(i=0; i<16; ++i)
assert(dstvi[i] == dstsi[i]);
}
void naive_smooth(int dim, pixel *src, pixel *dst){
int i, j;
for (i = 0; i < dim; i++)
{
for (j = 0; j < dim; j++)
{
dst[i*dim+j] = avg(dim, i, j, src);
}
}
}
auto_ptr<GridDensityProvider>
HeuristicGridDensityProviderFactory::newGridDensityProvider(OccluderSource& source, const real proscenium[4])
{
auto_ptr<AverageAreaGridDensityProvider> avg(new AverageAreaGridDensityProvider(source, proscenium, sizeFactor));
auto_ptr<Pow23GridDensityProvider> p23(new Pow23GridDensityProvider(source, proscenium, numFaces));
if (avg->cellSize() > p23->cellSize()) {
return (auto_ptr<GridDensityProvider>) p23;
}
else {
return (auto_ptr<GridDensityProvider>) avg;
}
}
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);
}
void smooth5(int dim, pixel *src, pixel *dst)
{
int i, j, ii;
for (i = 0; i < dim; i+=8)
{
for (j = 0; j < dim; j++)
{
for(ii = 0; ii<8; ii++)
dst[RIDX(i+ii, j, dim)] = avg(dim, i+ii, j, src);
}
}
}
