//[ tabular group ]----------
Group::Group(std::vector<Word> words)
: inv(0), whence(0)
{
//create vertex structure
Vertex *v_beg,*v_end;
try{ v_beg = new Vertex(); }
catch(std::bad_alloc){ mem_err(); }
try{ v_beg->next = new Vertex(); }
catch(std::bad_alloc){ mem_err(); }
v_beg->next->prev = v_beg;
try{ v_beg->next->next = new Vertex(); }
catch(std::bad_alloc){ mem_err(); }
v_beg->next->next->prev = v_beg->next;
v_end = v_beg->next->next;
//build free graph of left-multiplication
for (Vertex *v = v_beg->next;v!= v->next;v = v->next) {
for (int w=0; w<6; ++w) {
if (!(v->state & (1<<w))) { //i'm so tired...
Word& word = words[w];
Vertex *vnew = v;
for (unsigned i=0; i<word.size(); ++i) {
int j = word[i];
if (vnew->adj[j] == NULL) {
try{ vnew->adj[j]= new Vertex(v_end); }
catch(std::bad_alloc){ mem_err(); }
vnew->adj[j]->adj[j]= vnew;
}
vnew->state |= 1<<w;
vnew = vnew->adj[j];
}
v->equiv_to(vnew, v_end);
}
}
}
//states == 63.
logger.info() << "free group built, order = " << v_beg->count() |0;
/*
//find largest element and collapse mod 2
for (Vertex *v = v_end->prev; v != v->next; v = v->next) {
for (int r=0; r<4; ++r) {
if (v->adj[r]->state > 0) {
v->adj[r]->state = 0;
v->adj[r]->move_before(v_end);
}
}
v->state = 0;
}
v_beg->next->equiv_to(v_end->prev, v_end);
*/
//count & name elements
ord = 0;
for (Vertex *v = v_beg->next; v != v->next; v = v->next) {
v->state = ord++;
}
//logger.debug() << "quotient built, order = " << ord |0;
//build left mult table from graph
try{ _left = new int*[ord]; }
catch(std::bad_alloc){ mem_err(); }
for (int g = 0; g<ord; ++g) {
try{ _left[g] = new int[4]; }
catch(std::bad_alloc){ mem_err(); }
}
for(Vertex *v = v_beg->next; v != v->next; v = v->next) {
for(int j = 0; j<4; ++j) {
_left[v->state][j] = v->adj[j]->state;
}
}
delete v_beg;
logger.debug() << "left mult table built." |0;
/*
for(int c = 0;c<ord;c++)
{
logger.info() << "(" << left(c,0) |0;
for(int j = 1;j<4;j++)
logger.info() << " " << left(c,j) |0;
logger.info() << ")" |0;
}
*/
//build inverse table
whence.resize(ord, UNDEFINED);
int largest = 0;
Word reached;
reached.reserve(ord);
// start with identity element
whence[0] = IDENTITY;
reached.push_back(0);
// parse all other words
for (int i=0; i<ord; ++i) {
for (int j=0; j<4; ++j) {
int v = reached[i];
int g = left(v,j);
if (whence[g] == UNDEFINED) {
whence[g] = j;
largest = g;
reached.push_back(g);
}
}
}
// trace back to identity
Word(ord, UNDEFINED).swap(inv);
for (int g=0; g<ord; ++g) {
if (inv[g] == UNDEFINED) { //for efficiency, traverse only half
int g1 = g, g1_inv = 0;
while (g1 != 0) {
int j = whence[g1];
g1_inv = left(g1_inv,j);
g1 = left(g1, j);
}
inv[g] = g1_inv;
inv[g1_inv] = g;
}
}
logger.debug() << "inverse table built." |0;
/*
for (int c=0; c<ord; ++c) {
logger.info() << inv[c] << " " |0;
}
*/
const Logging::fake_ostream& os = logger.debug();
os << "largest element = ";
Word l = parse(largest);
for (unsigned t=0; t<l.size(); ++t) {
os << l[t];
}
os |0;
}
static COMMAND_FUNC( do_chng_one )
{
Param *p;
const char **pnlist;
int nlist=0;
int i=0;
const char *s;
p=theptbl;
/* count the number of parameters */
while( p->p_type != NULL_P_TYPE ) {
nlist++;
p++;
}
pnlist = (const char **) getbuf( (nlist+1) * sizeof(char *) );
if( pnlist == NULL ) mem_err("do_chng_one");
#ifdef HAVE_HISTORY
if( intractive(SINGLE_QSP_ARG) && IS_TRACKING_HISTORY(THIS_QSP) ){
List *lp;
Node *np;
lp = new_list();
for(i=0;i<nlist;i++){
pnlist[i] = theptbl[i].p_name;
np = mk_node(&theptbl[i]);
addTail(lp,np);
}
pnlist[i]="all";
np = mk_node(&pnlist[i]);
addTail(lp,np);
if( intractive(SINGLE_QSP_ARG) ){
char pline[LLEN];
make_prompt(QSP_ARG pline,PNAME_PMPT);
new_defs(QSP_ARG pline); /* is this needed? */
init_hist_from_item_list(QSP_ARG PNAME_PMPT,lp);
}
dellist(lp);
}
#else /* ! HAVE_HISTORY */
for(i=0;i<nlist;i++)
pnlist[i] = theptbl[i].p_name;
#endif /* ! HAVE_HISTORY */
s=NAMEOF(PNAME_PMPT);
if( !strcmp(s,"all") ){
p=theptbl;
while( p->p_type != NULL_P_TYPE ) {
getparm(QSP_ARG p);
showparm(QSP_ARG p);
p++;
}
return;
} else if( get_pval(QSP_ARG s,theptbl) == -1 ){
sprintf(ERROR_STRING,"Unknown parameter \"%s\"",s);
WARN(ERROR_STRING);
}
}
int open_server_port(QSP_ARG_DECL const char *name,int port_no)
{
Port *mpp;
#ifdef HAVE_SOCKET
socklen_t length;
#endif // HAVE_SOCKET
int on=1;
if ( (port_no < 2001) || (port_no > 6999) ) {
WARN("Illegal port number");
advise("Use 2001-6999");
advise("Check /etc/services for other conflicts");
return(-1);
}
mpp=new_port(QSP_ARG name);
if( mpp==NO_PORT ){
if( verbose ){
sprintf(ERROR_STRING,"open_server_port %s %d failed to create port struct",
name,port_no);
WARN(ERROR_STRING);
}
return(-1);
}
#ifdef HAVE_SOCKET
mpp->mp_o_sock=socket(AF_INET,SOCK_STREAM,0);
//fprintf(stderr,"socket returned %d (0x%x)\n",
//mpp->mp_o_sock,mpp->mp_o_sock);
#ifdef FOOBAR
// pc-nfs???
mpp->mp_o_sock=socket(PF_INET,SOCK_STREAM,0);
#endif /* FOOBAR */
#else // ! HAVE_SOCKET
WARN("open_server_port: Sorry, no socket implementation available!?");
mpp->mp_o_sock=(-1);
#endif // HAVE_SOCKET
#ifdef BUILD_FOR_WINDOWS
if( mpp->mp_o_sock == INVALID_SOCKET ){
int e;
e=WSAGetLastError();
fprintf(stderr,"Invalid socket, error code = %d\n",e);
switch(e){
case WSANOTINITIALISED:
WARN("Missing call to WSAStartup!?");
break;
default:
WARN("Unclassified error.");
break;
}
}
#endif // BUILD_FOR_WINDOWS
// sleeptime used to be signed, but not now.
//mpp->mp_sleeptime=(-1);
mpp->mp_sleeptime=0;
mpp->mp_sock=(-1);
if( mpp->mp_o_sock<0 ){
tell_sys_error("open_server_port (socket)");
WARN("error opening stream socket");
delport(QSP_ARG mpp);
return(-1);
}
#ifdef HAVE_SOCKET
fprintf(stderr,"Setting socket options...\n");
setsockopt(mpp->mp_o_sock,SOL_SOCKET,SO_REUSEADDR,
(char *)&on,sizeof(on));
mpp->mp_addrp =
(struct sockaddr_in *) getbuf( sizeof(*(mpp->mp_addrp) ) );
if( mpp->mp_addrp == NULL ) mem_err("open_server_port");
mpp->mp_flags = 0;
mpp->mp_flags |= PORT_SERVER; // makes it keep trying!
mpp->mp_pp = NO_PORT;
mpp->mp_text_var_name=NULL;
mpp->mp_output_filename=NULL;
mpp->mp_auth_string=NULL;
mpp->mp_portnum = port_no;
mpp->mp_addrp->sin_family = AF_INET;
mpp->mp_addrp->sin_addr.s_addr = INADDR_ANY;
length=sizeof(*(mpp->mp_addrp));
mpp->mp_addrp->sin_port = htons( port_no );
fprintf(stderr,"Binding socket...\n");
if( bind(mpp->mp_o_sock,(struct sockaddr *)(mpp->mp_addrp), length) ){
tell_sys_error("bind");
WARN("open_server_port: couldn't bind to port");
goto cleanup;
}
fprintf(stderr,"Getting socket name...\n");
if( getsockname(mpp->mp_o_sock,
(struct sockaddr *)mpp->mp_addrp,&length) ){
WARN("open_server_port: error getting socket name");
goto cleanup;
}
/* We used to make sure that the port number
* was the one we requested, but we no longer
* insist upon that...
*/
if( port_listen(QSP_ARG mpp) < 0 )
goto cleanup;
fprintf(stderr,"Back from port_listen...\n");
#endif // HAVE_SOCKET
return(port_no);
cleanup:
givbuf((char *)mpp->mp_addrp);
mpp->mp_addrp = NULL;
delport(QSP_ARG mpp);
return(-1);
} // open_server_port
