예제 #1
0
int 
scheduler_start(lua_State *L) {
	luaL_checktype(L,1,LUA_TTABLE);
	hive_createenv(L);
	struct global_queue * gmq = lua_newuserdata(L, sizeof(*gmq));
	globalmq_init(gmq);

	lua_pushvalue(L,-1);
	hive_setenv(L, "message_queue");

	lua_State *sL;

	sL = scheduler_newtask(L);
	luaL_requiref(sL, "cell.system", cell_system_lib, 0);
	lua_pop(sL,1);
	struct cell * sys = cell_new(sL, "system.lua");
	if (sys == NULL) {
		return 0;
	}
	scheduler_starttask(sL);
	lua_getfield(L,1, "thread");
	int thread = luaL_optinteger(L, -1, DEFAULT_THREAD);
	lua_pop(L,1);

	struct timer * t = lua_newuserdata(L, sizeof(*t));
	timer_init(t,sys,gmq);

	_start(gmq,thread,t);
	cell_close(sys);

	return 0;
}
예제 #2
0
static UnitCell *new_shifted_cell(UnitCell *input, int k, double shift)
{
	UnitCell *cell;
	double asx, asy, asz;
	double bsx, bsy, bsz;
	double csx, csy, csz;

	cell = cell_new();
	cell_get_reciprocal(input, &asx, &asy, &asz, &bsx, &bsy, &bsz,
	                    &csx, &csy, &csz);
	switch ( k )
	{
		case REF_ASX :  asx += shift;  break;
		case REF_ASY :  asy += shift;  break;
		case REF_ASZ :  asz += shift;  break;
		case REF_BSX :  bsx += shift;  break;
		case REF_BSY :  bsy += shift;  break;
		case REF_BSZ :  bsz += shift;  break;
		case REF_CSX :  csx += shift;  break;
		case REF_CSY :  csy += shift;  break;
		case REF_CSZ :  csz += shift;  break;
	}
	cell_set_reciprocal(cell, asx, asy, asz, bsx, bsy, bsz, csx, csy, csz);

	return cell;
}
예제 #3
0
void convert_lines(DataRow * row, std::vector<std::string> lines)
{
	std::vector<std::string>::iterator it = lines.begin();
	for (; it != lines.end(); it++) {
		DataCell * cell = cell_new(NULL, NULL);
		cell_set(cell, "", "", it->c_str(), 0);
		row_append(row, cell);
	}
}
예제 #4
0
파일: cell.c 프로젝트: keitaroyam/CrystFEL
UnitCell *cell_new_from_parameters(double a, double b, double c,
                                   double alpha, double beta, double gamma)
{
	UnitCell *cell;

	cell = cell_new();
	if ( cell == NULL ) return NULL;

	cell_set_parameters(cell, a, b, c, alpha, beta, gamma);

	return cell;
}
예제 #5
0
파일: query.c 프로젝트: darashi/groonga
inline static grn_cell *
cons(grn_query *q, grn_cell *car, grn_cell *cdr)
{
  grn_cell *c;
  if ((c = cell_new(q))) {
    c->header.type = GRN_CELL_LIST;
    c->u.l.car = car;
    c->u.l.cdr = cdr;
    return c;
  } else {
    return NIL;
  }
}
예제 #6
0
파일: query.c 프로젝트: darashi/groonga
inline static grn_cell *
op_new(grn_query *q, int8_t op, int16_t weight, int8_t mode, int32_t option)
{
  grn_cell *c;
  if ((c = cell_new(q))) {
    c->header.type = GRN_CELL_OP;
    c->u.op.op = op;
    c->u.op.weight = weight;
    c->u.op.mode = mode;
    c->u.op.option = option;
    return c;
  } else {
    return NIL;
  }
}
예제 #7
0
파일: cell.c 프로젝트: keitaroyam/CrystFEL
UnitCell *cell_new_from_direct_axes(struct rvec a, struct rvec b, struct rvec c)
{
	UnitCell *cell;

	cell = cell_new();
	if ( cell == NULL ) return NULL;

	cell->ax = a.u;  cell->ay = a.v;  cell->az = a.w;
	cell->bx = b.u;  cell->by = b.v;  cell->bz = b.w;
	cell->cx = c.u;  cell->cy = c.v;  cell->cz = c.w;

	cell->rep = CELL_REP_CART;

	return cell;
}
예제 #8
0
파일: query.c 프로젝트: darashi/groonga
inline static grn_cell *
token_new(grn_query *q, const char *start, const char *end)
{
  grn_cell *c;
  if (start >= end) { return NIL; }
  if ((c = cell_new(q))) {
    unsigned int len = end - start;
    c->header.type = GRN_CELL_STR;
    c->u.b.value = (char *)start;
    c->u.b.size = len;
    q->cur_expr++;
    return c;
  } else {
    return NIL;
  }
}
예제 #9
0
파일: cell.c 프로젝트: keitaroyam/CrystFEL
UnitCell *cell_new_from_reciprocal_axes(struct rvec as, struct rvec bs,
                                        struct rvec cs)
{
	UnitCell *cell;

	cell = cell_new();
	if ( cell == NULL ) return NULL;

	cell->axs = as.u;  cell->ays = as.v;  cell->azs = as.w;
	cell->bxs = bs.u;  cell->bys = bs.v;  cell->bzs = bs.w;
	cell->cxs = cs.u;  cell->cys = cs.v;  cell->czs = cs.w;

	cell->rep = CELL_REP_RECIP;

	return cell;
}
예제 #10
0
void convert_row(DataPage * page, std::vector<Cell> cells)
{
	if (cells.size() <= 0) {
		return;
	}
	
	DataRow * row = row_new(cells[0].key.row.c_str());
	std::vector<Hypertable::ThriftGen::Cell>::iterator it = cells.begin();
	int index = 1;
	for (; it != cells.end(); it++) {
		DataCell * cell = cell_new(NULL, NULL);
		cell_set(cell, it->key.column_family.c_str(),
				 it->key.column_qualifier.c_str(),
				 it->value.c_str(),
				 it->key.revision);
		row_append(row, cell);
		index++;
	}
	
	//add row
	page_append(page, row);
}
예제 #11
0
 NTSTATUS cell_connect_dn(struct likewise_cell **c, const char *dn)
{
	NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
	struct likewise_cell *new_cell = NULL;
	char *dns_domain = NULL;

	if (*c || !dn) {
		nt_status = NT_STATUS_INVALID_PARAMETER;
		BAIL_ON_NTSTATUS_ERROR(nt_status);
	}

	if ((new_cell = cell_new()) == NULL) {
		nt_status = NT_STATUS_NO_MEMORY;
		BAIL_ON_NTSTATUS_ERROR(nt_status);
	}

	/* Set the DNS domain, dn, etc ... and add it to the list */

	dns_domain = cell_dn_to_dns(dn);
	cell_set_dns_domain(new_cell, dns_domain);
	SAFE_FREE(dns_domain);

	cell_set_dn(new_cell, dn);

	nt_status = cell_connect(new_cell);
	BAIL_ON_NTSTATUS_ERROR(nt_status);

	*c = new_cell;

done:
	if (!NT_STATUS_IS_OK(nt_status)) {
		DEBUG(1,("LWI: Failled to connect to cell \"%s\" (%s)\n",
			 dn ? dn : "NULL", nt_errstr(nt_status)));
		talloc_destroy(new_cell);
	}

	return nt_status;
}
예제 #12
0
int main(int argc, char *argv[])
{
	int fail = 0;
	struct quaternion orientation;
	UnitCell *cell;
	double asx, asy, asz;
	double bsx, bsy, bsz;
	double csx, csy, csz;
	double asmag, bsmag, csmag;
	double als, bes, gas;
	double ax, ay, az;
	double bx, by, bz;
	double cx, cy, cz;
	gsl_rng *rng;

	rng = gsl_rng_alloc(gsl_rng_mt19937);

	cell = cell_new_from_parameters(27.155e-9, 28.155e-9, 10.987e-9,
	                                deg2rad(90.0),
	                                deg2rad(90.0),
	                                deg2rad(120.0));
	if ( cell == NULL ) return 1;

	orientation = random_quaternion(rng);
	cell = cell_rotate(cell, orientation);

	cell_get_reciprocal(cell, &asx, &asy, &asz,
	                          &bsx, &bsy, &bsz,
	                          &csx, &csy, &csz);

	asmag = sqrt(pow(asx, 2.0) + pow(asy, 2.0) + pow(asz, 2.0));
	bsmag = sqrt(pow(bsx, 2.0) + pow(bsy, 2.0) + pow(bsz, 2.0));
	csmag = sqrt(pow(csx, 2.0) + pow(csy, 2.0) + pow(csz, 2.0));

	als = angle_between(bsx, bsy, bsz, csx, csy, csz);
	bes = angle_between(asx, asy, asz, csx, csy, csz);
	gas = angle_between(asx, asy, asz, bsx, bsy, bsz);

	STATUS("Separation between (100) planes = %5.2f nm\n", 1e9/asmag);
	STATUS("Separation between (010) planes = %5.2f nm\n", 1e9/bsmag);
	STATUS("Separation between (001) planes = %5.2f nm\n", 1e9/csmag);
	STATUS("Angle between (100) and (010) planes = %5.2f deg\n",
	       rad2deg(gas));
	STATUS("Angle between (100) and (001) planes = %5.2f deg\n",
	       rad2deg(bes));
	STATUS("Angle between (010) and (001) planes = %5.2f deg\n",
	       rad2deg(als));

	cell_free(cell);

	cell = cell_new();
	if ( cell == NULL ) return 1;

	cell_set_reciprocal(cell, asx, asy, asz, bsx, bsy, bsz, csx, csy, csz);
	cell_print(cell);

	cell_get_cartesian(cell, &ax, &ay, &az,
	                         &bx, &by, &bz,
	                         &cx, &cy, &cz);

	STATUS("Cell choice 1:\n");
	cell_set_cartesian(cell, ax, ay, az,
	                         bx, by, bz,
	                         cx, cy, cz);
	cell_print(cell);

	STATUS("Cell choice 2:\n");
	cell_set_cartesian(cell, bx, by, bz,
	                         -ax-bx, -ay-by, -az-bz,
	                         cx, cy, cz);
	cell_print(cell);


	STATUS("Cell choice 3:\n");
	cell_set_cartesian(cell, -ax-bx, -ay-by, -az-bz,
	                         ax, ay, az,
	                         cx, cy, cz);
	cell_print(cell);

	gsl_rng_free(rng);

	return fail;
}
예제 #13
0
파일: main.c 프로젝트: gitter-badger/good
int main() {
    cell_new();
}