def test_ave_add(self):
c1 = Average('c1')
c1.add(0, 1)
c2 = Average('c2')
c2.add(1, 3)
c3 = c1 + c2
ave, unc = c3.average()
self.assertEqual(ave, 0.75)
def test_ave_unw(self):
c = Average('TestAve')
c.add( 1, 1 )
c.add( 2, 1 )
ave, unc = c.average()
self.assertEqual(ave, 1.5)
self.assertAlmostEqual(unc, 0.35, 1)
def test_ave_wei(self):
c = Average('TestAve')
c.add( 0, 1 )
c.add( 1, 3 )
ave, unc = c.average()
self.assertEqual(ave, 0.75)
self.assertAlmostEqual(unc, 0.22, 1)
def average():
form1 = Average()
form2 = Graph()
if request.method == 'GET':
return render_template('base.html',
form1=form1,
form2=form2,
ch='First')
elif request.method == 'POST':
if request.form['submit'] == 'PlotTheGraph':
class Interpolate:
S, Q, R = [], [], []
# for finding limits, polynomials
x = sp.Symbol('x')
def Lag_Poly(self, L, M):
# X for storing x coordinates
# Y for storing f(x)
self.Q, self.R = L, M
for i in range(len(L)):
u, j = 1, 0
# forming list of polynomials
# summation of which is Lagrange Polynomial
while j < len(L):
if i != j:
u *= (self.x - L[j]) / (L[i] - L[j])
j += 1
u *= M[i]
self.S.append(u)
# plot Lagrange Polynomial
self.plot_Poly()
def plot_Poly(self, var=[]):
a = np.arange(0, max(self.Q) + 0.2, 0.1)
pol_sum = 0
# plot function in the list
for i in self.S:
pol_sum += i
for j in a:
var.append(sp.limit(i, self.x, j))
plt.plot(a, var)
var = []
# plot Lagrange Polynomial in Black Color
for j in a:
var.append(sp.limit(pol_sum, self.x, j))
plt.plot(a, var, 'k')
# plot node points
plt.plot(self.Q, self.R, 'ro')
plt.title('INTERPOLATING POLYNOMIAL IS BLACK')
plt.xlabel('X-AXIS')
plt.ylabel('Y-AXIS')
plt.savefig('C:\Users\hp\Desktop\NA\static\img\graph.png')
plt.clf()
ob = Interpolate()
x = form2.x_cor.data
y = form2.y_cor.data
L = [float(i) for i in x.split(' ')]
R = [float(i) for i in y.split(' ')]
ob.Lag_Poly(L, R)
return render_template('base.html',
form1=form1,
form2=form2,
ch='Second')
else:
num = form1.message.data
num, sum = num.split(' '), 0
for i in num:
sum += float(i)
return render_template('base.html',
form1=form1,
form2=form2,
avg=(sum * 1.0) / len(num),
ch='Third')
def test_arrayNumbers_elementos_1(self):
self.assertEqual(Average().arrayNumbers("32")[0], 1, "Elementos cadena 1")
def test_arrayNumbers_average_n(self):
self.assertEqual(Average().arrayNumbers("3, 9, 3, 9")[3], 6, "Promedio cadena 2")
def test_arrayNumbers_average_1(self):
self.assertEqual(Average().arrayNumbers("3")[3], 3, "Promedio cadena 1")
def test_arrayNumbers_average_vacio(self):
self.assertEqual(Average().arrayNumbers("")[3], None, "Promedio cadena vacia")
def test_arrayNumbers_elementos_vacio(self):
self.assertEqual(Average().arrayNumbers("")[0], 0, "Elementos cadena vacia")
def test_arrayNumbers_elementos_n(self):
self.assertEqual(Average().arrayNumbers("233, 232,23,23,2,2,2,432, 466,6")[0], 10, "Elementos cadena n")
ch.setFormatter(logging.Formatter('%(asctime)s: %(levelname)s: %(message)s'))
logger.addHandler(ch)
logger.info('Startup')
signals_handler = signals_handler(messageboard)
with Display(), \
Sensor(), \
Status(), \
HtmlWriter(), \
Fan(), \
Menu(), \
Devices(), \
DCF77(), \
Average(), \
RestartWLAN(), \
CheckNetwork():
time0 = Uptime()
while messageboard.query('ExitThread') is None:
exception = messageboard.query('Exception')
if exception is not None:
raise exception
messageboard.post('Time', (Uptime(), time.localtime()))
time1 = Uptime()
if not time1 >= time0:
logger.warning('Error in uptime: {} < {}.'.format(time1, time0))
time0 = time1
sleeptime = 1 - time1 + time0
if sleeptime <= 0:
logger.warning(u'Zero sleep time: {} < {}, Δ={:.1f}s.'.format(
def test_arrayNumbers_max_1(self):
self.assertEqual(Average().arrayNumbers("3")[2], 3, "Maximo cadena 1")
def test_arrayNumbers_max_vacio(self):
self.assertEqual(Average().arrayNumbers("")[2], None, "Maximo cadena vacia")
def test_arrayNumbers_min_n(self):
self.assertEqual(Average().arrayNumbers("1, 434,32,32,32,32,3,4")[1], 1, "Minimo cadena n")
def test_arrayNumbers_min_2(self):
self.assertEqual(Average().arrayNumbers("1, 434")[1], 1, "Minimo cadena 2")
def test_arrayNumbers_min_1(self):
self.assertEqual(Average().arrayNumbers("32")[1], 32, "Minimo cadena 1")
def test_arrayNumbers_min_vacio(self):
self.assertEqual(Average().arrayNumbers("")[1], None, "Minimo cadena vacia")
all_dataset.drop(labels=['V5', 'V17', 'V22'], axis=1, inplace=True)
all_dataset['V0'] = all_dataset['V0'].apply(lambda x: math.exp(x))
all_dataset['V1'] = all_dataset['V1'].apply(lambda x: math.exp(x))
all_dataset['V6'] = all_dataset['V6'].apply(lambda x: math.exp(x))
all_dataset['V7'] = all_dataset['V7'].apply(lambda x: math.exp(x))
all_dataset['V8'] = all_dataset['V8'].apply(lambda x: math.exp(x))
all_dataset['V30'] = np.log1p(all_dataset["V30"])
all_dataset = pd.DataFrame(preprocessing.scale(all_dataset), columns=all_dataset.columns)
X_train = all_dataset[0:len(train_dataset)].values
X_test = all_dataset[len(train_dataset):].values
y_train = train_labels.values
model.fit(X_train, y_train)
model.get_submission(X_test)
if __name__ == "__main__":
from average import Average
from lgb import LGB_Model
from etr import ETR_Model
from huber import Huber_Model
model_list = [('LGB', LGB_Model()), ('ETR', ETR_Model()), ('HUBER', Huber_Model())]
ave = Average(model_list)
train_eval(ave)
generate_submission(ave)
def test_arrayNumbers_max_2(self):
self.assertEqual(Average().arrayNumbers("3, 323")[2], 323, "Maximo cadena 2")
def test_arrayNumbers_elementos_2(self):
self.assertEqual(Average().arrayNumbers("233, 232")[0], 2, "Elementos cadena 2")
#!/usr/bin/python
import random
from event import Event
from average import Average
e = Event()
a = Average()
def add_random_sample_delegate(x):
a.add_sample(x + 10 * (-.5 + random.random()))
def add_sample_delegate(x):
a.add_sample(x)
e.add_event_listener(add_sample_delegate)
e.add_event_listener(add_random_sample_delegate)
e.add_event(2)
e.add_event(200)
print a.calculate()
def test_arrayNumbers_max_n(self):
self.assertEqual(Average().arrayNumbers("3, 323, 232,2 ,2,2,3 ,4")[2], 323, "Maximo cadena n")
