126 lines
2.9 KiB
C
126 lines
2.9 KiB
C
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <malloc.h>
|
|
#include <setoper.h>
|
|
#include <cdd.h>
|
|
|
|
#include "weyl.h"
|
|
#include "thickenings.h"
|
|
|
|
doublequotient_t *dq;
|
|
double *vector;
|
|
char buf[1000];
|
|
|
|
typedef struct {
|
|
dd_MatrixPtr M;
|
|
dd_LPSolutionPtr lps;
|
|
} info_t;
|
|
|
|
static char* alphabetize(weylgroup_element_t *e, char *str)
|
|
{
|
|
if(e->wordlength == 0)
|
|
sprintf(str, "1");
|
|
else {
|
|
for(int j = 0; j < e->wordlength; j++)
|
|
str[j] = e->word[j] + 'a';
|
|
str[e->wordlength] = 0;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
static void balanced_thickening_callback(const bitvec_t *pos, int size, const enumeration_info_t *ei)
|
|
{
|
|
int bit, funcbit, sign;
|
|
dd_rowset ImL, Lbasis;
|
|
dd_ErrorType err = dd_NoError;
|
|
info_t *info = (info_t*)ei->callback_data;
|
|
|
|
for(int i = 0; i < size; i++) {
|
|
bit = i < size/2 ? bv_get_bit(pos, i) : !bv_get_bit(pos, size - 1 - i);
|
|
sign = bit ? 1 : -1;
|
|
info->M->matrix[i][0][0] = 0.0;
|
|
info->M->matrix[i][1][0] = sign*vector[3*i];
|
|
info->M->matrix[i][2][0] = sign*vector[3*i+1];
|
|
info->M->matrix[i][3][0] = sign*vector[3*i+2];
|
|
// printf("0 %.2f %.2f %.2f %d %d\n", sign*vector[3*i], sign*vector[3*i+1], sign*vector[3*i+2], bit, funcbit);
|
|
}
|
|
|
|
dd_FindRelativeInterior(info->M, &ImL, &Lbasis, &(info->lps), &err);
|
|
|
|
if(set_card(Lbasis) != 0)
|
|
printf("codim = %ld\n", set_card(Lbasis));
|
|
else
|
|
printf("weight = (%.4f, %.4f, %.4f)\n", *info->lps->sol[0], *info->lps->sol[1], *info->lps->sol[2]);
|
|
|
|
|
|
dd_FreeLPSolution(info->lps);
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
static int apply_reflection(double *in, double *out, int rank, int reflection)
|
|
{
|
|
memcpy(out, in, rank*sizeof(double));
|
|
/*
|
|
out[reflection] *= -1;
|
|
if(reflection != 0)
|
|
out[reflection-1] += in[reflection];
|
|
if(reflection != rank-1)
|
|
out[reflection+1] += in[reflection];
|
|
*/
|
|
out[reflection] *= -1;
|
|
if(reflection != 0)
|
|
out[reflection] += in[reflection-1];
|
|
if(reflection != rank-1)
|
|
out[reflection] += in[reflection+1];
|
|
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
semisimple_type_t type;
|
|
simple_type_t simple;
|
|
info_t info;
|
|
|
|
type.n = 1;
|
|
type.factors = &simple;
|
|
simple.series = 'A';
|
|
simple.rank = 3;
|
|
|
|
dq = weyl_generate_bruhat(type, 0, 0);
|
|
|
|
int order = weyl_order(type);
|
|
int rank = weyl_rank(type);
|
|
weylgroup_element_t *group = dq->group;
|
|
vector = malloc(weyl_order(type)*weyl_rank(type)*sizeof(double));
|
|
|
|
vector[0] = 3;
|
|
vector[1] = 4;
|
|
vector[2] = 3;
|
|
|
|
for(int i = 0; i < order; i++) {
|
|
printf("%s %.2f %.2f %.2f\n", alphabetize(&group[i], buf), vector[3*i], vector[3*i+1], vector[3*i+2]);
|
|
|
|
for(int j = 0; j < rank; j++)
|
|
if(group[i].left[j]->wordlength > group[i].wordlength)
|
|
apply_reflection(&vector[3*i], &vector[3*group[i].left[j]->index], rank, j);
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
dd_set_global_constants();
|
|
info.M = dd_CreateMatrix(24, 4);
|
|
info.M->representation = dd_Inequality;
|
|
info.M->numbtype = dd_Real;
|
|
info.M->objective = dd_LPmax;
|
|
|
|
enumerate_balanced_thickenings(dq, balanced_thickening_callback, &info);
|
|
|
|
dd_FreeMatrix(info.M);
|
|
weyl_destroy_bruhat(dq);
|
|
free(vector);
|
|
|
|
return 0;
|
|
}
|