/* use pointer device to rotate (via magic sphere) */
bool pointer_rotate (int iw, int to_x, int to_y)
{
double a[3], b[3], c[3], R[3][3];
mgs ( n[iw].lx - AX_size[iw].width/2.,
n[iw].ly - AX_size[iw].height/2., n[iw].mgs_radius, a );
mgs ( to_x - AX_size[iw].width/2.,
to_y - AX_size[iw].height/2., n[iw].mgs_radius, b );
V3CROSS (a, b, c);
if (V3LENGTH2(c) < MIN_RADIAN*MIN_RADIAN) return (FALSE);
M3geodesic (b, a, R);
rotate (iw, R);
n[iw].lx = to_x;
n[iw].ly = to_y;
return (TRUE);
} /* end pointer_rotate() */
void onDisplay( ) {
glClearColor(0.1f, 0.2f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_LINES);
for (int i = -3; i < 3; i++) {
for (int j = -3; j <= 3; j++) {
glVertex3f(i*zoom, 0, j*zoom);
glVertex3f((i+1)*zoom, 0, j*zoom);
}
}
for (int i = -3; i < 3; i++) {
for (int j = -3; j <= 3; j++) {
glVertex3f(j*zoom, 0, i*zoom);
glVertex3f(j*zoom, 0, (i+1)*zoom);
}
}
glEnd();
mygluSphere mgs(2., 100., 100.);
//GLUquadric *quad = gluNewQuadric();
//gluSphere(quad, 2., 100., 100.);
// Buffercsere: rajzolas vege
glFinish();
glutSwapBuffers();
}
int DLL_EXPORT extrapolate(real_t *vectors, uint_t dim, uint_t order, enum EXTR_METHOD method)
{
real_t *const v0 = vectors;
/* Compute differences */
for (uint_t i = order - 1; i > 0; --i) {
real_t *v = vectors + i * dim;
real_t *u = v - dim;
for (uint_t k = 0; k < dim; ++k)
v[k] = v[k] - u[k];
}
vectors = vectors + dim;
order = order - 1;
/* QR decomposition */
real_t R[order * order];
mgs(vectors, R, dim, order);
/* Compute coefficients */
real_t gamma[order];
switch (method) {
case MPE: mpe(R, gamma, order); break;
case RRE: rre(R, gamma, order); break;
default: return -1;
}
/* xi = 1 - cumsum(gamma) */
for (uint_t i = 1; i < order; ++i)
gamma[i] = gamma[i] + gamma[i-1];
real_t xi[order];
for (uint_t i = 0; i < order; ++i)
xi[i] = 1 - gamma[i];
/* eta = R * xi */
real_t eta[order];
for (uint_t i = 0; i < order; ++i) {
eta[i] = 0;
for (uint_t k = 0; k < order; ++k)
eta[i] = eta[i] + R[IDX(i, k, order)] * xi[k];
}
/* Compute the solution: v0 + Q * eta */
for (uint_t i = 0; i < order; ++i) {
real_t *q = vectors + i * dim;
for (uint_t k = 0; k < dim; ++k)
v0[k] = v0[k] + q[k] * eta[i];
}
return 0;
}
int main ( void )
/******************************************************************************/
/*
Purpose:
MAIN is the main program for MGS_PRB.
Discussion:
MGS_PRB tests the MGS library.
Modified:
07 November 2011
Author:
John Burkardt
*/
{
float **a;
float **a_qr;
float **a_save;
float a_hi = 10.0;
float a_lo = -10.0;
float diff;
int i;
int j;
int k;
int m;
int n;
float **q;
float **r;
int seed = 123456789;
int test;
timestamp ( );
printf ( "\n" );
printf ( "MGS_PRB:\n" );
printf ( " C version\n" );
printf ( " Test cases for MGS.\n" );
printf ( "\n" );
for ( test = 1; test <= 4; test++ )
{
m = i4_uniform ( 1, 20, &seed );
n = i4_uniform ( 1, 20, &seed );
a = r4mat_new ( m, n );
a_qr = r4mat_new ( m, n );
a_save = r4mat_new ( m, n );
q = r4mat_new ( m, n );
r = r4mat_new ( n, n );
r4mat_uniform ( m, n, a_lo, a_hi, &seed, a );
for ( j = 0; j < n; j++ )
{
for ( i = 0; i < m; i++ )
{
a_save[i][j] = a[i][j];
}
}
for ( j = 0; j < n; j++ )
{
for ( i = 0; i < m; i++ )
{
q[i][j] = 0.0;
}
}
for ( j = 0; j < n; j++ )
{
for ( i = 0; i < n; i++ )
{
r[i][j] = 0.0;
}
}
mgs ( m, n, a, r, q );
for ( j = 0; j < n; j++ )
{
for ( i = 0; i < m; i++ )
{
a_qr[i][j] = 0.0;
for ( k = 0; k < n; k++ )
{
a_qr[i][j] = a_qr[i][j] + q[i][k] * r[k][j];
}
}
}
diff = 0.0;
for ( j = 0; j < n; j++ )
{
for ( i = 0; i < m; i++ )
{
diff = diff + pow ( a_save[i][j] - a_qr[i][j], 2 );
}
}
diff = diff / sqrt ( ( float ) ( m * n ) );
printf ( " %2d %2d %14.6g\n", m, n, diff );
r4mat_delete ( a, m, n );
r4mat_delete ( a_qr, m, n );
r4mat_delete ( a_save, m, n );
r4mat_delete ( q, m, n );
r4mat_delete ( r, n, n );
}
/*
Terminate.
*/
printf ( "\n" );
printf ( "MGS_PRB:\n" );
printf ( " Normal end of execution.\n" );
printf ( "\n" );
timestamp ( );
return 0;
}
void Peer::received(
const RuntimeEnvironment *RR,
const SharedPtr<Socket> &fromSock,
const InetAddress &remoteAddr,
unsigned int hops,
uint64_t packetId,
Packet::Verb verb,
uint64_t inRePacketId,
Packet::Verb inReVerb,
uint64_t now)
{
// Update system-wide last packet receive time
*((const_cast<uint64_t *>(&(RR->timeOfLastPacketReceived)))) = now;
// Global last receive time regardless of path
_lastReceive = now;
if (!hops) {
// Learn paths from direct packets (hops == 0)
{
bool havePath = false;
for(unsigned int p=0,np=_numPaths;p<np;++p) {
if ((_paths[p].address() == remoteAddr)&&(_paths[p].tcp() == fromSock->tcp())) {
_paths[p].received(now);
havePath = true;
break;
}
}
if (!havePath) {
unsigned int np = _numPaths;
if (np >= ZT_PEER_MAX_PATHS)
clean(now);
np = _numPaths;
if (np < ZT_PEER_MAX_PATHS) {
Path::Type pt = Path::PATH_TYPE_UDP;
switch(fromSock->type()) {
case Socket::ZT_SOCKET_TYPE_TCP_IN:
pt = Path::PATH_TYPE_TCP_IN;
break;
case Socket::ZT_SOCKET_TYPE_TCP_OUT:
pt = Path::PATH_TYPE_TCP_OUT;
break;
default:
break;
}
_paths[np].init(remoteAddr,pt,false);
_paths[np].received(now);
_numPaths = ++np;
}
}
}
/* Announce multicast groups of interest to direct peers if they are
* considered authorized members of a given network. Also announce to
* supernodes and network controllers. The other place this is done
* is in rescanMulticastGroups() in Network, but that only sends something
* if a network's multicast groups change. */
if ((now - _lastAnnouncedTo) >= ((ZT_MULTICAST_LIKE_EXPIRE / 2) - 1000)) {
_lastAnnouncedTo = now;
bool isSupernode = RR->topology->isSupernode(_id.address());
Packet outp(_id.address(),RR->identity.address(),Packet::VERB_MULTICAST_LIKE);
std::vector< SharedPtr<Network> > networks(RR->nc->networks());
for(std::vector< SharedPtr<Network> >::iterator n(networks.begin());n!=networks.end();++n) {
if ( ((*n)->isAllowed(_id.address())) || (isSupernode) ) {
std::set<MulticastGroup> mgs((*n)->multicastGroups());
for(std::set<MulticastGroup>::iterator mg(mgs.begin());mg!=mgs.end();++mg) {
if ((outp.size() + 18) > ZT_UDP_DEFAULT_PAYLOAD_MTU) {
outp.armor(_key,true);
fromSock->send(remoteAddr,outp.data(),outp.size());
outp.reset(_id.address(),RR->identity.address(),Packet::VERB_MULTICAST_LIKE);
}
// network ID, MAC, ADI
outp.append((uint64_t)(*n)->id());
mg->mac().appendTo(outp);
outp.append((uint32_t)mg->adi());
}
}
}
if (outp.size() > ZT_PROTO_MIN_PACKET_LENGTH) {
outp.armor(_key,true);
fromSock->send(remoteAddr,outp.data(),outp.size());
}
}
}
if ((verb == Packet::VERB_FRAME)||(verb == Packet::VERB_EXT_FRAME))
_lastUnicastFrame = now;
else if ((verb == Packet::VERB_P5_MULTICAST_FRAME)||(verb == Packet::VERB_MULTICAST_FRAME))
_lastMulticastFrame = now;
}
SEXP TASCB_min(SEXP vect, SEXP tau, SEXP numberofSamples, SEXP sigma){
int value_count, sigma_count;
mgs_result mgs_res;
quant_result q_res;
dbl_array *vector, *vect_sorted, *s;
dbl_matrix *H_Mat1, *H_Mat2;
calc_V_result_tri v_res;
final_result_tri f_res;
SEXP result, binarized_vector, threshold1, threshold2, p_value, other_results, names;
SEXP smoothed, zerocrossing, deriv, steps, H1, H2, index, v_vec, meanlist, smoothedX;
value_count = length(vect);
sigma_count = length(sigma);
PROTECT(result = allocVector(VECSXP, 5));
PROTECT(names = allocVector(VECSXP, 5));
SET_VECTOR_ELT(names,0, mkChar("binarized_vector"));
SET_VECTOR_ELT(names,1, mkChar("threshold1"));
SET_VECTOR_ELT(names,2, mkChar("threshold2"));
SET_VECTOR_ELT(names,3, mkChar("p_value"));
SET_VECTOR_ELT(names,4, mkChar("other_results"));
setAttrib(result, R_NamesSymbol, names);
UNPROTECT(1);
PROTECT(other_results = allocVector(VECSXP, 10));
PROTECT(names = allocVector(VECSXP, 10));
SET_VECTOR_ELT(names,0, mkChar("smoothed"));
SET_VECTOR_ELT(names,1, mkChar("zerocrossing"));
SET_VECTOR_ELT(names,2, mkChar("deriv"));
SET_VECTOR_ELT(names,3, mkChar("steps"));
SET_VECTOR_ELT(names,4, mkChar("H_Mat1"));
SET_VECTOR_ELT(names,5, mkChar("H_Mat2"));
SET_VECTOR_ELT(names,6, mkChar("index"));
SET_VECTOR_ELT(names,7, mkChar("v_vec"));
SET_VECTOR_ELT(names,8, mkChar("smoothedX"));
SET_VECTOR_ELT(names,9, mkChar("meanlist"));
setAttrib(other_results, R_NamesSymbol, names);
UNPROTECT(1);
PROTECT(smoothed = allocMatrix(REALSXP, value_count - 1, sigma_count));
PROTECT(zerocrossing = allocMatrix(INTSXP, (int)ceil((double)value_count / 2.0), sigma_count));
PROTECT(deriv = allocVector(REALSXP, value_count - 1));
mgs_res.smoothed = init_dbl_matrix(REAL(smoothed), sigma_count, value_count - 1, 0);
mgs_res.zerocrossing = init_int_matrix(INTEGER(zerocrossing), sigma_count, (int)ceil((double)value_count / 2.0), 0);
mgs_res.deriv = init_dbl_array(REAL(deriv), value_count - 1, 0);
vector = init_dbl_array(REAL(vect), value_count, 1);
vect_sorted = init_dbl_array(0, value_count, 0);
s = init_dbl_array(REAL(sigma), sigma_count, 1);
b = init_dbl_matrix(0, sigma_count, mgs_res.deriv->length, 0);
b_returned = init_int_matrix(0, sigma_count, mgs_res.deriv->length, 0);
memcpy(vect_sorted->values, REAL(vect), vect_sorted->length * sizeof(double));
qsort(vect_sorted->values, vect_sorted->length, sizeof(double), comp);
mgs(&mgs_res, vect_sorted, s);
q_res.steps = init_int_matrix(0, sigma_count, (int)ceil((double)value_count / 2.0), 0);
q_res.index = init_int_array(0, sigma_count, 0);
q_res.greatest_index_ind = 0;
q_res.greatest_steps_col = 0;
q_res.greatest_steps_row = 0;
getQuantizations(&q_res, &mgs_res);
PROTECT(steps = allocMatrix(INTSXP, q_res.greatest_steps_col, q_res.greatest_steps_row));
PROTECT(H1 = allocMatrix(REALSXP, q_res.greatest_steps_col, q_res.greatest_steps_row));
PROTECT(H2 = allocMatrix(REALSXP, q_res.greatest_steps_col, q_res.greatest_steps_row));
PROTECT(index = allocVector(INTSXP, q_res.greatest_index_ind));
cut_int_matrix(q_res.steps, INTEGER(steps), 0, q_res.greatest_steps_row - 1, 0, q_res.greatest_steps_col - 1);
cut_int_array(q_res.index, INTEGER(index), 0, q_res.greatest_index_ind - 1);
H_Mat1 = init_dbl_matrix(REAL(H1), q_res.greatest_steps_row, q_res.greatest_steps_col, 0);
H_Mat2 = init_dbl_matrix(REAL(H2), q_res.greatest_steps_row, q_res.greatest_steps_col, 0);
PROTECT(v_vec = allocMatrix(INTSXP, q_res.index->length, 2));
PROTECT(smoothedX = allocMatrix(REALSXP, mgs_res.smoothed->cols + 1, q_res.index->length));
PROTECT(meanlist = allocMatrix(REALSXP, vect_sorted->length, q_res.index->length + 1));
v_res.v = init_int_matrix(INTEGER(v_vec), q_res.index->length, 2, 0);
v_res.meanlist = init_dbl_matrix(REAL(meanlist), q_res.index->length + 1, vect_sorted->length, 0);
v_res.smoothedX = init_dbl_matrix(REAL(smoothedX), q_res.index->length, mgs_res.smoothed->cols + 1, 0);
calc_V_Scalespace_tri_min(&v_res, &mgs_res, &q_res, H_Mat1, H_Mat2, vect_sorted);
PROTECT(binarized_vector = allocVector(INTSXP, value_count));
PROTECT(threshold1 = allocVector(REALSXP, 1));
PROTECT(threshold2 = allocVector(REALSXP, 1));
PROTECT(p_value = allocVector(REALSXP, 1));
f_res.binarized_vector = init_int_array(INTEGER(binarized_vector), value_count, 0);
f_res.p = REAL(p_value);
f_res.threshold1 = REAL(threshold1);
f_res.threshold2 = REAL(threshold2);
calc_final_results_tri_min(&f_res, v_res.v, vector, vect_sorted, *REAL(tau), *INTEGER(numberofSamples));
SET_VECTOR_ELT(other_results, 0, smoothed);
SET_VECTOR_ELT(other_results, 1, zerocrossing);
SET_VECTOR_ELT(other_results, 2, deriv);
SET_VECTOR_ELT(other_results, 3, steps);
SET_VECTOR_ELT(other_results, 4, H1);
SET_VECTOR_ELT(other_results, 5, H2);
SET_VECTOR_ELT(other_results, 6, index);
SET_VECTOR_ELT(other_results, 7, v_vec);
SET_VECTOR_ELT(other_results, 8, smoothedX);
SET_VECTOR_ELT(other_results, 9, meanlist);
SET_VECTOR_ELT(result, 0, binarized_vector);
SET_VECTOR_ELT(result, 1, threshold1);
SET_VECTOR_ELT(result, 2, threshold2);
SET_VECTOR_ELT(result, 3, p_value);
SET_VECTOR_ELT(result, 4, other_results);
destroy_dbl_matrix(mgs_res.smoothed);
destroy_int_matrix(mgs_res.zerocrossing);
destroy_dbl_array(mgs_res.deriv);
destroy_dbl_array(vector);
destroy_dbl_array(vect_sorted);
destroy_dbl_array(s);
destroy_dbl_matrix(b);
destroy_int_matrix(b_returned);
b = 0;
b_returned = 0;
destroy_dbl_matrix(H_Mat1);
destroy_dbl_matrix(H_Mat2);
destroy_int_matrix(q_res.steps);
destroy_int_array(q_res.index);
destroy_int_matrix(v_res.v);
destroy_dbl_matrix(v_res.meanlist);
destroy_dbl_matrix(v_res.smoothedX);
destroy_int_array(f_res.binarized_vector);
UNPROTECT(16);
return result;
}
void mexFunction(
int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{ double *Q, *R, *Rout, *indextmp, *normrout, *nreout;
mwIndex subs[2];
mwSize nsubs=2;
mwIndex *index;
mwSize n, k1, k, j, nre, method;
double alpha, normr, normrold;
/* CHECK FOR PROPER NUMBER OF ARGUMENTS */
if (nrhs < 3) {
mexErrMsgTxt("mexreorth: requires at least 2 input arguments.");
}
if (nlhs > 4) {
mexErrMsgTxt("mexreorth: requires at most 4 output argument.");
}
/* CHECK THE DIMENSIONS */
n = mxGetM(prhs[0]);
k1 = mxGetN(prhs[0]);
if (mxIsSparse(prhs[0])) {
mexErrMsgTxt("mexreorth: sparse Q not allowed.");
}
Q = mxGetPr(prhs[0]);
if (mxIsSparse(prhs[1])) {
mexErrMsgTxt("mexreorth: sparse R not allowed.");
}
if (mxGetM(prhs[1])!=n || mxGetN(prhs[1])!=1) {
mexErrMsgTxt("mexreorth: R is not compatible.");
}
R = mxGetPr(prhs[1]);
if (nrhs < 3) {
normr = sqrt(realdot(R,R,n));
} else {
normr = *mxGetPr(prhs[2]);
}
if (nrhs < 4) {
k = k1;
index = mxCalloc(k,sizeof(mwSize));
for (j=0; j<k; j++) {
index[j]=j;
}
} else {
indextmp = mxGetPr(prhs[3]);
if (indextmp == NULL) {
mexErrMsgTxt("mexreorth: index is empty");
}
k = MAX(mxGetM(prhs[3]),mxGetN(prhs[3]));
index = mxCalloc(k,sizeof(mwSize));
for (j=0; j<k; j++) {
index[j] = (mwSize) (indextmp[j]-1);
}
}
if (nrhs< 5) {
alpha = 0.5;
}
else {
alpha = *mxGetPr(prhs[4]);
}
if (nrhs==5) {
method = (mwSize)*mxGetPr(prhs[5]);
}
else {
method = 0;
}
/***** create return argument *****/
plhs[0] = mxCreateDoubleMatrix(n,1,mxREAL);
Rout = mxGetPr(plhs[0]);
plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL);
normrout = mxGetPr(plhs[1]);
plhs[2] = mxCreateDoubleMatrix(1,1,mxREAL);
nreout = mxGetPr(plhs[2]);
memcpy(mxGetPr(plhs[0]),mxGetPr(prhs[1]),(n)*sizeof(double));
/***** main *****/
normrold = 0;
nre = 0;
while ((normr<alpha*normrold) || (nre==0)) {
mgs(n,Q,Rout,index,k);
normrold = normr;
normr = sqrt(realdot(Rout,Rout,n));
nre = nre+1;
if (nre > 4) {
/** printf("R is in span(Q)"); **/
for (j=0; j<n; j++) {
Rout[j] = 0;
}
normr = 0;
break;
}
}
normrout[0] = normr;
nreout[0] = nre;
return;
}
msym_error_t generateOrbitalSubspaces(msym_point_group_t *pg, int esl, msym_equivalence_set_t *es, msym_permutation_t **perm, int basisl, msym_orbital_t basis[basisl], msym_thresholds_t *thresholds, int *subspacel, msym_subspace_t **subspace, int **pspan){
msym_error_t ret = MSYM_SUCCESS;
int lmax = -1, nmax = -1, eslmax = -1;
for(int i = 0;i < basisl;i++){
lmax = basis[i].l > lmax ? basis[i].l : lmax;
nmax = basis[i].n > nmax ? basis[i].n : nmax;
}
if(lmax < 0){ret = MSYM_INVALID_ORBITALS; return ret;} //if we goto err here, code will get ugly due to scope
for(int i = 0;i < esl;i++) eslmax = es[i].length > eslmax ? es[i].length : eslmax;
struct _ltransforms {int d; void *t;} *lts = calloc(lmax+1,sizeof(struct _ltransforms));
double (*mkron)[(2*lmax+1)*pg->order] = malloc(sizeof(double[(2*lmax+1)*pg->order][(2*lmax+1)*pg->order]));
double (*mperm)[pg->order] = malloc(sizeof(double[pg->order][pg->order]));
double (*mproj)[pg->ct->l+1][(2*lmax+1)*pg->order][(2*lmax+1)*pg->order] = malloc(sizeof(double[lmax+1][pg->ct->l+1][(2*lmax+1)*pg->order][(2*lmax+1)*pg->order]));
double (*lspan)[pg->ct->l] = malloc(sizeof(double[lmax+1][pg->ct->l]));
int (*ispan) = calloc(pg->ct->l,sizeof(int));
int *aspan = calloc(pg->ct->l,sizeof(int));
int *nl = malloc(sizeof(int[lmax+1]));
msym_orbital_t *(*omap)[nmax][lmax][2*lmax+1] = malloc(sizeof(msym_orbital_t *[eslmax][nmax+1][lmax+1][2*lmax+1]));
*subspace = NULL;
msym_subspace_t *iss = calloc(pg->ct->l, sizeof(msym_subspace_t));
for(int k = 0;k < pg->ct->l;k++){
iss[k].type = ATOMIC_ORBITAL;
iss[k].irrep = k;
iss[k].subspacel = esl;
iss[k].subspace = calloc(esl, sizeof(msym_subspace_t));
}
for(int l = 0; l <= lmax;l++){
lts[l].d = 2*l+1;
lts[l].t = malloc(sizeof(double[pg->sopsl][lts[l].d][lts[l].d]));
if(MSYM_SUCCESS != (ret = generateOrbitalTransforms(pg->sopsl, pg->sops, l, lts[l].t))) goto err;
}
for(int i = 0; i < esl;i++){
int esilmax = -1, esinmax = -1;
memset(nl,0,sizeof(int[lmax+1]));
for(int j = 0;j < es[i].elements[0]->aol;j++){
esilmax = esilmax < es[i].elements[0]->ao[j]->l ? es[i].elements[0]->ao[j]->l : esilmax;
esinmax = esinmax < es[i].elements[0]->ao[j]->n ? es[i].elements[0]->ao[j]->n : esinmax;
nl[es[i].elements[0]->ao[j]->l] += es[i].elements[0]->ao[j]->m == 0;
}
msym_orbital_t *(*esomap)[esinmax+1][esilmax+1][2*esilmax+1] = omap;
memset(esomap,0,sizeof(msym_orbital_t *[es->length][esinmax+1][esilmax+1][2*esilmax+1]));
for(int a = 0;a < es[i].length;a++){
for(int ao = 0;ao < es[i].elements[a]->aol;ao++){
msym_orbital_t *o = es[i].elements[a]->ao[ao];
esomap[a][o->n][o->l][o->m+o->l] = o;
}
}
memset(lspan,0,sizeof(double[lmax+1][pg->ct->l]));
for(int l = 0;l <= esilmax;l++){
int d = es[i].length*lts[l].d;
double (*mlproj)[d][d] = mproj[l];
memset(mlproj,0,sizeof(double[pg->ct->l][d][d]));
memset(ispan,0,sizeof(int[pg->ct->l]));
for(int s = 0;s < pg->sopsl;s++){
double (*lt)[lts[l].d][lts[l].d] = lts[l].t;
permutationMatrix(&perm[i][s], mperm);
kron(perm[i][s].p_length,mperm,lts[l].d,lt[s],d,mkron);
//printSymmetryOperation(&pg->sops[s]);
//printTransform(d, d, mkron);
for(int k = 0;k < pg->ct->l;k++){
lspan[l][k] += pg->ct->irrep[k].v[pg->sops[s].cla]*mltrace(d, mkron);
mlscale(pg->ct->irrep[k].v[pg->sops[s].cla], d, mkron, mlproj[pg->ct->l]); //mproj[pg->ct.l] is a workspace
mladd(d, mlproj[pg->ct->l], mlproj[k], mlproj[k]); //Could do this based on the span later, but it's not a huge amount of work
}
}
memset(mlproj[pg->ct->l],0,sizeof(double[d][d]));
int nirrepl = 0;
for(int k = 0;k < pg->ct->l;k++){
int lirrepl = nirrepl;
msym_subspace_t *ss = &iss[k].subspace[i];
ispan[k] = (((int)round(lspan[l][k]))/pg->order);
mlscale(((double) pg->ct->irrep[k].d)/pg->order, d, mlproj[k], mlproj[k]);
nirrepl = mgs(d, mlproj[k], mlproj[pg->ct->l], nirrepl, thresholds->orthogonalization/basisl);
if(nirrepl - lirrepl != ispan[k]*pg->ct->irrep[k].d){
//printTransform(d, d, mlproj[k]);
ret = MSYM_ORBITAL_ERROR;
msymSetErrorDetails("Ortogonal subspace of dimension (%d) inconsistent with span (%d) in %s",nirrepl - lirrepl,ispan[k]*pg->ct->irrep[k].d,pg->ct->irrep[k].name);
goto err;
}
ss->type = ATOMIC_ORBITAL;
ss->irrep = k;
if(ispan[k] > 0){
ss->subspace = realloc(ss->subspace, sizeof(msym_subspace_t[ss->subspacel+nl[l]]));
for(int n = l+1; n <= esinmax;n++){
if(esomap[0][n][l][0] == NULL) continue;
aspan[k] += ispan[k]*pg->ct->irrep[k].d;
msym_subspace_t *nss = &ss->subspace[ss->subspacel];
memset(nss,0,sizeof(msym_subspace_t));
nss->type = ATOMIC_ORBITAL;
nss->irrep = ss->irrep;
nss->d = ispan[k]*pg->ct->irrep[k].d;
double (*space)[d] = malloc(sizeof(double[nss->d][d]));
for(int dim = 0; dim < ss->subspace[ss->subspacel].d;dim++){
vlnorm2(d, mlproj[pg->ct->l][lirrepl+dim], space[dim]);
}
nss->space = (double*) space;
nss->basisl = 0;
nss->basis.o = malloc(sizeof(msym_orbital_t *[d]));
for(int e = 0;e < es[i].length;e++){
for(int m = -l;m <= l;m++){
nss->basis.o[nss->basisl++] = esomap[e][n][l][m+l];
}
}
ss->subspacel++;
if(nss->basisl != d) {
ret = MSYM_ORBITAL_ERROR;
msymSetErrorDetails("Basis length (%d) inconsistent with projection operator dimensions (%d)",nss->basisl,d);
goto err;
}
}
}
}
}
}
printf("Subspace span (vectors) = ");
for(int k = 0;k < pg->ct->l;k++){
printf(" + %d%s",aspan[k],pg->ct->irrep[k].name);
}
printf("\n");
msym_subspace_t tss = {.subspacel = pg->ct->l, .subspace = iss, .d = 0, .basisl = 0, .space = NULL};
filterSubspace(&tss);
*subspace = tss.subspace;
*subspacel = tss.subspacel;
*pspan = aspan;
free(omap);
free(nl);
free(ispan);
free(lspan);
free(mproj);
free(mperm);
free(mkron);
for(int l = 0;l <= lmax;l++){
free(lts[l].t);
}
free(lts);
return ret;
err:
free(aspan);
free(omap);
free(nl);
free(ispan);
free(lspan);
free(mproj);
free(mperm);
free(mkron);
for(int l = 0;l < lmax;l++){
free(lts[l].t);
}
free(lts);
for(int k = 0;k < pg->ct->l;k++){
freeSubspace(&iss[k]);
}
free(iss);
return ret;
}
msym_error_t getOrbitalSubspaces(int ssl, msym_subspace_t ss[ssl], int basisl, msym_orbital_t basis[basisl], double c[basisl][basisl]){
msym_error_t ret = MSYM_SUCCESS;
int index = 0;
memset(c,0,sizeof(double[basisl][basisl]));
for(int i = 0;i < ssl;i++){
if(MSYM_SUCCESS != (ret = getOrbitalSubspaceCoefficients(&ss[i],basisl,basis,&index,c))) goto err;
}
if(index != basisl){
msymSetErrorDetails("Subspace index (%d) does not match basis length (%d)",index,basisl);
ret = MSYM_INVALID_SUBSPACE;
goto err;
}
return ret;
err:
return ret;
}
