into iceaxe.:/Volumes/work/research/m5/merge src/cpu/simple/base.cc: src/kern/kernel_stats.cc: src/kern/kernel_stats.hh: src/kern/system_events.cc: src/kern/system_events.hh: src/python/m5/objects/System.py: src/sim/system.cc: src/sim/system.hh: hand merge --HG-- rename : build/SConstruct => SConstruct rename : SConscript => src/SConscript rename : arch/alpha/freebsd/system.cc => src/arch/alpha/freebsd/system.cc rename : arch/alpha/linux/system.cc => src/arch/alpha/linux/system.cc rename : arch/alpha/linux/system.hh => src/arch/alpha/linux/system.hh rename : arch/alpha/system.cc => src/arch/alpha/system.cc rename : arch/alpha/tru64/system.cc => src/arch/alpha/tru64/system.cc rename : base/statistics.cc => src/base/statistics.cc rename : base/statistics.hh => src/base/statistics.hh rename : base/stats/mysql.cc => src/base/stats/mysql.cc rename : base/stats/mysql.hh => src/base/stats/mysql.hh rename : base/stats/statdb.cc => src/base/stats/statdb.cc rename : base/stats/statdb.hh => src/base/stats/statdb.hh rename : base/stats/text.cc => src/base/stats/text.cc rename : base/stats/text.hh => src/base/stats/text.hh rename : cpu/simple/cpu.cc => src/cpu/simple/base.cc rename : kern/kernel_stats.cc => src/kern/kernel_stats.cc rename : kern/kernel_stats.hh => src/kern/kernel_stats.hh rename : kern/system_events.cc => src/kern/system_events.cc rename : kern/system_events.hh => src/kern/system_events.hh rename : python/m5/objects/System.py => src/python/m5/objects/System.py rename : sim/system.cc => src/sim/system.cc rename : sim/system.hh => src/sim/system.hh rename : test/stattest.cc => src/unittest/stattest.cc extra : convert_revision : 4bb576a2bf5e32784efc48030bd776c6c7c29a7c
768 lines
22 KiB
Python
768 lines
22 KiB
Python
# Copyright (c) 2003-2004 The Regents of The University of Michigan
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met: redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer;
|
|
# redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution;
|
|
# neither the name of the copyright holders nor the names of its
|
|
# contributors may be used to endorse or promote products derived from
|
|
# this software without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
# Authors: Nathan Binkert
|
|
|
|
from __future__ import division
|
|
import operator, re, types
|
|
|
|
class ProxyError(Exception):
|
|
pass
|
|
|
|
def unproxy(proxy):
|
|
if hasattr(proxy, '__unproxy__'):
|
|
return proxy.__unproxy__()
|
|
|
|
return proxy
|
|
|
|
def scalar(stat):
|
|
stat = unproxy(stat)
|
|
assert(stat.__scalar__() != stat.__vector__())
|
|
return stat.__scalar__()
|
|
|
|
def vector(stat):
|
|
stat = unproxy(stat)
|
|
assert(stat.__scalar__() != stat.__vector__())
|
|
return stat.__vector__()
|
|
|
|
def value(stat, *args):
|
|
stat = unproxy(stat)
|
|
return stat.__value__(*args)
|
|
|
|
def values(stat, run):
|
|
stat = unproxy(stat)
|
|
result = []
|
|
for i in xrange(len(stat)):
|
|
val = value(stat, run, i)
|
|
if val is None:
|
|
return None
|
|
result.append(val)
|
|
return result
|
|
|
|
def total(stat, run):
|
|
return sum(values(stat, run))
|
|
|
|
def len(stat):
|
|
stat = unproxy(stat)
|
|
return stat.__len__()
|
|
|
|
class Value(object):
|
|
def __scalar__(self):
|
|
raise AttributeError, "must define __scalar__ for %s" % (type (self))
|
|
def __vector__(self):
|
|
raise AttributeError, "must define __vector__ for %s" % (type (self))
|
|
|
|
def __add__(self, other):
|
|
return BinaryProxy(operator.__add__, self, other)
|
|
def __sub__(self, other):
|
|
return BinaryProxy(operator.__sub__, self, other)
|
|
def __mul__(self, other):
|
|
return BinaryProxy(operator.__mul__, self, other)
|
|
def __div__(self, other):
|
|
return BinaryProxy(operator.__div__, self, other)
|
|
def __truediv__(self, other):
|
|
return BinaryProxy(operator.__truediv__, self, other)
|
|
def __floordiv__(self, other):
|
|
return BinaryProxy(operator.__floordiv__, self, other)
|
|
|
|
def __radd__(self, other):
|
|
return BinaryProxy(operator.__add__, other, self)
|
|
def __rsub__(self, other):
|
|
return BinaryProxy(operator.__sub__, other, self)
|
|
def __rmul__(self, other):
|
|
return BinaryProxy(operator.__mul__, other, self)
|
|
def __rdiv__(self, other):
|
|
return BinaryProxy(operator.__div__, other, self)
|
|
def __rtruediv__(self, other):
|
|
return BinaryProxy(operator.__truediv__, other, self)
|
|
def __rfloordiv__(self, other):
|
|
return BinaryProxy(operator.__floordiv__, other, self)
|
|
|
|
def __neg__(self):
|
|
return UnaryProxy(operator.__neg__, self)
|
|
def __pos__(self):
|
|
return UnaryProxy(operator.__pos__, self)
|
|
def __abs__(self):
|
|
return UnaryProxy(operator.__abs__, self)
|
|
|
|
class Scalar(Value):
|
|
def __scalar__(self):
|
|
return True
|
|
|
|
def __vector__(self):
|
|
return False
|
|
|
|
def __value__(self, run):
|
|
raise AttributeError, '__value__ must be defined'
|
|
|
|
class VectorItemProxy(Value):
|
|
def __init__(self, proxy, index):
|
|
self.proxy = proxy
|
|
self.index = index
|
|
|
|
def __scalar__(self):
|
|
return True
|
|
|
|
def __vector__(self):
|
|
return False
|
|
|
|
def __value__(self, run):
|
|
return value(self.proxy, run, self.index)
|
|
|
|
class Vector(Value):
|
|
def __scalar__(self):
|
|
return False
|
|
|
|
def __vector__(self):
|
|
return True
|
|
|
|
def __value__(self, run, index):
|
|
raise AttributeError, '__value__ must be defined'
|
|
|
|
def __getitem__(self, index):
|
|
return VectorItemProxy(self, index)
|
|
|
|
class ScalarConstant(Scalar):
|
|
def __init__(self, constant):
|
|
self.constant = constant
|
|
def __value__(self, run):
|
|
return self.constant
|
|
def __str__(self):
|
|
return str(self.constant)
|
|
|
|
class VectorConstant(Vector):
|
|
def __init__(self, constant):
|
|
self.constant = constant
|
|
def __value__(self, run, index):
|
|
return self.constant[index]
|
|
def __len__(self):
|
|
return len(self.constant)
|
|
def __str__(self):
|
|
return str(self.constant)
|
|
|
|
def WrapValue(value):
|
|
if isinstance(value, (int, long, float)):
|
|
return ScalarConstant(value)
|
|
if isinstance(value, (list, tuple)):
|
|
return VectorConstant(value)
|
|
if isinstance(value, Value):
|
|
return value
|
|
|
|
raise AttributeError, 'Only values can be wrapped'
|
|
|
|
class Statistic(object):
|
|
def __getattr__(self, attr):
|
|
if attr in ('data', 'x', 'y'):
|
|
result = self.source.data(self, self.ticks)
|
|
self.data = result.data
|
|
self.x = result.x
|
|
self.y = result.y
|
|
return super(Statistic, self).__getattribute__(attr)
|
|
|
|
def __setattr__(self, attr, value):
|
|
if attr == 'stat':
|
|
raise AttributeError, '%s is read only' % stat
|
|
if attr in ('source', 'ticks'):
|
|
if getattr(self, attr) != value:
|
|
if hasattr(self, 'data'):
|
|
delattr(self, 'data')
|
|
|
|
super(Statistic, self).__setattr__(attr, value)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
class ValueProxy(Value):
|
|
def __getattr__(self, attr):
|
|
if attr == '__value__':
|
|
if scalar(self):
|
|
return self.__scalarvalue__
|
|
if vector(self):
|
|
return self.__vectorvalue__
|
|
if attr == '__len__':
|
|
if vector(self):
|
|
return self.__vectorlen__
|
|
return super(ValueProxy, self).__getattribute__(attr)
|
|
|
|
class UnaryProxy(ValueProxy):
|
|
def __init__(self, op, arg):
|
|
self.op = op
|
|
self.arg = WrapValue(arg)
|
|
|
|
def __scalar__(self):
|
|
return scalar(self.arg)
|
|
|
|
def __vector__(self):
|
|
return vector(self.arg)
|
|
|
|
def __scalarvalue__(self, run):
|
|
val = value(self.arg, run)
|
|
if val is None:
|
|
return None
|
|
return self.op(val)
|
|
|
|
def __vectorvalue__(self, run, index):
|
|
val = value(self.arg, run, index)
|
|
if val is None:
|
|
return None
|
|
return self.op(val)
|
|
|
|
def __vectorlen__(self):
|
|
return len(unproxy(self.arg))
|
|
|
|
def __str__(self):
|
|
if self.op == operator.__neg__:
|
|
return '-%s' % str(self.arg)
|
|
if self.op == operator.__pos__:
|
|
return '+%s' % str(self.arg)
|
|
if self.op == operator.__abs__:
|
|
return 'abs(%s)' % self.arg
|
|
|
|
class BinaryProxy(ValueProxy):
|
|
def __init__(self, op, arg0, arg1):
|
|
super(BinaryProxy, self).__init__()
|
|
self.op = op
|
|
self.arg0 = WrapValue(arg0)
|
|
self.arg1 = WrapValue(arg1)
|
|
|
|
def __scalar__(self):
|
|
return scalar(self.arg0) and scalar(self.arg1)
|
|
|
|
def __vector__(self):
|
|
return vector(self.arg0) or vector(self.arg1)
|
|
|
|
def __scalarvalue__(self, run):
|
|
val0 = value(self.arg0, run)
|
|
val1 = value(self.arg1, run)
|
|
if val0 is None or val1 is None:
|
|
return None
|
|
try:
|
|
return self.op(val0, val1)
|
|
except ZeroDivisionError:
|
|
return None
|
|
|
|
def __vectorvalue__(self, run, index):
|
|
if scalar(self.arg0):
|
|
val0 = value(self.arg0, run)
|
|
if vector(self.arg0):
|
|
val0 = value(self.arg0, run, index)
|
|
if scalar(self.arg1):
|
|
val1 = value(self.arg1, run)
|
|
if vector(self.arg1):
|
|
val1 = value(self.arg1, run, index)
|
|
|
|
if val0 is None or val1 is None:
|
|
return None
|
|
|
|
try:
|
|
return self.op(val0, val1)
|
|
except ZeroDivisionError:
|
|
return None
|
|
|
|
def __vectorlen__(self):
|
|
if vector(self.arg0) and scalar(self.arg1):
|
|
return len(self.arg0)
|
|
if scalar(self.arg0) and vector(self.arg1):
|
|
return len(self.arg1)
|
|
|
|
len0 = len(self.arg0)
|
|
len1 = len(self.arg1)
|
|
|
|
if len0 != len1:
|
|
raise AttributeError, \
|
|
"vectors of different lengths %d != %d" % (len0, len1)
|
|
|
|
return len0
|
|
|
|
def __str__(self):
|
|
ops = { operator.__add__ : '+',
|
|
operator.__sub__ : '-',
|
|
operator.__mul__ : '*',
|
|
operator.__div__ : '/',
|
|
operator.__truediv__ : '/',
|
|
operator.__floordiv__ : '//' }
|
|
|
|
return '(%s %s %s)' % (str(self.arg0), ops[self.op], str(self.arg1))
|
|
|
|
class Proxy(Value):
|
|
def __init__(self, name, dict):
|
|
self.name = name
|
|
self.dict = dict
|
|
|
|
def __unproxy__(self):
|
|
return unproxy(self.dict[self.name])
|
|
|
|
def __getitem__(self, index):
|
|
return ItemProxy(self, index)
|
|
|
|
def __getattr__(self, attr):
|
|
return AttrProxy(self, attr)
|
|
|
|
def __str__(self):
|
|
return str(self.dict[self.name])
|
|
|
|
class ItemProxy(Proxy):
|
|
def __init__(self, proxy, index):
|
|
self.proxy = proxy
|
|
self.index = index
|
|
|
|
def __unproxy__(self):
|
|
return unproxy(unproxy(self.proxy)[self.index])
|
|
|
|
def __str__(self):
|
|
return '%s[%s]' % (self.proxy, self.index)
|
|
|
|
class AttrProxy(Proxy):
|
|
def __init__(self, proxy, attr):
|
|
self.proxy = proxy
|
|
self.attr = attr
|
|
|
|
def __unproxy__(self):
|
|
proxy = unproxy(self.proxy)
|
|
try:
|
|
attr = getattr(proxy, self.attr)
|
|
except AttributeError, e:
|
|
raise ProxyError, e
|
|
return unproxy(attr)
|
|
|
|
def __str__(self):
|
|
return '%s.%s' % (self.proxy, self.attr)
|
|
|
|
class ProxyGroup(object):
|
|
def __init__(self, dict=None, **kwargs):
|
|
self.__dict__['dict'] = {}
|
|
|
|
if dict is not None:
|
|
self.dict.update(dict)
|
|
|
|
if kwargs:
|
|
self.dict.update(kwargs)
|
|
|
|
def __getattr__(self, name):
|
|
return Proxy(name, self.dict)
|
|
|
|
def __setattr__(self, attr, value):
|
|
self.dict[attr] = value
|
|
|
|
class ScalarStat(Statistic,Scalar):
|
|
def __value__(self, run):
|
|
if run not in self.data:
|
|
return None
|
|
return self.data[run][0][0]
|
|
|
|
def display(self, run=None):
|
|
import display
|
|
p = display.Print()
|
|
p.name = self.name
|
|
p.desc = self.desc
|
|
p.value = value(self, run)
|
|
p.flags = self.flags
|
|
p.precision = self.precision
|
|
if display.all or (self.flags & flags.printable):
|
|
p.display()
|
|
|
|
class VectorStat(Statistic,Vector):
|
|
def __value__(self, run, item):
|
|
if run not in self.data:
|
|
return None
|
|
return self.data[run][item][0]
|
|
|
|
def __len__(self):
|
|
return self.x
|
|
|
|
def display(self, run=None):
|
|
import display
|
|
d = display.VectorDisplay()
|
|
d.name = self.name
|
|
d.desc = self.desc
|
|
d.value = [ value(self, run, i) for i in xrange(len(self)) ]
|
|
d.flags = self.flags
|
|
d.precision = self.precision
|
|
d.display()
|
|
|
|
class Formula(Value):
|
|
def __getattribute__(self, attr):
|
|
if attr not in ( '__scalar__', '__vector__', '__value__', '__len__' ):
|
|
return super(Formula, self).__getattribute__(attr)
|
|
|
|
formula = re.sub(':', '__', self.formula)
|
|
value = eval(formula, self.source.stattop)
|
|
return getattr(value, attr)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
class SimpleDist(Statistic):
|
|
def __init__(self, sums, squares, samples):
|
|
self.sums = sums
|
|
self.squares = squares
|
|
self.samples = samples
|
|
|
|
def display(self, name, desc, flags, precision):
|
|
import display
|
|
p = display.Print()
|
|
p.flags = flags
|
|
p.precision = precision
|
|
|
|
if self.samples > 0:
|
|
p.name = name + ".mean"
|
|
p.value = self.sums / self.samples
|
|
p.display()
|
|
|
|
p.name = name + ".stdev"
|
|
if self.samples > 1:
|
|
var = (self.samples * self.squares - self.sums ** 2) \
|
|
/ (self.samples * (self.samples - 1))
|
|
if var >= 0:
|
|
p.value = math.sqrt(var)
|
|
else:
|
|
p.value = 'NaN'
|
|
else:
|
|
p.value = 0.0
|
|
p.display()
|
|
|
|
p.name = name + ".samples"
|
|
p.value = self.samples
|
|
p.display()
|
|
|
|
def comparable(self, other):
|
|
return True
|
|
|
|
def __eq__(self, other):
|
|
return self.sums == other.sums and self.squares == other.squares and \
|
|
self.samples == other.samples
|
|
|
|
def __isub__(self, other):
|
|
self.sums -= other.sums
|
|
self.squares -= other.squares
|
|
self.samples -= other.samples
|
|
return self
|
|
|
|
def __iadd__(self, other):
|
|
self.sums += other.sums
|
|
self.squares += other.squares
|
|
self.samples += other.samples
|
|
return self
|
|
|
|
def __itruediv__(self, other):
|
|
if not other:
|
|
return self
|
|
self.sums /= other
|
|
self.squares /= other
|
|
self.samples /= other
|
|
return self
|
|
|
|
class FullDist(SimpleDist):
|
|
def __init__(self, sums, squares, samples, minval, maxval,
|
|
under, vec, over, min, max, bsize, size):
|
|
self.sums = sums
|
|
self.squares = squares
|
|
self.samples = samples
|
|
self.minval = minval
|
|
self.maxval = maxval
|
|
self.under = under
|
|
self.vec = vec
|
|
self.over = over
|
|
self.min = min
|
|
self.max = max
|
|
self.bsize = bsize
|
|
self.size = size
|
|
|
|
def display(self, name, desc, flags, precision):
|
|
import display
|
|
p = display.Print()
|
|
p.flags = flags
|
|
p.precision = precision
|
|
|
|
p.name = name + '.min_val'
|
|
p.value = self.minval
|
|
p.display()
|
|
|
|
p.name = name + '.max_val'
|
|
p.value = self.maxval
|
|
p.display()
|
|
|
|
p.name = name + '.underflow'
|
|
p.value = self.under
|
|
p.display()
|
|
|
|
i = self.min
|
|
for val in self.vec[:-1]:
|
|
p.name = name + '[%d:%d]' % (i, i + self.bsize - 1)
|
|
p.value = val
|
|
p.display()
|
|
i += self.bsize
|
|
|
|
p.name = name + '[%d:%d]' % (i, self.max)
|
|
p.value = self.vec[-1]
|
|
p.display()
|
|
|
|
|
|
p.name = name + '.overflow'
|
|
p.value = self.over
|
|
p.display()
|
|
|
|
SimpleDist.display(self, name, desc, flags, precision)
|
|
|
|
def comparable(self, other):
|
|
return self.min == other.min and self.max == other.max and \
|
|
self.bsize == other.bsize and self.size == other.size
|
|
|
|
def __eq__(self, other):
|
|
return self.sums == other.sums and self.squares == other.squares and \
|
|
self.samples == other.samples
|
|
|
|
def __isub__(self, other):
|
|
self.sums -= other.sums
|
|
self.squares -= other.squares
|
|
self.samples -= other.samples
|
|
|
|
if other.samples:
|
|
self.minval = min(self.minval, other.minval)
|
|
self.maxval = max(self.maxval, other.maxval)
|
|
self.under -= under
|
|
self.vec = map(lambda x,y: x - y, self.vec, other.vec)
|
|
self.over -= over
|
|
return self
|
|
|
|
def __iadd__(self, other):
|
|
if not self.samples and other.samples:
|
|
self = other
|
|
return self
|
|
|
|
self.sums += other.sums
|
|
self.squares += other.squares
|
|
self.samples += other.samples
|
|
|
|
if other.samples:
|
|
self.minval = min(self.minval, other.minval)
|
|
self.maxval = max(self.maxval, other.maxval)
|
|
self.under += other.under
|
|
self.vec = map(lambda x,y: x + y, self.vec, other.vec)
|
|
self.over += other.over
|
|
return self
|
|
|
|
def __itruediv__(self, other):
|
|
if not other:
|
|
return self
|
|
self.sums /= other
|
|
self.squares /= other
|
|
self.samples /= other
|
|
|
|
if self.samples:
|
|
self.under /= other
|
|
for i in xrange(len(self.vec)):
|
|
self.vec[i] /= other
|
|
self.over /= other
|
|
return self
|
|
|
|
class Dist(Statistic):
|
|
def display(self):
|
|
import display
|
|
if not display.all and not (self.flags & flags.printable):
|
|
return
|
|
|
|
self.dist.display(self.name, self.desc, self.flags, self.precision)
|
|
|
|
def comparable(self, other):
|
|
return self.name == other.name and \
|
|
self.dist.compareable(other.dist)
|
|
|
|
def __eq__(self, other):
|
|
return self.dist == other.dist
|
|
|
|
def __isub__(self, other):
|
|
self.dist -= other.dist
|
|
return self
|
|
|
|
def __iadd__(self, other):
|
|
self.dist += other.dist
|
|
return self
|
|
|
|
def __itruediv__(self, other):
|
|
if not other:
|
|
return self
|
|
self.dist /= other
|
|
return self
|
|
|
|
class VectorDist(Statistic):
|
|
def display(self):
|
|
import display
|
|
if not display.all and not (self.flags & flags.printable):
|
|
return
|
|
|
|
if isinstance(self.dist, SimpleDist):
|
|
return
|
|
|
|
for dist,sn,sd,i in map(None, self.dist, self.subnames, self.subdescs,
|
|
range(len(self.dist))):
|
|
if len(sn) > 0:
|
|
name = '%s.%s' % (self.name, sn)
|
|
else:
|
|
name = '%s[%d]' % (self.name, i)
|
|
|
|
if len(sd) > 0:
|
|
desc = sd
|
|
else:
|
|
desc = self.desc
|
|
|
|
dist.display(name, desc, self.flags, self.precision)
|
|
|
|
if (self.flags & flags.total) or 1:
|
|
if isinstance(self.dist[0], SimpleDist):
|
|
disttotal = SimpleDist( \
|
|
reduce(sums, [d.sums for d in self.dist]),
|
|
reduce(sums, [d.squares for d in self.dist]),
|
|
reduce(sums, [d.samples for d in self.dist]))
|
|
else:
|
|
disttotal = FullDist( \
|
|
reduce(sums, [d.sums for d in self.dist]),
|
|
reduce(sums, [d.squares for d in self.dist]),
|
|
reduce(sums, [d.samples for d in self.dist]),
|
|
min([d.minval for d in self.dist]),
|
|
max([d.maxval for d in self.dist]),
|
|
reduce(sums, [d.under for d in self.dist]),
|
|
reduce(sums, [d.vec for d in self.dist]),
|
|
reduce(sums, [d.over for d in self.dist]),
|
|
dist[0].min,
|
|
dist[0].max,
|
|
dist[0].bsize,
|
|
dist[0].size)
|
|
|
|
name = '%s.total' % (self.name)
|
|
desc = self.desc
|
|
disttotal.display(name, desc, self.flags, self.precision)
|
|
|
|
def comparable(self, other):
|
|
return self.name == other.name and \
|
|
alltrue(map(lambda x, y : x.comparable(y),
|
|
self.dist,
|
|
other.dist))
|
|
|
|
def __eq__(self, other):
|
|
return alltrue(map(lambda x, y : x == y, self.dist, other.dist))
|
|
|
|
def __isub__(self, other):
|
|
if isinstance(self.dist, (list, tuple)) and \
|
|
isinstance(other.dist, (list, tuple)):
|
|
for sd,od in zip(self.dist, other.dist):
|
|
sd -= od
|
|
else:
|
|
self.dist -= other.dist
|
|
return self
|
|
|
|
def __iadd__(self, other):
|
|
if isinstance(self.dist, (list, tuple)) and \
|
|
isinstance(other.dist, (list, tuple)):
|
|
for sd,od in zip(self.dist, other.dist):
|
|
sd += od
|
|
else:
|
|
self.dist += other.dist
|
|
return self
|
|
|
|
def __itruediv__(self, other):
|
|
if not other:
|
|
return self
|
|
if isinstance(self.dist, (list, tuple)):
|
|
for dist in self.dist:
|
|
dist /= other
|
|
else:
|
|
self.dist /= other
|
|
return self
|
|
|
|
class Vector2d(Statistic):
|
|
def display(self):
|
|
import display
|
|
if not display.all and not (self.flags & flags.printable):
|
|
return
|
|
|
|
d = display.VectorDisplay()
|
|
d.__dict__.update(self.__dict__)
|
|
|
|
if self.__dict__.has_key('ysubnames'):
|
|
ysubnames = list(self.ysubnames)
|
|
slack = self.x - len(ysubnames)
|
|
if slack > 0:
|
|
ysubnames.extend(['']*slack)
|
|
else:
|
|
ysubnames = range(self.x)
|
|
|
|
for x,sname in enumerate(ysubnames):
|
|
o = x * self.y
|
|
d.value = self.value[o:o+self.y]
|
|
d.name = '%s[%s]' % (self.name, sname)
|
|
d.display()
|
|
|
|
if self.flags & flags.total:
|
|
d.value = []
|
|
for y in range(self.y):
|
|
xtot = 0.0
|
|
for x in range(self.x):
|
|
xtot += self.value[y + x * self.x]
|
|
d.value.append(xtot)
|
|
|
|
d.name = self.name + '.total'
|
|
d.display()
|
|
|
|
def comparable(self, other):
|
|
return self.name == other.name and self.x == other.x and \
|
|
self.y == other.y
|
|
|
|
def __eq__(self, other):
|
|
return True
|
|
|
|
def __isub__(self, other):
|
|
return self
|
|
|
|
def __iadd__(self, other):
|
|
return self
|
|
|
|
def __itruediv__(self, other):
|
|
if not other:
|
|
return self
|
|
return self
|
|
|
|
def NewStat(source, data):
|
|
stat = None
|
|
if data.type == 'SCALAR':
|
|
stat = ScalarStat()
|
|
elif data.type == 'VECTOR':
|
|
stat = VectorStat()
|
|
elif data.type == 'DIST':
|
|
stat = Dist()
|
|
elif data.type == 'VECTORDIST':
|
|
stat = VectorDist()
|
|
elif data.type == 'VECTOR2D':
|
|
stat = Vector2d()
|
|
elif data.type == 'FORMULA':
|
|
stat = Formula()
|
|
|
|
stat.__dict__['source'] = source
|
|
stat.__dict__['ticks'] = None
|
|
stat.__dict__.update(data.__dict__)
|
|
|
|
return stat
|
|
|