def prep_model(prices):
dataset = prices.values
X = dataset[:, 1].reshape(-1, 1)
Y = ravel(dataset[:, 0:1]) # Ravel changes it from vector to 1D array
validation_size = 0.15
seed = 7
X_train, X_validation, Y_train, Y_validation = train_test_split(
X, Y, test_size=validation_size, random_state=seed)
return X, Y, X_train, X_validation, Y_train, Y_validation
def lstsq(a, b, rcond=-1):
"""
Return the least-squares solution to an equation.
Solves the equation `a x = b` by computing a vector `x` that minimizes
the norm `|| b - a x ||`.
Parameters
----------
a : array_like, shape (M, N)
Input equation coefficients.
b : array_like, shape (M,) or (M, K)
Equation target values. If `b` is two-dimensional, the least
squares solution is calculated for each of the `K` target sets.
rcond : float, optional
Cutoff for ``small`` singular values of `a`.
Singular values smaller than `rcond` times the largest singular
value are considered zero.
Returns
-------
x : ndarray, shape(N,) or (N, K)
Least squares solution. The shape of `x` depends on the shape of
`b`.
residues : ndarray, shape(), (1,), or (K,)
Sums of residues; squared Euclidian norm for each column in
`b - a x`.
If the rank of `a` is < N or > M, this is an empty array.
If `b` is 1-dimensional, this is a (1,) shape array.
Otherwise the shape is (K,).
rank : integer
Rank of matrix `a`.
s : ndarray, shape(min(M,N),)
Singular values of `a`.
Raises
------
LinAlgError
If computation does not converge.
Notes
-----
If `b` is a matrix, then all array results returned as
matrices.
Examples
--------
Fit a line, ``y = mx + c``, through some noisy data-points:
>>> x = np.array([0, 1, 2, 3])
>>> y = np.array([-1, 0.2, 0.9, 2.1])
By examining the coefficients, we see that the line should have a
gradient of roughly 1 and cuts the y-axis at more-or-less -1.
We can rewrite the line equation as ``y = Ap``, where ``A = [[x 1]]``
and ``p = [[m], [c]]``. Now use `lstsq` to solve for `p`:
>>> A = np.vstack([x, np.ones(len(x))]).T
>>> A
array([[ 0., 1.],
[ 1., 1.],
[ 2., 1.],
[ 3., 1.]])
>>> m, c = np.linalg.lstsq(A, y)[0]
>>> print m, c
1.0 -0.95
Plot the data along with the fitted line:
>>> import matplotlib.pyplot as plt
>>> plt.plot(x, y, 'o', label='Original data', markersize=10)
>>> plt.plot(x, m*x + c, 'r', label='Fitted line')
>>> plt.legend()
>>> plt.show()
"""
import math
a, _ = _makearray(a)
b, wrap = _makearray(b)
is_1d = len(b.shape) == 1
if is_1d:
b = b[:, newaxis]
_assertRank2(a, b)
m = a.shape[0]
n = a.shape[1]
n_rhs = b.shape[1]
ldb = max(n, m)
if m != b.shape[0]:
raise LinAlgError, 'Incompatible dimensions'
t, result_t = _commonType(a, b)
real_t = _linalgRealType(t)
bstar = zeros((ldb, n_rhs), t)
bstar[:b.shape[0],:n_rhs] = b.copy()
a, bstar = _fastCopyAndTranspose(t, a, bstar)
s = zeros((min(m, n),), real_t)
nlvl = max( 0, int( math.log( float(min(m, n))/2. ) ) + 1 )
iwork = zeros((3*min(m, n)*nlvl+11*min(m, n),), fortran_int)
if isComplexType(t):
lapack_routine = lapack_lite.zgelsd
lwork = 1
rwork = zeros((lwork,), real_t)
work = zeros((lwork,), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, -1, rwork, iwork, 0)
lwork = int(abs(work[0]))
rwork = zeros((lwork,), real_t)
a_real = zeros((m, n), real_t)
bstar_real = zeros((ldb, n_rhs,), real_t)
results = lapack_lite.dgelsd(m, n, n_rhs, a_real, m,
bstar_real, ldb, s, rcond,
0, rwork, -1, iwork, 0)
lrwork = int(rwork[0])
work = zeros((lwork,), t)
rwork = zeros((lrwork,), real_t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, lwork, rwork, iwork, 0)
else:
lapack_routine = lapack_lite.dgelsd
lwork = 1
work = zeros((lwork,), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, -1, iwork, 0)
lwork = int(work[0])
work = zeros((lwork,), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, lwork, iwork, 0)
if results['info'] > 0:
raise LinAlgError, 'SVD did not converge in Linear Least Squares'
resids = array([], t)
if is_1d:
x = array(ravel(bstar)[:n], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = array([sum((ravel(bstar)[n:])**2)], dtype=result_t)
else:
x = array(transpose(bstar)[:n,:], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = sum((transpose(bstar)[n:,:])**2, axis=0).astype(result_t)
st = s[:min(n, m)].copy().astype(_realType(result_t))
return wrap(x), wrap(resids), results['rank'], st
def lstsq(a, b, rcond=-1):
"""
Return the least-squares solution to an equation.
Solves the equation `a x = b` by computing a vector `x` that minimizes
the norm `|| b - a x ||`.
Parameters
----------
a : array_like, shape (M, N)
Input equation coefficients.
b : array_like, shape (M,) or (M, K)
Equation target values. If `b` is two-dimensional, the least
squares solution is calculated for each of the `K` target sets.
rcond : float, optional
Cutoff for ``small`` singular values of `a`.
Singular values smaller than `rcond` times the largest singular
value are considered zero.
Returns
-------
x : ndarray, shape(N,) or (N, K)
Least squares solution. The shape of `x` depends on the shape of
`b`.
residues : ndarray, shape(), (1,), or (K,)
Sums of residues; squared Euclidian norm for each column in
`b - a x`.
If the rank of `a` is < N or > M, this is an empty array.
If `b` is 1-dimensional, this is a (1,) shape array.
Otherwise the shape is (K,).
rank : integer
Rank of matrix `a`.
s : ndarray, shape(min(M,N),)
Singular values of `a`.
Raises
------
LinAlgError
If computation does not converge.
Notes
-----
If `b` is a matrix, then all array results returned as
matrices.
Examples
--------
Fit a line, ``y = mx + c``, through some noisy data-points:
>>> x = np.array([0, 1, 2, 3])
>>> y = np.array([-1, 0.2, 0.9, 2.1])
By examining the coefficients, we see that the line should have a
gradient of roughly 1 and cuts the y-axis at more-or-less -1.
We can rewrite the line equation as ``y = Ap``, where ``A = [[x 1]]``
and ``p = [[m], [c]]``. Now use `lstsq` to solve for `p`:
>>> A = np.vstack([x, np.ones(len(x))]).T
>>> A
array([[ 0., 1.],
[ 1., 1.],
[ 2., 1.],
[ 3., 1.]])
>>> m, c = np.linalg.lstsq(A, y)[0]
>>> print m, c
1.0 -0.95
Plot the data along with the fitted line:
>>> import matplotlib.pyplot as plt
>>> plt.plot(x, y, 'o', label='Original data', markersize=10)
>>> plt.plot(x, m*x + c, 'r', label='Fitted line')
>>> plt.legend()
>>> plt.show()
"""
import math
a, _ = _makearray(a)
b, wrap = _makearray(b)
is_1d = len(b.shape) == 1
if is_1d:
b = b[:, newaxis]
_assertRank2(a, b)
m = a.shape[0]
n = a.shape[1]
n_rhs = b.shape[1]
ldb = max(n, m)
if m != b.shape[0]:
raise LinAlgError, 'Incompatible dimensions'
t, result_t = _commonType(a, b)
real_t = _linalgRealType(t)
bstar = zeros((ldb, n_rhs), t)
bstar[:b.shape[0], :n_rhs] = b.copy()
a, bstar = _fastCopyAndTranspose(t, a, bstar)
s = zeros((min(m, n), ), real_t)
nlvl = max(0, int(math.log(float(min(m, n)) / 2.)) + 1)
iwork = zeros((3 * min(m, n) * nlvl + 11 * min(m, n), ), fortran_int)
if isComplexType(t):
lapack_routine = lapack_lite.zgelsd
lwork = 1
rwork = zeros((lwork, ), real_t)
work = zeros((lwork, ), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, -1, rwork, iwork, 0)
lwork = int(abs(work[0]))
rwork = zeros((lwork, ), real_t)
a_real = zeros((m, n), real_t)
bstar_real = zeros((
ldb,
n_rhs,
), real_t)
results = lapack_lite.dgelsd(m, n, n_rhs, a_real, m, bstar_real, ldb,
s, rcond, 0, rwork, -1, iwork, 0)
lrwork = int(rwork[0])
work = zeros((lwork, ), t)
rwork = zeros((lrwork, ), real_t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, lwork, rwork, iwork, 0)
else:
lapack_routine = lapack_lite.dgelsd
lwork = 1
work = zeros((lwork, ), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, -1, iwork, 0)
lwork = int(work[0])
work = zeros((lwork, ), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, lwork, iwork, 0)
if results['info'] > 0:
raise LinAlgError, 'SVD did not converge in Linear Least Squares'
resids = array([], t)
if is_1d:
x = array(ravel(bstar)[:n], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = array([sum((ravel(bstar)[n:])**2)], dtype=result_t)
else:
x = array(transpose(bstar)[:n, :], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = sum((transpose(bstar)[n:, :])**2, axis=0).astype(result_t)
st = s[:min(n, m)].copy().astype(_realType(result_t))
return wrap(x), wrap(resids), results['rank'], st
def lstsq(a, b, rcond=-1):
"""Compute least-squares solution to equation :math:`a x = b`
Compute a vector x such that the 2-norm :math:`|b - a x|` is minimised.
Parameters
----------
a : array-like, shape (M, N)
b : array-like, shape (M,) or (M, K)
rcond : float
Cutoff for 'small' singular values.
Singular values smaller than rcond*largest_singular_value are
considered zero.
Raises LinAlgError if computation does not converge
Returns
-------
x : array, shape (N,) or (N, K) depending on shape of b
Least-squares solution
residues : array, shape () or (1,) or (K,)
Sums of residues, squared 2-norm for each column in :math:`b - a x`
If rank of matrix a is < N or > M this is an empty array.
If b was 1-d, this is an (1,) shape array, otherwise the shape is (K,)
rank : integer
Rank of matrix a
s : array, shape (min(M,N),)
Singular values of a
If b is a matrix, then all results except the rank are also returned as
matrices.
"""
import math
a, _ = _makearray(a)
b, wrap = _makearray(b)
is_1d = len(b.shape) == 1
if is_1d:
b = b[:, newaxis]
_assertRank2(a, b)
m = a.shape[0]
n = a.shape[1]
n_rhs = b.shape[1]
ldb = max(n, m)
if m != b.shape[0]:
raise LinAlgError, 'Incompatible dimensions'
t, result_t = _commonType(a, b)
real_t = _linalgRealType(t)
bstar = zeros((ldb, n_rhs), t)
bstar[:b.shape[0],:n_rhs] = b.copy()
a, bstar = _fastCopyAndTranspose(t, a, bstar)
s = zeros((min(m, n),), real_t)
nlvl = max( 0, int( math.log( float(min(m, n))/2. ) ) + 1 )
iwork = zeros((3*min(m, n)*nlvl+11*min(m, n),), fortran_int)
if isComplexType(t):
lapack_routine = lapack_lite.zgelsd
lwork = 1
rwork = zeros((lwork,), real_t)
work = zeros((lwork,), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, -1, rwork, iwork, 0)
lwork = int(abs(work[0]))
rwork = zeros((lwork,), real_t)
a_real = zeros((m, n), real_t)
bstar_real = zeros((ldb, n_rhs,), real_t)
results = lapack_lite.dgelsd(m, n, n_rhs, a_real, m,
bstar_real, ldb, s, rcond,
0, rwork, -1, iwork, 0)
lrwork = int(rwork[0])
work = zeros((lwork,), t)
rwork = zeros((lrwork,), real_t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, lwork, rwork, iwork, 0)
else:
lapack_routine = lapack_lite.dgelsd
lwork = 1
work = zeros((lwork,), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, -1, iwork, 0)
lwork = int(work[0])
work = zeros((lwork,), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, lwork, iwork, 0)
if results['info'] > 0:
raise LinAlgError, 'SVD did not converge in Linear Least Squares'
resids = array([], t)
if is_1d:
x = array(ravel(bstar)[:n], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = array([sum((ravel(bstar)[n:])**2)], dtype=result_t)
else:
x = array(transpose(bstar)[:n,:], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = sum((transpose(bstar)[n:,:])**2, axis=0).astype(result_t)
st = s[:min(n, m)].copy().astype(_realType(result_t))
return wrap(x), wrap(resids), results['rank'], st
def lstsq(a, b, rcond=-1):
"""Compute least-squares solution to equation :math:`a x = b`
Compute a vector x such that the 2-norm :math:`|b - a x|` is minimised.
Parameters
----------
a : array-like, shape (M, N)
b : array-like, shape (M,) or (M, K)
rcond : float
Cutoff for 'small' singular values.
Singular values smaller than rcond*largest_singular_value are
considered zero.
Raises LinAlgError if computation does not converge
Returns
-------
x : array, shape (N,) or (N, K) depending on shape of b
Least-squares solution
residues : array, shape () or (1,) or (K,)
Sums of residues, squared 2-norm for each column in :math:`b - a x`
If rank of matrix a is < N or > M this is an empty array.
If b was 1-d, this is an (1,) shape array, otherwise the shape is (K,)
rank : integer
Rank of matrix a
s : array, shape (min(M,N),)
Singular values of a
If b is a matrix, then all results except the rank are also returned as
matrices.
"""
import math
a, _ = _makearray(a)
b, wrap = _makearray(b)
is_1d = len(b.shape) == 1
if is_1d:
b = b[:, newaxis]
_assertRank2(a, b)
m = a.shape[0]
n = a.shape[1]
n_rhs = b.shape[1]
ldb = max(n, m)
if m != b.shape[0]:
raise LinAlgError, 'Incompatible dimensions'
t, result_t = _commonType(a, b)
real_t = _linalgRealType(t)
bstar = zeros((ldb, n_rhs), t)
bstar[:b.shape[0], :n_rhs] = b.copy()
a, bstar = _fastCopyAndTranspose(t, a, bstar)
s = zeros((min(m, n), ), real_t)
nlvl = max(0, int(math.log(float(min(m, n)) / 2.)) + 1)
iwork = zeros((3 * min(m, n) * nlvl + 11 * min(m, n), ), fortran_int)
if isComplexType(t):
lapack_routine = lapack_lite.zgelsd
lwork = 1
rwork = zeros((lwork, ), real_t)
work = zeros((lwork, ), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, -1, rwork, iwork, 0)
lwork = int(abs(work[0]))
rwork = zeros((lwork, ), real_t)
a_real = zeros((m, n), real_t)
bstar_real = zeros((
ldb,
n_rhs,
), real_t)
results = lapack_lite.dgelsd(m, n, n_rhs, a_real, m, bstar_real, ldb,
s, rcond, 0, rwork, -1, iwork, 0)
lrwork = int(rwork[0])
work = zeros((lwork, ), t)
rwork = zeros((lrwork, ), real_t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, lwork, rwork, iwork, 0)
else:
lapack_routine = lapack_lite.dgelsd
lwork = 1
work = zeros((lwork, ), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, -1, iwork, 0)
lwork = int(work[0])
work = zeros((lwork, ), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, lwork, iwork, 0)
if results['info'] > 0:
raise LinAlgError, 'SVD did not converge in Linear Least Squares'
resids = array([], t)
if is_1d:
x = array(ravel(bstar)[:n], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = array([sum((ravel(bstar)[n:])**2)], dtype=result_t)
else:
x = array(transpose(bstar)[:n, :], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = sum((transpose(bstar)[n:, :])**2, axis=0).astype(result_t)
st = s[:min(n, m)].copy().astype(_realType(result_t))
return wrap(x), wrap(resids), results['rank'], st
def lstsq(a, b, rcond=-1):
"""returns x,resids,rank,s
where x minimizes 2-norm(|b - Ax|)
resids is the sum square residuals
rank is the rank of A
s is the rank of the singular values of A in descending order
If b is a matrix then x is also a matrix with corresponding columns.
If the rank of A is less than the number of columns of A or greater than
the number of rows, then residuals will be returned as an empty array
otherwise resids = sum((b-dot(A,x)**2).
Singular values less than s[0]*rcond are treated as zero.
"""
import math
a = asarray(a)
b, wrap = _makearray(b)
one_eq = len(b.shape) == 1
if one_eq:
b = b[:, newaxis]
_assertRank2(a, b)
m = a.shape[0]
n = a.shape[1]
n_rhs = b.shape[1]
ldb = max(n, m)
if m != b.shape[0]:
raise LinAlgError, 'Incompatible dimensions'
t, result_t = _commonType(a, b)
real_t = _linalgRealType(t)
bstar = zeros((ldb, n_rhs), t)
bstar[:b.shape[0], :n_rhs] = b.copy()
a, bstar = _fastCopyAndTranspose(t, a, bstar)
s = zeros((min(m, n), ), real_t)
nlvl = max(0, int(math.log(float(min(m, n)) / 2.)) + 1)
iwork = zeros((3 * min(m, n) * nlvl + 11 * min(m, n), ), fortran_int)
if isComplexType(t):
lapack_routine = lapack_lite.zgelsd
lwork = 1
rwork = zeros((lwork, ), real_t)
work = zeros((lwork, ), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, -1, rwork, iwork, 0)
lwork = int(abs(work[0]))
rwork = zeros((lwork, ), real_t)
a_real = zeros((m, n), real_t)
bstar_real = zeros((
ldb,
n_rhs,
), real_t)
results = lapack_lite.dgelsd(m, n, n_rhs, a_real, m, bstar_real, ldb,
s, rcond, 0, rwork, -1, iwork, 0)
lrwork = int(rwork[0])
work = zeros((lwork, ), t)
rwork = zeros((lrwork, ), real_t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, lwork, rwork, iwork, 0)
else:
lapack_routine = lapack_lite.dgelsd
lwork = 1
work = zeros((lwork, ), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, -1, iwork, 0)
lwork = int(work[0])
work = zeros((lwork, ), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond, 0,
work, lwork, iwork, 0)
if results['info'] > 0:
raise LinAlgError, 'SVD did not converge in Linear Least Squares'
resids = array([], t)
if one_eq:
x = array(ravel(bstar)[:n], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = array([sum((ravel(bstar)[n:])**2)], dtype=result_t)
else:
x = array(transpose(bstar)[:n, :], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = sum((transpose(bstar)[n:, :])**2, axis=0).astype(result_t)
st = s[:min(n, m)].copy().astype(_realType(result_t))
return wrap(x), resids, results['rank'], st
def lstsq(a, b, rcond=-1):
"""returns x,resids,rank,s
where x minimizes 2-norm(|b - Ax|)
resids is the sum square residuals
rank is the rank of A
s is the rank of the singular values of A in descending order
If b is a matrix then x is also a matrix with corresponding columns.
If the rank of A is less than the number of columns of A or greater than
the number of rows, then residuals will be returned as an empty array
otherwise resids = sum((b-dot(A,x)**2).
Singular values less than s[0]*rcond are treated as zero.
"""
import math
a = asarray(a)
b, wrap = _makearray(b)
one_eq = len(b.shape) == 1
if one_eq:
b = b[:, newaxis]
_assertRank2(a, b)
m = a.shape[0]
n = a.shape[1]
n_rhs = b.shape[1]
ldb = max(n, m)
if m != b.shape[0]:
raise LinAlgError, 'Incompatible dimensions'
t, result_t = _commonType(a, b)
real_t = _linalgRealType(t)
bstar = zeros((ldb, n_rhs), t)
bstar[:b.shape[0],:n_rhs] = b.copy()
a, bstar = _fastCopyAndTranspose(t, a, bstar)
s = zeros((min(m, n),), real_t)
nlvl = max( 0, int( math.log( float(min(m, n))/2. ) ) + 1 )
iwork = zeros((3*min(m, n)*nlvl+11*min(m, n),), fortran_int)
if isComplexType(t):
lapack_routine = lapack_lite.zgelsd
lwork = 1
rwork = zeros((lwork,), real_t)
work = zeros((lwork,), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, -1, rwork, iwork, 0)
lwork = int(abs(work[0]))
rwork = zeros((lwork,), real_t)
a_real = zeros((m, n), real_t)
bstar_real = zeros((ldb, n_rhs,), real_t)
results = lapack_lite.dgelsd(m, n, n_rhs, a_real, m,
bstar_real, ldb, s, rcond,
0, rwork, -1, iwork, 0)
lrwork = int(rwork[0])
work = zeros((lwork,), t)
rwork = zeros((lrwork,), real_t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, lwork, rwork, iwork, 0)
else:
lapack_routine = lapack_lite.dgelsd
lwork = 1
work = zeros((lwork,), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, -1, iwork, 0)
lwork = int(work[0])
work = zeros((lwork,), t)
results = lapack_routine(m, n, n_rhs, a, m, bstar, ldb, s, rcond,
0, work, lwork, iwork, 0)
if results['info'] > 0:
raise LinAlgError, 'SVD did not converge in Linear Least Squares'
resids = array([], t)
if one_eq:
x = array(ravel(bstar)[:n], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = array([sum((ravel(bstar)[n:])**2)], dtype=result_t)
else:
x = array(transpose(bstar)[:n,:], dtype=result_t, copy=True)
if results['rank'] == n and m > n:
resids = sum((transpose(bstar)[n:,:])**2, axis=0).astype(result_t)
st = s[:min(n, m)].copy().astype(_realType(result_t))
return wrap(x), resids, results['rank'], st
