void reset(T *tree,
int data_num,
const AzBytArr *inp_s_temp_prefix) {
reset();
if (inp_s_temp_prefix == NULL || inp_s_temp_prefix->length() <= 0) {
return;
}
s_temp_prefix.reset(inp_s_temp_prefix);
unit_size = tree->estimateSizeofDataIndexes(data_num);
if (unit_size <= 0) {
return;
}
if (unit_size > max_size) {
throw new AzException(AzInputError, "AzTemp_forTrTreeEns::reset",
"Data size is too large.");
}
open_new_file();
}
virtual void show_stat(AzBytArr &s) const {
if (p.typ == AzpActivDflt_None) return;
if (!p.do_stat) return;
AzDvect my_v_pop(&v_pop_last);
my_v_pop.normalize1();
s.nl();
double accum = 0;
int ix;
for (ix = 0; ix < my_v_pop.rowNum(); ++ix) {
accum += my_v_pop.get(ix);
s.c("b"); s.cn(v_border.get(ix)); s.c("="); s.cn(my_v_pop.get(ix),3); s.c("("); s.cn(accum,3); s.c("),");
}
}
/*--------------------------------------------------------*/
void AzTreeEnsemble::show_weights(const AzOut &out, AzSvFeatInfo *fi) const
{
AzIIFarr iifa_tx_nx_posiw, iifa_tx_nx_negaw;
int tx;
for (tx = 0; tx < t_num; ++tx) {
int nx;
for (nx = 0; nx < t[tx]->nodeNum(); ++nx) {
const AzTreeNode *np = t[tx]->node(nx);
if (np->weight > 0) {
iifa_tx_nx_posiw.put(tx, nx, np->weight);
}
else if (np->weight < 0) {
iifa_tx_nx_negaw.put(tx, nx, np->weight);
}
}
}
iifa_tx_nx_posiw.sort_Float(false); /* descending order */
iifa_tx_nx_negaw.sort_Float(true); /* ascending order */
AzPrint::writeln(out, "Positive weights -------------------");
int ix;
for (ix = 0; ix < iifa_tx_nx_posiw.size(); ++ix) {
int tx, nx;
double w = iifa_tx_nx_posiw.get(ix, &tx, &nx);
AzBytArr s_desc;
t[tx]->genDesc(fi, nx, &s_desc);
AzBytArr s; s.cn(w, 6, false); s.c(' '); s.c(&s_desc);
AzPrint::writeln(out, s);
}
AzPrint::writeln(out, "Negative weights -------------------");
for (ix = 0; ix < iifa_tx_nx_negaw.size(); ++ix) {
int tx, nx;
double w = iifa_tx_nx_negaw.get(ix, &tx, &nx);
AzBytArr s_desc;
t[tx]->genDesc(fi, nx, &s_desc);
AzBytArr s; s.cn(w, 6, false); s.c(' '); s.c(&s_desc);
AzPrint::writeln(out, s);
}
}
inline void reset(const AzTreeRule *inp) {
ba.reset();
if (inp == NULL) return;
ba.reset(&inp->ba);
}
inline void print_space(int len) {
AzBytArr s; s.fill(' ', len);
print(s);
}
static inline void writeln(const AzOut &out, const AzBytArr &s) {
writeln(out, s.c_str());
}
inline void writeln(const AzBytArr &s) {
if (o == NULL) return;
*o<<s.c_str()<<endl;
}
inline void inParen(const AzBytArr &s) {
if (o == NULL) return;
inParen(s.c_str());
}
inline void inBrackets(int val, int width=-1, bool doFillZero=false) {
if (o == NULL) return;
itemBegin();
AzBytArr s; inBrackets(&s, val, width, doFillZero);
*o<<s.c_str();
}
inline void printV_if_not_empty(const char *kw, const AzBytArr &s) {
if (o == NULL) return;
if (s.length() <= 0) return;
itemBegin();
*o<<kw<<s.c_str();
}
void reset() {
unit_size = -1;
s_temp_prefix.reset();
pool_file.reset();
}
inline const char *param_c_str() const {
return s_param.c_str();
}
void throw_if_empty(const char *kw, const AzBytArr &s) const {
if (s.length() <= 0) throw new AzException(AzInputError, "AzsLinear::resetParam", kw, "must be specified.");
}
inline void finalize() {
if (ba.getLen() == 0) {
ba.concat('_'); /* root node (CONST) */
}
}
inline void append(const AzTreeRule *inp) {
if (inp != NULL) {
ba.concat(&inp->ba);
}
}
inline static void print(int number, const char *msg, const AzOut &out) {
AzBytArr s; s.cn(number);
print(s.c_str(), msg, out);
}
inline void printV(const char *kw, const AzBytArr &s) {
if (o == NULL) return;
itemBegin();
*o<<kw<<s.c_str();
}
void setup_no_activation() {
s_activ_typ.reset("None");
typ = 'N';
trunc = -1;
}
/*-------------------*/
inline void print(const AzBytArr &s) {
if (o == NULL) return;
print(s.c_str());
}
virtual void write(AzFile *file) {
AzTools::write_header(file, version, reserved_len);
s_activ_typ.write(file);
file->writeByte(typ);
file->writeDouble(trunc);
}
inline void inBrackets(double val, int prec=-1, bool doSci=false) {
if (o == NULL) return;
itemBegin();
AzBytArr s; inBrackets(&s, val, prec, doSci);
*o<<s.c_str();
}
virtual void read(AzFile *file) {
AzTools::read_header(file, reserved_len);
s_activ_typ.read(file);
typ = file->readByte();
trunc = file->readDouble();
}
inline void inBrackets(const AzBytArr &s) {
if (o == NULL) return;
inBrackets(s.c_str());
}
/*-------------------------------------------------------------------------*/
int AzTools_text::replace_utf8dashes(AzByte *data, int len) /* inout */
{
const char *eyec = "AzTools_text:;replace_utf8dashes";
AzBytArr s_mydata;
AzByte *mydata = s_mydata.reset(len*2, 0);
AzByte *mywp = mydata;
/* 0xe28093: en dash (often used as in 1900-1935) */
/* 0xe28094: em dash (long dash) */
/* 0xe2809c: double quote begin -> [ " ] */
/* 0xe2809d: duoble quote end -> [ " ] */
/* 0xe28098: single quote begin -> [ ' ]*/
/* 0xe28099: single quote end -> [ 's] if ending a token; [ ' ] otherwise */
const AzByte *data_end = data+len, *wp = data;
for ( ; wp < data_end; ) {
const AzByte *ptr = (AzByte *)memchr(wp, 0xE2, data_end-wp);
if (ptr == NULL) {
ptr = data_end;
}
int mvlen = Az64::ptr_diff(ptr-wp, eyec);
if (mvlen > 0) {
memcpy(mywp, wp, mvlen); mywp += mvlen; /* string before 0xE2 */
}
if (ptr+3 <= data_end) {
AzByte prevch = (ptr-1 >= data) ? *(ptr-1) : 0;
AzByte nextch = (ptr+3 < data_end) ? *(ptr+3) : 0;
AzBytArr s;
if (*(ptr+1) == 0x80) {
if (*(ptr+2) == 0x93) { /* en dash */
if (prevch>='0' && prevch<='9' && nextch>='0' && nextch<='9') s.c("-"); /* between digits */
else s.c(" - ");
}
else if (*(ptr+2) == 0x94) s.c(" - "); /* em dash */
else if (*(ptr+2) == 0x98) s.c(" ' ");
else if (*(ptr+2) == 0x9c || *(ptr+2) == 0x9d) s.c(" \" "); /* double quote */
else if (*(ptr+2) == 0x99) {
if (ptr+5<=data_end && memcmp(ptr+3, "s ", 2)==0) s.c(" '");
else s.c(" ' ");
}
else s.c(ptr, 3);
}
else s.c(ptr, 3);
memcpy(mywp, s.point(), s.length()); mywp += s.length();
wp = ptr+3;
}
else {
mvlen = Az64::ptr_diff(data_end-ptr, eyec);
if (mvlen > 0) {
memcpy(mywp, ptr, mvlen); mywp += mvlen;
}
wp = data_end;
}
}
int mydata_len = Az64::ptr_diff(mywp-mydata);
memcpy(data, mydata, mydata_len);
mydata[mydata_len] = '\0';
return mydata_len;
}
inline void write(const AzBytArr &s) {
if (o == NULL) return;
*o<<s.c_str();
}
inline void close() {
ofs.close();
if (ofs.fail()) {
throw new AzException(AzFileIOError, "AzOfs::close", "Failed to close:", s_fn.c_str());
}
}
static inline void force_writeln(const AzBytArr &s) {
force_writeln(s.c_str());
}
inline static void print(const AzBytArr &s, const AzOut &out) {
print(s.c_str(), out);
}
inline virtual void show(const char *header, const AzOut &out) const {
AzBytArr s;
s.c(header);
format(s);
AzPrint::writeln(out, s);
}
inline void reset() {
ba.clear();
}
