int main(int argc, char * argv[]) {
clock_t start, end;
start = clock();
set_define(argv[1], argv[2], argv[3]);
struct itemStructArray *item = get_dataset();
struct itemListStructArray *result = apriori(item);
/*if(result->link == NULL) {
printf("只在第一層");
}
else {
show_largeItem_level1(result);
}
int counter;
if(result->link == NULL) {
counter = get_itemset_level2_counter(item);
}
else {
counter = get_itemset_counter(result);
}
printf("counter is: %d\n", counter);
*/
end = clock();
printf("%.2f\n", (end-start)/(double)(CLOCKS_PER_SEC));
return 0;
}
xmmsc_result_t *
xmmsc_visualization_start (xmmsc_connection_t *c, int vv)
{
xmmsc_result_t *res;
xmmsc_visualization_t *v;
x_check_conn (c, 0);
v = get_dataset (c, vv);
x_api_error_if (!v, "with unregistered/unconnected visualization dataset", 0);
switch (v->state) {
case VIS_WORKING:
case VIS_ERRORED:
break;
case VIS_NEW:
#ifdef HAVE_SEMTIMEDOP
/* first try unixshm */
v->type = VIS_UNIXSHM;
res = setup_shm_prepare (c, vv);
v->state = VIS_TRYING_UNIXSHM;
break;
#endif
case VIS_TO_TRY_UDP:
v->type = VIS_UDP;
res = setup_udp_prepare (c, vv);
v->state = VIS_TRYING_UDP;
break;
default:
v->state = VIS_ERRORED;
x_api_warning ("out of sequence");
break;
}
return res;
}
/* Return 0 if failed */
static int get_multiplicity(SPGCONST double lattice[3][3],
SPGCONST double position[][3],
const int types[],
const int num_atom,
const double symprec)
{
int size;
SpglibDataset *dataset;
size = 0;
dataset = NULL;
if ((dataset = get_dataset(lattice,
position,
types,
num_atom,
0,
symprec)) == NULL) {
return 0;
}
size = dataset->n_operations;
spg_free_dataset(dataset);
return size;
}
static int refine_cell(double lattice[3][3],
double position[][3],
int types[],
const int num_atom,
const double symprec)
{
int i, n_brv_atoms;
SpglibDataset *dataset;
n_brv_atoms = 0;
dataset = NULL;
if ((dataset = get_dataset(lattice,
position,
types,
num_atom,
0,
symprec)) == NULL) {
return 0;
}
n_brv_atoms = dataset->n_brv_atoms;
mat_copy_matrix_d3(lattice, dataset->brv_lattice);
for (i = 0; i < dataset->n_brv_atoms; i++) {
types[i] = dataset->brv_types[i];
mat_copy_vector_d3(position[i], dataset->brv_positions[i]);
}
spg_free_dataset(dataset);
return n_brv_atoms;
}
void HDF5DataWriter::recvData(const Eref&e,
ObjId src, const double* start, unsigned int num )
{
string path = src.path();
if (nodemap_.find(path) == nodemap_.end()){
// first time call, initialize entries in map
hid_t dataid = get_dataset(path);
if (dataid < 0){
cerr << "Warning: could not create data set for " << path << endl;
}
nodemap_[path] = dataid;
datamap_[path] = vector<double>();
}
const double * end = start + num;
// append only the new data. old_size is guaranteed to be 0 on
// write and the table vecs will also be cleared.
datamap_[path].insert(datamap_[path].end(), start, end);
SetGet0::set(src, "clearVec"); //Unsure what this is for.
// #ifndef NDEBUG
// // debug leftover entries coming from table
// cout << "HDF5DataWriter::recvData: vec_size=" << vec_size << endl;
// cout << "HDF5DataWriter::recvData: dataSize=" << pb.dataSize() << endl;
// cout << "HDF5DataWriter::recvData: numEntries=" << pb.numEntries() << endl;
// cout << "HDF5DataWriter::recvData: size=" << pb.size() << endl;
// cout << "HDF5DataWriter::recvData: data()" << endl;
// for (int ii = 0; ii <= vec_size; ++ii){
// cout << ii << "\t" << pb.data()[ii] << endl;
// }
// #endif
}
/*---------*/
static int get_ir_reciprocal_mesh(int grid_address[][3],
int map[],
const int mesh[3],
const int is_shift[3],
const int is_time_reversal,
SPGCONST double lattice[3][3],
SPGCONST double position[][3],
const int types[],
const int num_atom,
const double symprec)
{
SpglibDataset *dataset;
int num_ir, i;
MatINT *rotations;
dataset = get_dataset(lattice,
position,
types,
num_atom,
symprec);
rotations = mat_alloc_MatINT(dataset->n_operations);
for (i = 0; i < dataset->n_operations; i++) {
mat_copy_matrix_i3(rotations->mat[i], dataset->rotations[i]);
}
num_ir = kpt_get_irreducible_reciprocal_mesh(grid_address,
map,
mesh,
is_shift,
is_time_reversal,
rotations);
mat_free_MatINT(rotations);
spg_free_dataset(dataset);
return num_ir;
}
/*---------*/
SpglibDataset * spg_get_dataset(SPGCONST double lattice[3][3],
SPGCONST double position[][3],
const int types[],
const int num_atom,
const double symprec)
{
sym_set_angle_tolerance(-1.0);
return get_dataset(lattice,
position,
types,
num_atom,
symprec);
}
/* Return NULL if failed */
SpglibDataset *
spgat_get_dataset_with_hall_number(SPGCONST double lattice[3][3],
SPGCONST double position[][3],
const int types[],
const int num_atom,
const int hall_number,
const double symprec,
const double angle_tolerance)
{
sym_set_angle_tolerance(angle_tolerance);
return get_dataset(lattice,
position,
types,
num_atom,
hall_number,
symprec);
}
xmmsc_result_t *
setup_udp_prepare (xmmsc_connection_t *c, int32_t vv)
{
xmmsc_result_t *res;
xmmsc_visualization_t *v;
x_check_conn (c, 0);
v = get_dataset (c, vv);
res = xmmsc_send_cmd (c, XMMS_IPC_OBJECT_VISUALIZATION,
XMMS_IPC_CMD_VISUALIZATION_INIT_UDP,
XMMSV_LIST_ENTRY_INT (v->id),
XMMSV_LIST_END);
if (res) {
xmmsc_result_visc_set (res, v);
}
return res;
}
/* Return 0 if failed */
static int get_symmetry_from_dataset(int rotation[][3][3],
double translation[][3],
const int max_size,
SPGCONST double lattice[3][3],
SPGCONST double position[][3],
const int types[],
const int num_atom,
const double symprec)
{
int i, num_sym;
SpglibDataset *dataset;
num_sym = 0;
dataset = NULL;
if ((dataset = get_dataset(lattice,
position,
types,
num_atom,
0,
symprec)) == NULL) {
return 0;
}
if (dataset->n_operations > max_size) {
fprintf(stderr,
"spglib: Indicated max size(=%d) is less than number ", max_size);
fprintf(stderr,
"spglib: of symmetry operations(=%d).\n", dataset->n_operations);
goto ret;
}
num_sym = dataset->n_operations;
for (i = 0; i < num_sym; i++) {
mat_copy_matrix_i3(rotation[i], dataset->rotations[i]);
mat_copy_vector_d3(translation[i], dataset->translations[i]);
}
ret:
spg_free_dataset(dataset);
return num_sym;
}
xmmsc_result_t *
setup_shm_prepare (xmmsc_connection_t *c, int32_t vv)
{
xmmsc_result_t *res;
xmmsc_vischunk_t *buffer;
xmmsc_vis_unixshm_t *t;
xmmsc_visualization_t *v;
char shmidstr[32];
x_check_conn (c, 0);
v = get_dataset (c, vv);
t = &v->transport.shm;
/* prepare unixshm + semaphores */
/* following access modifiers imply everyone on the system could inject wrong vis data ;) */
t->shmid = shmget (IPC_PRIVATE, sizeof (xmmsc_vischunk_t) * XMMS_VISPACKET_SHMCOUNT, S_IRWXU + S_IRWXG + S_IRWXO);
if (t->shmid == -1) {
c->error = strdup ("Couldn't create the shared memory!");
return false;
}
/* attach early, so that the server doesn't think we aren't there */
buffer = shmat(t->shmid, NULL, SHM_RDONLY);
t->buffer = buffer;
/* we send it as string to make it work on 64bit systems.
Ugly? Yes, but works. */
snprintf (shmidstr, sizeof (shmidstr), "%d", t->shmid);
/* send packet */
res = xmmsc_send_cmd (c, XMMS_IPC_OBJECT_VISUALIZATION,
XMMS_IPC_COMMAND_VISUALIZATION_INIT_SHM,
XMMSV_LIST_ENTRY_INT (v->id),
XMMSV_LIST_ENTRY_STR (shmidstr),
XMMSV_LIST_END);
if (res) {
xmmsc_result_visc_set (res, v);
}
return res;
}
void HDF5DataWriter::flush()
{
if (filehandle_ < 0){
cerr << "HDF5DataWriter::flush() - Filehandle invalid. Cannot write data." << endl;
return;
}
for (map < string, vector < double > >::iterator ii = datamap_.begin(); ii != datamap_.end(); ++ ii){
hid_t dataset = nodemap_[ii->first];
if (dataset < 0){
dataset = get_dataset(ii->first);
nodemap_[ii->first] = dataset;
}
herr_t status = appendToDataset(dataset, ii->second);
if (status < 0){
cerr << "Warning: appending data for object " << ii->first << " returned status " << status << endl;
}
ii->second.clear();
}
H5Fflush(filehandle_, H5F_SCOPE_LOCAL);
}
/**
Write data to datasets in HDF5 file. Clear all data in the table
objects associated with this object. */
void HDF5DataWriter::process(const Eref & e, ProcPtr p)
{
if (filehandle_ < 0){
return;
}
// cout << "HDF5DataWriter::process: currentTime=" << p->currTime << endl;
requestOut()->send(e, recvDataBuf()->getFid());
for (map<string, vector < double > >:: iterator data_it = datamap_.begin(); data_it != datamap_.end(); ++data_it){
string path = data_it->first;
// if (data_it->second.size() >= flushLimit_){
map < string, hid_t >::iterator node_it = nodemap_.find(path);
assert (node_it != nodemap_.end());
if (node_it->second < 0){
nodemap_[path] = get_dataset(path);
}
herr_t status = appendToDataset(nodemap_[path], data_it->second);
if (status < 0){
cerr << "Warning: appending data for object " << data_it->first << " returned status " << status << endl;
}
data_it->second.clear();
}
}
int main(int argc, char * argv[]) {
float mTime;
clock_t start, end;
start = clock();
char *file_name = "1000k";
char *type = "rate";
char *rate = "3";
set_define(file_name, type, rate);
int *mItem = malloc(sizeof(int) * TRANSCATION_COUNT * SIZE_OF_ARRAY),
*item_counter = malloc(sizeof(int) * (ITEM_COUNT + 1)),
*item_index = malloc(sizeof(int) * (ITEM_COUNT + 1));
struct header_table *htable = malloc(sizeof(struct header_table));
struct header_table *head = malloc(sizeof(struct header_table));
get_dataset(mItem, item_counter, item_index);
struct node *fptree = malloc(sizeof(struct node));
fptree = create_fptree();
create_header_table(htable, head, item_index);
build_fptree(fptree, mItem, item_index, htable, head);
while(htable->next != NULL) htable = htable->next;
conditional_parrern_base(fptree, htable, item_counter, item_index, "");
end = clock();
mTime = (end-start) / (double) (CLOCKS_PER_SEC);
mTime = mTime * 1000;
printf("\nneed:%2.f millisecond \n", mTime);
return 0;
}
/* Return 0 if failed */
static int get_symmetry_with_collinear_spin(int rotation[][3][3],
double translation[][3],
int equivalent_atoms[],
const int max_size,
SPGCONST double lattice[3][3],
SPGCONST double position[][3],
const int types[],
const double spins[],
const int num_atom,
const double symprec)
{
int i, size;
Symmetry *symmetry, *sym_nonspin;
Cell *cell;
SpglibDataset *dataset;
size = 0;
symmetry = NULL;
sym_nonspin = NULL;
cell = NULL;
dataset = NULL;
if ((cell = cel_alloc_cell(num_atom)) == NULL) {
goto err;
}
cel_set_cell(cell, lattice, position, types);
if ((dataset = get_dataset(lattice,
position,
types,
num_atom,
0,
symprec)) == NULL) {
cel_free_cell(cell);
goto err;
}
if ((sym_nonspin = sym_alloc_symmetry(dataset->n_operations)) == NULL) {
spg_free_dataset(dataset);
cel_free_cell(cell);
goto err;
}
for (i = 0; i < dataset->n_operations; i++) {
mat_copy_matrix_i3(sym_nonspin->rot[i], dataset->rotations[i]);
mat_copy_vector_d3(sym_nonspin->trans[i], dataset->translations[i]);
}
spg_free_dataset(dataset);
if ((symmetry = spn_get_collinear_operations(equivalent_atoms,
sym_nonspin,
cell,
spins,
symprec)) == NULL) {
sym_free_symmetry(sym_nonspin);
cel_free_cell(cell);
goto err;
}
sym_free_symmetry(sym_nonspin);
if (symmetry->size > max_size) {
fprintf(stderr, "spglib: Indicated max size(=%d) is less than number ",
max_size);
fprintf(stderr, "spglib: of symmetry operations(=%d).\n", symmetry->size);
sym_free_symmetry(symmetry);
goto err;
}
for (i = 0; i < symmetry->size; i++) {
mat_copy_matrix_i3(rotation[i], symmetry->rot[i]);
mat_copy_vector_d3(translation[i], symmetry->trans[i]);
}
size = symmetry->size;
cel_free_cell(cell);
sym_free_symmetry(symmetry);
return size;
err:
return 0;
}
static int get_standardized_cell(double lattice[3][3],
double position[][3],
int types[],
const int num_atom,
const int to_primitive,
const double symprec)
{
int num_std_atom;
SpglibDataset *dataset;
Cell *std_cell, *cell;
Centering centering;
num_std_atom = 0;
dataset = NULL;
std_cell = NULL;
cell = NULL;
if ((dataset = get_dataset(lattice,
position,
types,
num_atom,
0,
symprec)) == NULL) {
goto err;
}
if (to_primitive) {
if ((centering = get_centering(dataset->hall_number)) == CENTERING_ERROR) {
goto err;
}
if (dataset->hall_number == 433 ||
dataset->hall_number == 436 ||
dataset->hall_number == 444 ||
dataset->hall_number == 450 ||
dataset->hall_number == 452 ||
dataset->hall_number == 458 ||
dataset->hall_number == 460) {
centering = R_CENTER;
}
} else {
centering = PRIMITIVE;
}
if ((cell = cel_alloc_cell(num_atom)) == NULL) {
spg_free_dataset(dataset);
goto err;
}
cel_set_cell(cell, lattice, position, types);
std_cell = spa_transform_to_primitive(cell,
dataset->transformation_matrix,
centering,
symprec);
spg_free_dataset(dataset);
cel_free_cell(cell);
if (std_cell == NULL) {
goto err;
}
set_cell(lattice, position, types, std_cell);
num_std_atom = std_cell->size;
cel_free_cell(std_cell);
return num_std_atom;
err:
return 0;
}
static int standardize_primitive(double lattice[3][3],
double position[][3],
int types[],
const int num_atom,
const double symprec)
{
int num_prim_atom;
Centering centering;
SpglibDataset *dataset;
Cell *primitive, *bravais;
double identity[3][3] = {{ 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 0, 1 }};
num_prim_atom = 0;
dataset = NULL;
primitive = NULL;
bravais = NULL;
if ((dataset = get_dataset(lattice,
position,
types,
num_atom,
0,
symprec)) == NULL) {
return 0;
}
if ((centering = get_centering(dataset->hall_number)) == CENTERING_ERROR) {
goto err;
}
if (dataset->hall_number == 433 ||
dataset->hall_number == 436 ||
dataset->hall_number == 444 ||
dataset->hall_number == 450 ||
dataset->hall_number == 452 ||
dataset->hall_number == 458 ||
dataset->hall_number == 460) {
centering = R_CENTER;
}
if ((bravais = cel_alloc_cell(dataset->n_std_atoms)) == NULL) {
spg_free_dataset(dataset);
return 0;
}
cel_set_cell(bravais,
dataset->std_lattice,
dataset->std_positions,
dataset->std_types);
spg_free_dataset(dataset);
primitive = spa_transform_to_primitive(bravais,
identity,
centering,
symprec);
cel_free_cell(bravais);
if (primitive == NULL) {
goto err;
}
set_cell(lattice, position, types, primitive);
num_prim_atom = primitive->size;
cel_free_cell(primitive);
return num_prim_atom;
err:
return 0;
}
