arzmq-sys 0.6.3

Low-level bindings to the zeromq library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

#include "protoAverage.h"
#include "protoDebug.h"
#include "math.h"
#include <limits>
using std::numeric_limits;

ProtoAverage::ProtoAverage() : count(0)
{
}
ProtoAverage::~ProtoAverage()
{
}
void
ProtoAverage::Reset()
{
    list.Destroy();
    count = 0;
}
bool
ProtoAverage::AddNumber(double number)
{
    count++;
    //if its the first entry just make new Item and add it to the list
    if(list.IsEmpty())
    {
        AverageItem* newItem = new AverageItem(number);
        list.Prepend(*newItem);
        return true;
    }
    //check the depth of the last value
    if(list.GetHead()->GetDepth()!=0)//first entry is not a single value so just prepend the item
    {
        AverageItem* newItem = new AverageItem(number);
        list.Prepend(*newItem);
    } else { //the head entry was a single value so we need to bubble back the averages
        AverageList::Iterator iterator(list);
        AverageItem tempItem(number);
        AverageItem* firstItemPtr = &tempItem;
        AverageItem* secondItemPtr = list.GetHead();
        while(firstItemPtr->GetDepth()==secondItemPtr->GetDepth())
        {
            if(!secondItemPtr->Merge(*firstItemPtr))
            {
                TRACE("failed merging numbers!\n");
                return false;
            }
            //if first item is the head destroy it
            if(firstItemPtr==list.GetHead())
            {
                firstItemPtr = list.RemoveHead();
                delete firstItemPtr;
            }
            //fix the pointers
            iterator.Reset();
            firstItemPtr = iterator.GetNextItem();
            secondItemPtr = iterator.GetNextItem();
            if(secondItemPtr==NULL)
            {
                //we bubbled all the way to one value
                return true;
            }
        }
    }
    return true;
}
double
ProtoAverage::GetAverage()
{
    //iterate over list in reverse and get the weighted average
    AverageList::Iterator iterator(list);
    AverageItem* item = iterator.GetNextItem();
    if(item!=NULL)
    {
        ProtoAverage::AverageItem tempItem(item->GetValue());//used for storing the moving average as we go
        tempItem.SetDepth(item->GetDepth());
        double x , y, z;
        double dpx=0;
        double dpy=0;
        double dpz=0;
        double numeral;
        double denom;
        while((item = iterator.GetNextItem()))
        {
            x = tempItem.GetValue();
            dpx = tempItem.GetDepth();
            y = item->GetValue();
            dpy = item->GetDepth();

            numeral = (x + y * pow(2,dpy-dpx));
            if(numeral==numeric_limits<double>::infinity()){
                //we need to go under instead of over
                numeral = (x * pow(2,dpx-dpy) + y);
                denom = (pow(2,dpx-dpy)+1);
            } 
            else 
            {
                denom = (1+pow(2,dpy-dpx));
            }
            z = numeral/denom; //z is the new average
            dpz  = log(denom)/log(2)+dpx; //dpz is the weighted depth of the new average
            dpz  = log(1+pow(2,dpy-dpx))/log(2)+dpx; //dpz is the weighted depth of the new average

            tempItem.SetValue(z);
            tempItem.SetDepth(dpz);
        }
        return tempItem.GetValue();
    }
    return 0;
}
unsigned long
ProtoAverage::GetCount() const
{
    return count;
}
void
ProtoAverage::Print()
{
    AverageList::Iterator iterator(list);
    AverageItem* item;
    while((item = iterator.GetNextItem()))
    {
        TRACE("(%f,%f) ",item->GetValue(),item->GetDepth());
    }
    TRACE("\n");
}
bool
ProtoAverage::AverageItem::Merge(const ProtoAverage::AverageItem &otherItem)
{
    //verify that they are at the same depth
    double tempvalue = 0;
    if(otherItem.GetDepth()!=GetDepth())
    {
        return false;
    }
    tempvalue = (value + otherItem.GetValue())/2;
    if(tempvalue==numeric_limits<double>::infinity())
    {
        //lets try dividing first
        value = value/2 + otherItem.GetValue()/2;
    } else {
        value = tempvalue;
    }
    
    if(value==numeric_limits<double>::infinity())
    {
        TRACE("still getting inf\n");
        TRACE("%f\n\n",value/2);
        TRACE("%f\n\n",otherItem.GetValue()/2);
        TRACE("%f\n\n",value/2+otherItem.GetValue()/2);
        return false;
    }
    depth = depth+1;
    return true;
}
void
ProtoAverage::AverageItem::SetValue(double v)
{
    value = v;
    return;
}
void
ProtoAverage::AverageItem::SetDepth(double d)
{
    depth = d;
    return;
}