def create_profile(time, rate_constants):
""" Computes a concentration profile according to the *model()* function.
Parameters
----------
time : np.array
Time array.
rate_constants : RateConstants
RateConstants object.
Returns
-------
profile : np.array
Concentration profile matrix.
"""
ks = rate_constants.ks
alphas = rate_constants.alphas
if rate_constants.style == 'dec':
s0 = np.ones(ks.shape[0])
elif rate_constants.style == 'custom':
s0 = np.zeros(ks.shape)
for i in range(s0.shape[1]):
s0[0, i] = alphas[i]
s0 = s0.flatten('F')
else:
# assuming a starting population of 100% for the first species
s0 = np.zeros(ks.shape[0])
s0[0] = 1
time = time.reshape(-1)
# sometimes odeint encounters an overflow
errs = scsp.geterr()
errs['overflow'] = 'ignore'
scsp.seterr(**errs)
profile = odeint(model, s0, time, (rate_constants, ))
errs['overflow'] = 'warn'
scsp.seterr(**errs)
if rate_constants.style == 'custom':
profile = np.split(profile, ks.shape[1], axis=1)
profile = np.sum(profile, axis=0)
return profile
def test_seterr():
entry_err = sc.geterr()
try:
for category, error_code in _sf_error_code_map.items():
for action in _sf_error_actions:
geterr_olderr = sc.geterr()
seterr_olderr = sc.seterr(**{category: action})
assert_(geterr_olderr == seterr_olderr)
newerr = sc.geterr()
assert_(newerr[category] == action)
geterr_olderr.pop(category)
newerr.pop(category)
assert_(geterr_olderr == newerr)
_check_action(_sf_error_test_function, (error_code, ), action)
finally:
sc.seterr(**entry_err)
def test_seterr():
entry_err = sc.geterr()
try:
for category in _sf_error_code_map.keys():
for action in _sf_error_actions:
geterr_olderr = sc.geterr()
seterr_olderr = sc.seterr(**{category: action})
assert_(geterr_olderr == seterr_olderr)
newerr = sc.geterr()
assert_(newerr[category] == action)
geterr_olderr.pop(category)
newerr.pop(category)
assert_(geterr_olderr == newerr)
_check_action(_sf_error_test_function,
(_sf_error_code_map[category],),
action)
finally:
sc.seterr(**entry_err)
from sys import stdout
import numpy as np
import matplotlib.pyplot as plt
from scipy import integrate
from scipy import special
from cmath import *
from scipy.stats import qmc
import os
os.environ['NUMBAPRO_CUDALIB']='C:/Users/gueux/Miniconda3/envs/py36_7/Library/bin'
np.seterr(all='raise')
special.seterr(all='raise')
sobol_set = True
#sobol_set = False
# f-function related
def fp(e,p,ab,s1=0.76,s2=0.1821):
if e == 0:
#print('e -> 0, return value -> inf')
#return inf
return 0
else:
exponent = 2*s2/(np.power(e/ab,s1) + np.power(e/ab,-s1))
base = 1/np.cosh(p)
return np.power(base, exponent)
def fpp(e,p,ab,s1=0.76,s2=0.1821):
if p == 0:
return 0
else:
return fp(e,p,ab,s1,s2)*p
from numpy.linalg import norm, inv, det, matrix_power
from numpy.random import randn, randint, uniform
from math import pi, sqrt, atan2, sin, cos, floor
from controlpy.synthesis import controller_lqr_discrete_time as dlqr
import gurobipy as gp
from gurobipy import *
import scipy.sparse as sp
from scipy.linalg import block_diag
import matplotlib.pyplot as plt
from pytope import Polytope
from pytope.polytope import intersection, minkowski_sum
import multiprocessing
import scipy.special as sc
sc.seterr(all='ignore')
def DefineStabilizingController(A, B, Q, R):
# UNTITLED2 Summary of this function goes here
# Detailed explanation goes here
Ks, _, _ = dlqr(A, B, Q, R)
Ks = -Ks
Ke, _, _ = dlqr(A, B, Q, R)
Ke = -Ke
return Ks, Ke
def SpectralClustering(ck_sym, sc, options, rep_factor=100 ):
# np.set_printoptions(threshold=np.nan)
np.seterr(all='raise')
sc_special.seterr(all='raise')
check_point = time()
nn = ck_sym.shape[0]
dn = lil_matrix((nn, nn))
sum_ck = np.array(np.sqrt(np.sum(ck_sym, axis=0))[0])
# check for equality of results of different data types(matrix and array)
# a = np.array(ck_sym.todense()) # make sure that we have dense np.array
# b = np.sqrt(np.sum(a, axis=0))
# print(np.allclose(b, sum_ck, rtol=1e-16, atol=1e-15))
try:
dn.setdiag(1.0 / np.array(sum_ck)[0])
except (ZeroDivisionError, FloatingPointError):
print('Avoiding division by zero in dn.diag by adding eps(long double)')
sum_ck = np.array(sum_ck, dtype=np.longdouble)
eps = np.finfo(np.longdouble).eps
dn.setdiag(1.0 / (np.array(sum_ck)[0] + eps))
dn = dn.tocsc()
del sum_ck
if options['verbose'] > 1:
print('Starting eigen decomposition')
if options['spectral_eig_algo'] == 1:
lap_n = dn * ck_sym * dn # moved to matrix notation
ut, s, vn = svds(lap_n, options['n_clusters'], which='LM', ncv=min(5*options['n_clusters'] + 1, nn//2 + 1))
for i in range(options['n_clusters']):
if(s.imag.any() != 0):
print(i)
kern = np.fliplr(vn).T
elif options['spectral_eig_algo'] == 2: # LOOKS LIKE THIS PACKAGE IS OUTDATED AND PRODUCES WRONG RESULTS.
# Latest tested(successfully) python version for it is 3.2
sp_d_n = dn
# sp_d_n = sparse.csc_matrix(dn)
lap_n = sp_d_n.dot(sparse.csc_matrix(ck_sym)).dot(sp_d_n)
ut, s, vn = sparsesvd(lap_n, options['n_clusters'])
kern = vn.T
if len(s) < options['n_clusters']:
sp_d_n = sparse.csc_matrix(dn)
lap_n = sp_d_n.dot(sparse.csc_matrix(ck_sym)).dot(sp_d_n)
one, two, vn = svds(lap_n, options['n_clusters'], which='LM', ncv=100)
kern = vn[::-1].T
elif options['spectral_eig_algo'] == 3: # very slow, but always correct
# LapN = np.identity(nn) - np.dot(np.dot(DN, CKSym), DN)
dn = dn.todense()
lap_n = np.dot(np.dot(dn, ck_sym), dn)
ut, s, vn = linalg.svd(lap_n, full_matrices=True, lapack_driver='gesvd')
kern = vn[0:options['n_clusters']].T
else:
# **** BEGIN NON-SPARSE SVD *****
# LapN = np.identity(nn) - np.dot(np.dot(DN, CKSym), DN)
dn = dn.todense()
lap_n = np.dot(np.dot(dn, ck_sym), dn)
one, two, vn = np.linalg.svd(lap_n, full_matrices=True) # returns U, s, vN
kern = vn[0:options['n_clusters']].T
# **** END NON-SPARSE SVD *****
if options['verbose'] > 1:
print('Done with eigen decomposition')
del dn, ck_sym, lap_n, vn
kern = np.array(kern, dtype=np.longdouble)
norm_n = norm(kern, axis=1) # FloatingPointError: underflow encountered in multiply in RMS data
# https: // docs.scipy.org / doc / numpy / reference / generated / numpy.apply_along_axis.html
try:
kern_s = np.apply_along_axis(lambda a, b: a / b, 0, kern, norm_n)
except (ZeroDivisionError, FloatingPointError):
print('Avoiding division by zero in kern_norm by adding eps(long double)')
eps = np.finfo(np.longdouble).eps
kern_s = np.apply_along_axis(lambda a, b: a / b, 0, kern, norm_n + eps)
# kerNS = np.array(kerNS, dtype=np.float64)
# if sum(sum(abs(kern_s.imag))) > 0:
# print('Imaginary numbers in Laplasians,')
# kern_s = kern_s.real
# exit(-5)
check_point = log_print(check_point, options['verbose'], '%s Eigen decomposition time : ' % options['times'])
total_batch_size = 200*cpu_count()
if options['verbose'] > 1:
print('Starting K-means algorithm')
if options['kmeans_minibatch']:
groups = MiniBatchKMeans(n_clusters=options['n_clusters'], tol=1e-7, max_no_improvement=20, batch_size=total_batch_size,
n_jobs=cpu_count()).fit_predict(kern_s)
bestGroups = groups
nmi_batch = []
iter_counter = total_batch_size
else:
bestNMI, bestGroups, nmi_batch, iter_counter = simple_kmeans_par(kern_s, sc, options)
if options['verbose'] > 1:
print('Done with K-means algorithm')
# import seaborn as sns
# sns.set_style('whitegrid')
# sns.kdeplot(NMI_batch, bw=0.000000001)
# sns.kdeplot(NMI_batch)
# max1 = NMI_batch.max()
# min1 = NMI_batch.min()
bestGroups += 1 # add 1 to all elements since bestMap and further processing requires 1 as minimum index
check_point = log_print(check_point, options['verbose'], '%s Kmeans(with NMI) time : ' % options['times'])
return bestGroups, nmi_batch, iter_counter
################################################################################ # lib.py contained all the function needed to run Analytic_filtering, # Filtering_function, Histogram_computation, Test_distribution & Test_parralel # # Contact : Sullivan MARAFICO [email protected] ################################################################################ import numpy as np import matplotlib.pyplot as plt import time from scipy import special, interpolate, integrate, misc, stats from threading import Thread import multiprocessing as mp Nlim = -4. # log_lambda minimum for computing the histogram (if too small, computations can fail) special.seterr(all="ignore") def TestPDF(total, precision): '''Test if total(sum of PDF) is smaller or bigger than 1 +- 2*precision If yes, it shows a warning with the values of total''' if total < 1 - 2 * precision: print( "/!\ WARNING : Sum of probabilities < 1-2*precision (cf. TestPDF)") print("/!\ 1-precision = " + str(1 - precision) + " | Sum = " + str(total)) return False if total > 1 + 2 * precision: print("/!\ WARNING : Sum of probabilities > 1 (cf. TestPDF)")
from scipy.optimize import linprog
import numpy as np
import pandas as pd
from scipy import stats
import scipy.special as sc
sc.seterr(all="ignore") # TODO: suppress ALL warnings
def init_alpha(budget, n_treatments):
alpha = np.random.uniform(-budget, 0, size=None)
return alpha
def init_beta(budget, n_treatments):
beta = np.random.uniform(-budget, budget, size=n_treatments)
return beta
# Output dimensions: (n_subjects, n_treatments)
def get_price_matrix(alpha, beta, pte_matrix):
price_matrix = alpha * pte_matrix + beta
return price_matrix
# Solve linear programming problem to get utility-maximizing demands. Dimensions: (n_subjects, n_treatments)
def get_demand_matrix(wtp_matrix, pte_matrix, price_matrix, subject_budgets,
rct_treatment_probabilities, epsilon):
# Create empty matrix for filling
demand_matrix = []
# Solve problem for each individual
import numpy as np
import math
from scipy.optimize import curve_fit
from scipy.special import erf, seterr
from scipy.stats import kurtosis, skew
from astropy.modeling import models, fitting
import scipy.integrate as integrate
import warnings
from utils.run_functions import psnr, brightness_error
from utils.run_functions import rms
from utils.structures import DatabaseItem
seterr(all='ignore') # suppress fitting errors
warnings.simplefilter("ignore") # suppress fitting warnings
class PointCluster(object):
''' Object representing single cluster of pixels, fits functions as well as produces output for object '''
def __init__(self, points, image):
self.points = points
self.correct_fit = False
self.peak_point = None
self.header_data = None
self.background_data = None
self.squared_data = None
self.image = image
self.kurtosis = None
self.skew = None
self.psnr = None
self.show_object_fit = False
nd = args.nd
na = args.na
filebase = args.filebase
output = args.output
quasi = args.quasi
integ = args.integ
rank = args.rank
seed = args.seed
dep = args.dep
skip = args.skip
d0 = args.d0
d1min = 1
d1max = args.dmax
np.random.seed(seed)
np.seterr(all='ignore')
seterr(all='ignore')
#We should find the lcc of the network and discard the rest.
start = timeit.default_timer()
eta, nu, k, G = get_network(n, nr, na)
if args.type == 0:
row, col = np.where(eta[::2] - nu[::2] != 0)
data = (eta[::2] - nu[::2])[row, col]
A = csr_matrix((data, (row, col)), shape=(2 * nr, n), dtype=int)
adj = A.T.dot(A)
g = nx.convert_matrix.from_scipy_sparse_matrix(adj)
if args.type == 1:
g = nx.gnm_random_graph(n, nr, seed=seed)
adj = nx.adjacency_matrix(g)