void StreamTimerListe::Serialize( Json::Value& root )
{
// serialize primitives
unsigned int size = LD_StreamListe.size();
//Json::Value timer_value(Json::arrayValue); // []
//arr_value.append("Test1");
//arr_value.append("Test2");
Json::Value obj_value(Json::objectValue);
for(unsigned int i=0; i<size; i++)
{
obj_value["STREAM"]["LDNAME"] = LD_StreamListe[i].getLdName();
obj_value["STREAM"]["LDNUMBER"] = LD_StreamListe[i].getLdNumber();
obj_value["STREAM"]["LDI2CCHANNEL"] = LD_StreamListe[i].getLdI2cChannel();
for (int ii=0;ii<TIMERSTORECOUNT;ii++)
{
obj_value["STREAM"]["LDTIMEARRAY"].append(LD_StreamListe[i].getLdTimeArray()[ii]);
}
obj_value["STREAM"]["CHARTCOLOR"]= LD_StreamListe[i].getChartColor();
root["StreamListe"].append(obj_value);
obj_value.clear();
obj_value["STREAM"]["LDTIMEARRAY"].clear();
}
// version tag into stream
root["version"] = c_fileversion;
}
struct object *
pic_obj_alloc(pic_state *pic, int type)
{
struct object *obj;
obj = pic_obj_alloc_unsafe(pic, type);
pic_protect(pic, obj_value(pic, obj));
return obj;
}
int queryType(char *http_payload) {
debug("Find out query type");
if (http_payload == NULL) {
return -1;
}
std::string http_payload_str(http_payload);
Json::Reader reader = Json::Reader();
size_t pLastKey, pValue, pNextKey;
std::map<std::string, std::string> content;
pLastKey = 0;
while (true) {
pValue = http_payload_str.find('=', pLastKey);
pNextKey = http_payload_str.find('&', pValue);
std::string key = http_payload_str.substr(pLastKey, pValue - pLastKey);
std::string value = http_payload_str.substr(pValue + 1, pNextKey == std::string::npos ? pNextKey : pNextKey - pValue -1);
content.emplace(key, urlDecode(value));
if (pNextKey == std::string::npos) break;
pLastKey = pNextKey + 1;
}
std::string &query_str = content.at("query");
std::unique_ptr<Json::Value> root (new Json::Value);
if (reader.parse(query_str, (*root)) == false) {
log_err("Error parsing json: %s", reader.getFormattedErrorMessages().c_str());
debug("HTTP payload was %s", http_payload);
return -1;
}
std::unique_ptr<Json::Value> query = std::move(root);
Json::Value operators;
Json::Value obj_value(Json::objectValue);
if (!query->isObject() || query->isMember("operators") == false) {
log_err("query content does not contain any operators");
throw "query content does not contain any operators";
}
operators = query->get("operators", obj_value);
for (auto op: operators) {
auto type = op.get("type", "").asString();
if (type == "InsertScan" or
type == "Delete" or
type == "PosUpdateIncrementScan" or
type == "PosUpdateScan") {
return WRITE;
}
if (type == "TableLoad") {
return LOAD;
}
}
return READ;
}
pic_value
pic_data_value(pic_state *pic, void *userdata, const pic_data_type *type)
{
struct data *data;
data = (struct data *)pic_obj_alloc(pic, PIC_TYPE_DATA);
data->type = type;
data->data = userdata;
return obj_value(pic, data);
}
pic_value
pic_blob_value(pic_state *pic, const unsigned char *buf, int len)
{
struct blob *bv;
bv = (struct blob *)pic_obj_alloc(pic, PIC_TYPE_BLOB);
bv->data = pic_malloc(pic, len);
bv->len = len;
if (buf) {
memcpy(bv->data, buf, len);
}
return obj_value(pic, bv);
}
int RoundRobinDistributor::parseQuery(std::unique_ptr<Json::Value> query) {
bool writeQuery = false;
Json::Value operators;
Json::Value obj_value(Json::objectValue);
if (!query->isObject() || query->isMember("operators") == false) {
std::cerr << "query content does not contain any operators";
return -1;
}
operators = query->get("operators", obj_value);
for (auto op: operators) {
auto type = op.get("type", "").asString();
if (type == "InsertScan" or type == "Delete" or type == "PosUpdateIncrementScan" or type == "PosUpdateScan") writeQuery = true;
if (type == "TableLoad") return 2;
}
if (writeQuery) return 1;
return 0;
}
void StreamTimerListe::SerializeAjax( Json::Value& root )
{
// serialize primitives
int size = LD_StreamListe.size();
Json::Value timer_value(Json::arrayValue); // []
Json::Value row(Json::arrayValue);
Json::Value rowitem(Json::arrayValue);
Json::Value rowdata(Json::arrayValue);
Json::Value ledvalues(Json::arrayValue);
Json::Value zeile(Json::objectValue);
//arr_value.append("Test1");
//arr_value.append("Test2");
Json::Value obj_value(Json::objectValue);
for(int i=0; i<size; i++)
{
for (int ii=0;ii<TIMERSTORECOUNT;ii++)
{
ledvalues.append(LD_StreamListe[i].getLdTimeArray()[ii]);
}
zeile["id"] = LD_StreamListe[i].getLdNumber();
rowitem.append(LD_StreamListe[i].getLdNumber());
rowitem.append(LD_StreamListe[i].getLdName());
rowitem.append(LD_StreamListe[i].getLdI2cChannel());
rowitem.append(ledvalues);
rowitem.append(LD_StreamListe[i].getChartColor());
zeile["cell"] = rowitem;
root["StreamListe"].append(zeile);
ledvalues.clear();
rowitem.clear();
}
// version tag into stream
root["version"] = "2.0";
root["fooddelay"] = FOOD_DELAY; // Time in Sec that the streams are in food mode
root["foodpower"] = FOOD_MIN_POWER;
}
//' @title Master Wrapper for the GMWM Estimator
//' @description This function generates WV, GMWM Estimator, and an initial test estimate.
//' @param data A \code{vec} containing the data.
//' @param theta A \code{vec} with dimensions N x 1 that contains user-supplied initial values for parameters
//' @param desc A \code{vector<string>} indicating the models that should be considered.
//' @param objdesc A \code{field<vec>} containing a list of parameters (e.g. AR(1) = c(1,1), ARMA(p,q) = c(p,q,1))
//' @param model_type A \code{string} that represents the model transformation
//' @param starting A \code{bool} that indicates whether the supplied values are guessed (T) or are user-based (F).
//' @param alpha A \code{double} that handles the alpha level of the confidence interval (1-alpha)*100
//' @param compute_v A \code{string} that describes what kind of covariance matrix should be computed.
//' @param K An \code{int} that controls how many times theta is updated.
//' @param H An \code{int} that controls how many bootstrap replications are done.
//' @param G An \code{int} that controls how many guesses at different parameters are made.
//' @param robust A \code{bool} that indicates whether the estimation should be robust or not.
//' @param eff A \code{double} that specifies the amount of efficiency required by the robust estimator.
//' @return A \code{field<mat>} that contains a list of ever-changing estimates...
//' @author JJB
//' @references Wavelet variance based estimation for composite stochastic processes, S. Guerrier and Robust Inference for Time Series Models: a Wavelet-Based Framework, S. Guerrier
//' @keywords internal
//' @export
//' @backref src/gmwm_logic.cpp
//' @backref src/gmwm_logic.h
// [[Rcpp::export]]
arma::field<arma::mat> gmwm_master_cpp(arma::vec& data,
arma::vec theta,
const std::vector<std::string>& desc, const arma::field<arma::vec>& objdesc,
std::string model_type, bool starting,
double alpha,
std::string compute_v, unsigned int K, unsigned int H,
unsigned int G,
bool robust, double eff){
// Obtain counts of the different models we need to work with
std::map<std::string, int> models = count_models(desc);
// HACK METHOD (todo: formalize it)
// Determine if we need to difference
if(models["SARIMA"] > 0){
// Note: s, i, si are 6,7,8 => 5,6,7
for(unsigned int i = 0; i < desc.size(); i ++){
if(objdesc(i).n_elem > 3){
arma::vec sarima_desc = objdesc(i);
// Do we need to difference?
if(sarima_desc(6) > 0 || sarima_desc(7) > 0){
// Perform differencing in specific order...
// First non-seasonal and then seasonal.
if(sarima_desc(6) > 0){
// Lag is always 1, number of differences is (i)
data = diff_cpp(data, 1, sarima_desc(6));
}
if(sarima_desc(7) > 0){
// Lag is always seasonality (s) and differences is (si).
data = diff_cpp(data, sarima_desc(5), sarima_desc(7));
}
// Kill loop. We only handle the tsmodel object with the first difference.
break;
}
}
}
}
// ------ Variable Declarations
// Length of the Time Series
unsigned int N = data.n_elem;
// Number of Scales (J)
unsigned int nlevels = floor(log2(N));
// Number of parameters
unsigned int np = theta.n_elem;
// Take the mean of the first difference
double expect_diff = mean_diff(data);
// Guessed values of Theta (user supplied or generated)
arma::vec guessed_theta = theta;
// MODWT decomp
arma::field<arma::vec> modwt_decomp = modwt_cpp(data, "haar", nlevels, "periodic", true);
// Obtain WV and confidence intervals
arma::mat wvar = wvar_cpp(modwt_decomp, robust, eff, alpha, "eta3");
// Extract
arma::vec wv_empir = wvar.col(0);
arma::vec ci_lo = wvar.col(1);
arma::vec ci_hi = wvar.col(2);
//-------------------------
// Obtain Covariance Matrix
//-------------------------
arma::mat V;
// compute_cov_cpp is the hard core function. It can only be improved by using parallelization.
if(compute_v == "diag" || compute_v == "full"){
arma::field<arma::mat> Vout = compute_cov_cpp(modwt_decomp, nlevels, compute_v, robust, eff);
if(robust){
V = Vout(1);
}else{
V = Vout(0);
}
}else{
V = fast_cov_cpp(wvar.col(2), wvar.col(1));
}
// Obtain the Omega matrix
arma::mat omega = arma::inv(diagmat(V));
// Store the original V matrix (in case of bootstrapping) for use in the update function
arma::mat orgV = V;
// Calculate the values of the Scales
arma::vec scales = scales_cpp(nlevels);
// Min-Max / N
double ranged = dr_slope(data);
// Guess starting values for the theta parameters
if(starting){
// Always run guessing algorithm
theta = guess_initial(desc, objdesc, model_type, np, expect_diff, N, wvar, scales, ranged, G);
// If under ARMA case and only ARMA is in the model,
// then see how well these values are.
if(desc.size() == 1 && (desc[0] == "SARIMA" || desc[0] == "ARMA11") && N <= 1000){
// Use R's ARIMA function to estimate parameter space
arma::vec theta2 = Rcpp_ARIMA(data, objdesc(0)); // Only 1 objdesc in the available.
// Obtain the obj function under omega with these initial guesses
// DO >>NOT<< USE Yannick's to optimize starting values!!!!
double mle_css_obj = getObjFun(theta2, desc, objdesc, model_type, omega, wv_empir, scales);
// Obtain the objective function under Yannick's starting algorithm
double init_guess_obj = getObjFunStarting(theta, desc, objdesc, model_type, wv_empir, scales);
// What performs better?
if(mle_css_obj < init_guess_obj){
// Disable starting value optimization if using MLE.
theta = theta2;
starting = false;
}
}
guessed_theta = theta;
}
// Obtain the GMWM estimator's estimates.
theta = gmwm_engine(theta, desc, objdesc, model_type,
wv_empir, omega, scales, starting);
// Optim may return a very small value. In this case, instead of saying its zero (yielding a transform issue), make it EPSILON.
theta = code_zero(theta);
// Enable bootstrapping
if(compute_v == "bootstrap"){
for(unsigned int k = 0; k < K; k++){
// Create the full V matrix
V = cov_bootstrapper(theta, desc, objdesc, N, robust, eff, H, false);
// Update the omega matrix
omega = arma::inv(diagmat(V));
// The theta update in this case MUST not use Yannick's starting algorithm. Hence, the false value.
theta = gmwm_engine(theta, desc, objdesc, model_type, wv_empir, omega, scales, false);
// Optim may return a very small value. In this case, instead of saying its zero (yielding a transform issue), make it EPSILON.
theta = code_zero(theta);
}
}
if(desc[0] == "SARIMA" && desc.size() == 1){
arma::vec temp = objdesc(0);
unsigned int p = temp(0);
if(p != 0 && invert_check(arma::join_cols(arma::ones<arma::vec>(1), -theta.rows(0, p - 1))) == false){
Rcpp::Rcout << "WARNING: This ARMA model contains AR coefficients that are NON-STATIONARY!" << std::endl;
}
}
// Order AR1s / GM so largest phi is first!
if(models["AR1"] > 1 || models["GM"] > 1){
theta = order_AR1s(theta, desc, objdesc);
}
// Obtain the objective value function
arma::vec obj_value(1);
obj_value(0) = getObjFun(theta, desc, objdesc, model_type, omega, wv_empir, scales);
arma::vec dr_s(1);
dr_s(0) = ranged;
// Decomposition of the WV.
arma::mat decomp_theo = decomp_theoretical_wv(theta, desc, objdesc, scales);
arma::vec theo = decomp_to_theo_wv(decomp_theo);
// Export information back
arma::field<arma::mat> out(13);
out(0) = theta;
out(1) = guessed_theta;
out(2) = wv_empir;
out(3) = ci_lo;
out(4) = ci_hi;
out(5) = V;
out(6) = orgV;
out(7) = expect_diff;
out(8) = theo;
out(9) = decomp_theo;
out(10) = obj_value;
out(11) = omega;
out(12) = dr_s;
return out;
}
//' @title Update Wrapper for the GMWM Estimator
//' @description This function uses information obtained previously (e.g. WV covariance matrix) to re-estimate a different model parameterization
//' @param theta A \code{vec} with dimensions N x 1 that contains user-supplied initial values for parameters
//' @param desc A \code{vector<string>} indicating the models that should be considered.
//' @param objdesc A \code{field<vec>} containing a list of parameters (e.g. AR(1) = c(1,1), ARMA(p,q) = c(p,q,1))
//' @param model_type A \code{string} that represents the model transformation
//' @param wv_empir A \code{vec} that contains the empirical wavelet variance
//' @param omega A \code{mat} that represents the covariance matrix.
//' @param scales A \code{vec} that contains the scales or taus (2^(1:J))
//' @param starting A \code{bool} that indicates whether we guessed starting (T) or the user supplied estimates (F).
//' @return A \code{field<mat>} that contains the parameter estimates from GMWM estimator.
//' @author JJB
//' @references Wavelet variance based estimation for composite stochastic processes, S. Guerrier and Robust Inference for Time Series Models: a Wavelet-Based Framework, S. Guerrier
//' @keywords internal
//' @backref src/gmwm_logic.cpp
//' @backref src/gmwm_logic.h
// [[Rcpp::export]]
arma::field<arma::mat> gmwm_update_cpp(arma::vec theta,
const std::vector<std::string>& desc, const arma::field<arma::vec>& objdesc,
std::string model_type, unsigned int N, double expect_diff, double ranged,
const arma::mat& orgV, const arma::vec& scales, const arma::mat& wv,
bool starting,
std::string compute_v, unsigned int K, unsigned int H,
unsigned int G,
bool robust, double eff){
// Number of parameters
unsigned int np = theta.n_elem;
// Guessed Values
arma::vec guessed_theta = theta;
// V matrix
arma::mat V = orgV;
// Diagonal Omega Matrix
arma::mat omega = arma::inv(diagmat(V));
arma::vec wv_empir = wv.col(0);
// Do we need to run a guessing algorithm?
if(starting){
theta = guess_initial(desc, objdesc, model_type, np, expect_diff, N, wv, scales, ranged, G);
guessed_theta = theta;
}
// Obtain the GMWM estimator estimates.
theta = gmwm_engine(theta, desc, objdesc, model_type,
wv_empir, omega, scales, starting);
theta = code_zero(theta);
// Bootstrap the V matrix
if(compute_v == "bootstrap"){
for(unsigned int k = 0; k < K; k++){
// False here means we create the "full V" matrix
V = cov_bootstrapper(theta, desc, objdesc, N, robust, eff, H, false);
omega = arma::inv(diagmat(V));
// The theta update in this case MUST not use Yannick's starting algorithm. Hence, the false value.
theta = gmwm_engine(theta, desc, objdesc, model_type, wv_empir, omega, scales, false);
// Optim may return a very small value. In this case, instead of saying its zero (yielding a transform issue), make it EPSILON.
theta = code_zero(theta);
}
}
std::map<std::string, int> models = count_models(desc);
// Order AR1s so largest phi is first!
if(models["AR1"] > 1 || models["GM"] > 1){
theta = order_AR1s(theta, desc, objdesc);
}
// Obtain the theoretical WV.
arma::mat decomp_theo = decomp_theoretical_wv(theta, desc, objdesc, scales);
arma::vec theo = decomp_to_theo_wv(decomp_theo);
// Obtain the objective value function
arma::vec obj_value(1);
obj_value(0) = getObjFun(theta, desc, objdesc, model_type, omega, wv_empir, scales);
// Export calculations to R.
arma::field<arma::mat> out(6);
out(0) = theta;
out(1) = guessed_theta;
out(2) = V;
out(3) = theo;
out(4) = decomp_theo;
out(5) = obj_value;
return out;
}
static void
gc_finalize_object(pic_state *pic, struct object *obj)
{
switch (obj_type(pic, obj)) {
case PIC_TYPE_VECTOR: {
pic_free(pic, obj->u.vec.data);
break;
}
case PIC_TYPE_BLOB: {
pic_free(pic, obj->u.blob.data);
break;
}
case PIC_TYPE_STRING: {
pic_rope_decref(pic, obj->u.str.rope);
break;
}
case PIC_TYPE_DATA: {
if (obj->u.data.type->dtor) {
obj->u.data.type->dtor(pic, obj->u.data.data);
}
break;
}
case PIC_TYPE_DICT: {
kh_destroy(dict, &obj->u.dict.hash);
break;
}
case PIC_TYPE_SYMBOL: {
/* TODO: remove this symbol's entry from pic->syms immediately */
break;
}
case PIC_TYPE_WEAK: {
kh_destroy(weak, &obj->u.weak.hash);
break;
}
case PIC_TYPE_IREP: {
struct irep *irep = &obj->u.irep;
if ((irep->flags & IREP_CODE_STATIC) == 0) {
pic_free(pic, (code_t *) irep->code);
}
pic_free(pic, irep->obj);
pic_free(pic, irep->irep);
break;
}
case PIC_TYPE_PORT: {
pic_fclose(pic, obj_value(pic, obj)); /* FIXME */
break;
}
case PIC_TYPE_FRAME: {
pic_free(pic, obj->u.frame.regs);
break;
}
case PIC_TYPE_PAIR:
case PIC_TYPE_ERROR:
case PIC_TYPE_RECORD:
case PIC_TYPE_PROC_FUNC:
case PIC_TYPE_PROC_IREP:
break;
default:
PIC_UNREACHABLE();
}
}
static void
gc_mark_object(pic_state *pic, struct object *obj)
{
loop:
if (is_alive(obj))
return;
mark(obj);
#define LOOP(o) obj = (struct object *)(o); goto loop
switch (obj_type(pic, obj)) {
case PIC_TYPE_PAIR: {
gc_mark(pic, obj->u.pair.car);
if (obj_p(pic, obj->u.pair.cdr)) {
LOOP(obj_ptr(pic, obj->u.pair.cdr));
}
break;
}
case PIC_TYPE_FRAME: {
int i;
for (i = 0; i < obj->u.frame.regc; ++i) {
gc_mark(pic, obj->u.frame.regs[i]);
}
if (obj->u.frame.up) {
LOOP(obj->u.frame.up);
}
break;
}
case PIC_TYPE_PROC_FUNC: {
if (obj->u.proc.env) {
LOOP(obj->u.proc.env);
}
break;
}
case PIC_TYPE_PROC_IREP: {
if (obj->u.proc.env) {
gc_mark_object(pic, (struct object *)obj->u.proc.env);
}
LOOP(obj->u.proc.u.irep);
break;
}
case PIC_TYPE_IREP: {
size_t i;
for (i = 0; i < obj->u.irep.objc; ++i) {
gc_mark(pic, obj->u.irep.obj[i]);
}
for (i = 0; i < obj->u.irep.irepc; ++i) {
gc_mark_object(pic, (struct object *)obj->u.irep.irep[i]);
}
break;
}
case PIC_TYPE_PORT: {
break;
}
case PIC_TYPE_ERROR: {
gc_mark_object(pic, (struct object *)obj->u.err.type);
gc_mark(pic, obj->u.err.irrs);
LOOP(obj->u.err.msg);
break;
}
case PIC_TYPE_STRING: {
break;
}
case PIC_TYPE_VECTOR: {
int i;
for (i = 0; i < obj->u.vec.len; ++i) {
gc_mark(pic, obj->u.vec.data[i]);
}
break;
}
case PIC_TYPE_BLOB: {
break;
}
case PIC_TYPE_DATA: {
break;
}
case PIC_TYPE_DICT: {
pic_value key, val;
int it = 0;
while (pic_dict_next(pic, obj_value(pic, &obj->u.dict), &it, &key, &val)) {
gc_mark(pic, key);
gc_mark(pic, val);
}
break;
}
case PIC_TYPE_RECORD: {
gc_mark(pic, obj->u.rec.datum);
LOOP(obj->u.rec.type);
break;
}
case PIC_TYPE_SYMBOL: {
LOOP(obj->u.sym.str);
break;
}
case PIC_TYPE_WEAK: {
struct weak *weak = (struct weak *)obj;
weak->prev = pic->heap->weaks;
pic->heap->weaks = weak;
break;
}
default:
PIC_UNREACHABLE();
}
}
pic_state *
pic_open(pic_allocf allocf, void *userdata)
{
pic_state *pic;
pic = allocf(userdata, NULL, sizeof(pic_state));
if (! pic) {
goto EXIT_PIC;
}
/* allocator */
pic->allocf = allocf;
/* user data */
pic->userdata = userdata;
/* context */
pic->default_cxt.ai = 0;
pic->default_cxt.pc = NULL;
pic->default_cxt.fp = NULL;
pic->default_cxt.sp = NULL;
pic->default_cxt.irep = NULL;
pic->default_cxt.prev = NULL;
pic->cxt = &pic->default_cxt;
/* arena */
pic->arena = allocf(userdata, NULL, PIC_ARENA_SIZE * sizeof(struct object *));
pic->arena_size = PIC_ARENA_SIZE;
pic->ai = 0;
if (! pic->arena) {
goto EXIT_ARENA;
}
/* turn off GC */
pic->gc_enable = false;
/* memory heap */
pic->heap = pic_heap_open(pic);
/* symbol table */
kh_init(oblist, &pic->oblist);
/* global variables */
pic->globals = pic_make_dict(pic);
/* features */
pic->features = pic_nil_value(pic);
/* dynamic environment */
pic->dyn_env = pic_list(pic, 1, pic_make_weak(pic));
/* top continuation */
{
static const code_t halt_code[] = { 0x00 };
struct irep *irep;
struct proc *proc;
irep = (struct irep *)pic_obj_alloc(pic, PIC_TYPE_IREP);
irep->argc = 1;
irep->flags = IREP_CODE_STATIC;
irep->frame_size = 1;
irep->irepc = 0;
irep->objc = 0;
irep->irep = NULL;
irep->obj = NULL;
irep->code = halt_code;
irep->codec = sizeof halt_code / sizeof halt_code[0];
proc = (struct proc *)pic_obj_alloc(pic, PIC_TYPE_PROC_IREP);
proc->u.irep = irep;
proc->env = NULL;
pic->halt = obj_value(pic, proc);
}
/* panic handler */
pic->panicf = NULL;
/* turn on GC */
pic->gc_enable = true;
pic_init_core(pic);
pic_leave(pic, 0); /* empty arena */
return pic;
EXIT_ARENA:
allocf(userdata, pic, 0);
EXIT_PIC:
return NULL;
}
/*
* Describe the kind
*/
static void kind_info(char *buf, char *dam, char *wgt, int *lev, s32b *val, int k)
{
object_type forge;
object_type *q_ptr;
/* Get local object */
q_ptr = &forge;
/* Prepare a fake item */
object_prep(q_ptr, k);
/* It is known */
q_ptr->ident |= (IDENT_KNOWN);
/* Cancel bonuses */
q_ptr->pval = 0;
q_ptr->to_a = 0;
q_ptr->to_h = 0;
q_ptr->to_d = 0;
/* Level */
(*lev) = k_info[q_ptr->k_idx].level;
/* Value */
(*val) = obj_value(q_ptr);
/* Hack */
if (!buf || !dam || !wgt) return;
/* Description (too brief) */
object_desc(buf, q_ptr, (OD_NAME_ONLY | OD_STORE));
/* Misc info */
strcpy(dam, "");
/* Damage */
switch (q_ptr->tval)
{
/* Bows */
case TV_BOW:
{
break;
}
/* Ammo */
case TV_SHOT:
case TV_BOLT:
case TV_ARROW:
{
sprintf(dam, "%dd%d", q_ptr->dd, q_ptr->ds);
break;
}
/* Weapons */
case TV_HAFTED:
case TV_POLEARM:
case TV_SWORD:
case TV_DIGGING:
{
sprintf(dam, "%dd%d", q_ptr->dd, q_ptr->ds);
break;
}
/* Armour */
case TV_BOOTS:
case TV_GLOVES:
case TV_CLOAK:
case TV_CROWN:
case TV_HELM:
case TV_SHIELD:
case TV_SOFT_ARMOR:
case TV_HARD_ARMOR:
case TV_DRAG_ARMOR:
{
sprintf(dam, "%d", q_ptr->ac);
break;
}
}
/* Weight */
sprintf(wgt, "%3d.%d", q_ptr->weight / 10, q_ptr->weight % 10);
}
