void print_aurpkg_list(alpm_list_t *list)
{
alpm_list_t *i;
struct aurpkg_t *pkg;
const char *pkgname, *pkgver;
size_t cols, curcols, pkglen;
cols = getcols();
curcols = 0;
for (i = list; i; i = i->next) {
pkg = i->data;
pkgname = pkg->name;
pkgver = pkg->version;
pkglen = strlen(pkgname) + 1 + strlen(pkgver);
if (curcols + pkglen > cols) {
printf("\n");
curcols = 0;
}
if (curcols == 0) {
printf("%s %s", pkgname, pkgver);
curcols = pkglen;
} else {
printf(" %s %s", pkgname, pkgver);
curcols += pkglen + 2;
}
}
printf("\n");
}
void print_list(alpm_list_t *list)
{
alpm_list_t *i;
size_t curcols, newlen;
size_t cols = getcols();
if (!list) {
printf("None\n");
return;
}
curcols = 0;
for (i = list; i; i = i->next) {
/* There's a bug here which I'm not gonna fix. */
newlen = curcols + 2 + strlen(i->data);
if (newlen > cols) {
printf("\n");
curcols = 0;
}
if (curcols == 0) {
printf("%s", i->data);
curcols += strlen(i->data);
continue;
}
curcols = newlen;
printf(" %s", i->data);
}
printf("\n");
}
/*
void mkbound(pelement otmasuk[], pelement where, int* len){
otmasuk[0]->parent = where; where->left = otmasuk[0];
otmasuk++;
(*len)--;
otmasuk[0]->parent = where; where->right = otmasuk[0];
where->value = where->left->value + where->right->value;
otmasuk[0] = where;
somesort(otmasuk, *len);
}
*/
void printtree(pelement viska, pelement cur){
printf("%sНаше дерево Хаффмана%s\n", cyan, none);
int wid = getcols();
pelement a[256];
pelement b[256];
pelement* vivodar=a;
pelement* subvivodar=b;
pelement* tmp;
vivodar[0] = viska;
for (int q=1; q<=256; q*=2){
for (int z=0; z<q; z++){
for (int i=0; i<wid/q/2-2; i++) printf(" ");
if (vivodar[z] == cur) printf("%s", red);
printf("%4i", vivodar[z]->value);
printf("%s", none);
if (z!=q-1) for (int i=0; i<wid/q/2; i++) printf(" ");
}
printf("\n----------------\n");
for (int i=0; i<q; i++){
if (i >= 128) break;
subvivodar[i*2] = vivodar[i]->left;
subvivodar[i*2+1] = vivodar[i]->right;
}
tmp = vivodar;
vivodar = subvivodar;
subvivodar = tmp;
}
printf("%sГотово%s\n", green, none);
}
static void indent (const char *str)
{
const char *c=NULL, *c1=NULL;
int cur_col=INDENT, cols;
if (!str)
return;
cols=getcols();
if (!cols)
{
fprintf (stdout, "%*s%s\n", INDENT, "", str);
return;
}
c=str;
fprintf (stdout, "%*s", INDENT, "");
while ((c1=strchr (c, ' ')) != NULL)
{
int len = (c1-c);
cur_col+=len+1;
if (cur_col >= cols)
{
fprintf (stdout, "\n%*s%.*s ", INDENT, "", len, c);
cur_col=INDENT+len+1;
}
else
fprintf (stdout, "%.*s ", len, c);
c=&c1[1];
}
cur_col+=strlen (c);
if (cur_col >= cols && c!=str)
fprintf (stdout, "\n%*s%s\n", INDENT, "", c);
else
fprintf (stdout, "%s\n", c);
}
void print_list_color(alpm_list_t *list, const char *wcolor)
{
alpm_list_t *i;
size_t curcols, newlen;
size_t cols = getcols();
if (!list) {
printf("None\n");
return;
}
curcols = 0;
for (i = list; i; i = i->next) {
newlen = curcols + 2 + strlen(i->data);
if (newlen > cols) {
printf("\n");
curcols = 0;
}
if (curcols == 0) {
printf("%s%s%s", wcolor, i->data, color.nocolor);
curcols += strlen(i->data);
continue;
}
curcols = newlen;
printf(" %s%s%s", wcolor, i->data, color.nocolor);
}
printf("\n");
}
static void
ali_print_name_list (mu_list_t list, int off)
{
mu_iterator_t itr;
char *item;
mu_list_get_iterator (list, &itr);
if (list_mode)
{
mu_iterator_first (itr);
mu_iterator_current (itr, (void **)&item);
printf ("%s\n", item);
for (mu_iterator_next (itr); !mu_iterator_is_done (itr); mu_iterator_next (itr))
{
int len;
mu_iterator_current (itr, (void **)&item);
len = off + strlen (item);
printf ("%*.*s\n", len, len, item);
}
}
else
{
int ncol = getcols ();
int n = off;
mu_iterator_first (itr);
for (;;)
{
int len;
mu_iterator_current (itr, (void **)&item);
len = strlen (item) + 2;
if (n + len > ncol)
n = printf ("\n ");
len = printf ("%s", item);
mu_iterator_next (itr);
if (!mu_iterator_is_done (itr))
len += printf (", ");
else
break;
n += len;
}
printf ("\n");
}
mu_iterator_destroy (&itr);
}
/* Print dependencies */
void print_list_deps(alpm_list_t *list, const char *prefix)
{
alpm_list_t *i;
size_t indent, cols, curcols, newlen;
size_t depstrlen;
char *depstr;
printf("%s%s%s ", color.bold, prefix, color.nocolor);
if (!list) {
printf("None\n");
return;
}
cols = getcols();
indent = strlen(prefix) + 1;
curcols = indent;
for (i = list; i; i = i->next) {
/* Compute dep string */
depstr = alpm_dep_compute_string(i->data);
if (!depstr) {
continue;
}
depstrlen = strlen(depstr);
newlen = curcols + 2 + depstrlen;
if (newlen > cols) {
printf("\n");
printf("%*s", indent, "");
curcols = indent;
}
if (curcols == indent) {
printf("%s", depstr);
curcols += depstrlen;
} else {
printf(" %s", depstr);
curcols += 2 + depstrlen;
}
free(depstr);
}
printf("\n");
}
void print_list_prefix(alpm_list_t *list, const char *prefix)
{
alpm_list_t *i;
size_t len = strlen(prefix);
size_t indent, curcols, newlen;
size_t cols = getcols();
printf("%s%s%s ", color.bold, prefix, color.nocolor);
if (!list) {
printf("None\n");
return;
}
indent = len + 1;
curcols = indent;
for (i = list; i; i = i->next) {
/* There's a bug here which I'm not gonna fix. */
newlen = curcols + 2 + strlen(i->data);
if (newlen > cols) {
printf("\n");
printf("%*s", indent, "");
curcols = indent;
}
if (curcols == indent) {
printf("%s", i->data);
curcols += strlen(i->data);
continue;
}
curcols = newlen;
printf(" %s", i->data);
}
printf("\n");
}
void do_outputchar(char* chars)
{
int charslen=strlen(chars); //not mblen,maybe望文
int i;
int len = curline->pdata_x-curline->data;
//curline->data
//如果写成realloc(p) 则当输入10个字母时，数据突然丢失
//并且应该相应改动pdata_x? 需要改动相关的指针吗?
char* data2 = curline->data =
realloc(curline->data, strlen(curline->data)+charslen+1);
char* data_x2 = curline->pdata_x=curline->data+len;
memmove(data_x2+charslen,
data_x2,
strlen(data_x2) + 1);
memcpy(data_x2, chars,charslen);
//curline->data_x
curline->pdata_x+=charslen;
//output
curline->win_x+=getcols(chars);
sub_outputline(curline);
}
void car_module::putinfo()
{
printf("mac=%d\n",mac);
printf("sumcar=%2d spendcar=%2d\n",sumcar,spendcar);
printf("rows=%2d cols=%2d\n",rows,cols);
printf("speed_rows=%.3lf speed_cols=%.3lf\n",speed_rows,speed_cols);
printf("\n");
for(int i=rows-1;i>=0;i--)
{
for(int j=0;j<cols;j++)
{
printf("%2d ",i*cols+j);
}
printf("\n");
}
printf("\n");
for(i=0;i<rows*cols;i++)
{
printf("rows=%2d cols=%2d id=%2d free=%2d time=%.3lf\n",getrows(map_queue[i].id),getcols(map_queue[i].id),map_queue[i].id,map_queue[i].idle,map_queue[i].time);
}
printf("\n");
}
/* callback to handle questions from libalpm transactions (yes/no) */
void cb_question(alpm_question_t *question)
{
if(config->print) {
if(question->type == ALPM_QUESTION_INSTALL_IGNOREPKG) {
question->any.answer = 1;
} else {
question->any.answer = 0;
}
return;
}
switch(question->type) {
case ALPM_QUESTION_INSTALL_IGNOREPKG:
{
alpm_question_install_ignorepkg_t *q = &question->install_ignorepkg;
if(!config->op_s_downloadonly) {
q->install = yesno(_("%s is in IgnorePkg/IgnoreGroup. Install anyway?"),
alpm_pkg_get_name(q->pkg));
} else {
q->install = 1;
}
}
break;
case ALPM_QUESTION_REPLACE_PKG:
{
alpm_question_replace_t *q = &question->replace;
q->replace = yesno(_("Replace %s with %s/%s?"),
alpm_pkg_get_name(q->oldpkg),
alpm_db_get_name(q->newdb),
alpm_pkg_get_name(q->newpkg));
}
break;
case ALPM_QUESTION_CONFLICT_PKG:
{
alpm_question_conflict_t *q = &question->conflict;
/* print conflict only if it contains new information */
if(strcmp(q->conflict->package1, q->conflict->reason->name) == 0
|| strcmp(q->conflict->package2, q->conflict->reason->name) == 0) {
q->remove = noyes(_("%s and %s are in conflict. Remove %s?"),
q->conflict->package1,
q->conflict->package2,
q->conflict->package2);
} else {
q->remove = noyes(_("%s and %s are in conflict (%s). Remove %s?"),
q->conflict->package1,
q->conflict->package2,
q->conflict->reason->name,
q->conflict->package2);
}
}
break;
case ALPM_QUESTION_REMOVE_PKGS:
{
alpm_question_remove_pkgs_t *q = &question->remove_pkgs;
alpm_list_t *namelist = NULL, *i;
size_t count = 0;
for(i = q->packages; i; i = i->next) {
namelist = alpm_list_add(namelist,
(char *)alpm_pkg_get_name(i->data));
count++;
}
colon_printf(_n(
"The following package cannot be upgraded due to unresolvable dependencies:\n",
"The following packages cannot be upgraded due to unresolvable dependencies:\n",
count));
list_display(" ", namelist, getcols());
printf("\n");
q->skip = noyes(_n(
"Do you want to skip the above package for this upgrade?",
"Do you want to skip the above packages for this upgrade?",
count));
alpm_list_free(namelist);
}
break;
case ALPM_QUESTION_SELECT_PROVIDER:
{
alpm_question_select_provider_t *q = &question->select_provider;
size_t count = alpm_list_count(q->providers);
char *depstring = alpm_dep_compute_string(q->depend);
colon_printf(_n("There is %zd provider available for %s\n",
"There are %zd providers available for %s:\n", count),
count, depstring);
free(depstring);
select_display(q->providers);
q->use_index = select_question(count);
}
break;
case ALPM_QUESTION_CORRUPTED_PKG:
{
alpm_question_corrupted_t *q = &question->corrupted;
q->remove = yesno(_("File %s is corrupted (%s).\n"
"Do you want to delete it?"),
q->filepath,
alpm_strerror(q->reason));
}
break;
case ALPM_QUESTION_IMPORT_KEY:
{
alpm_question_import_key_t *q = &question->import_key;
char created[12];
time_t time = (time_t)q->key->created;
strftime(created, 12, "%Y-%m-%d", localtime(&time));
if(q->key->revoked) {
q->import = yesno(_("Import PGP key %d%c/%s, \"%s\", created: %s (revoked)?"),
q->key->length, q->key->pubkey_algo, q->key->fingerprint, q->key->uid, created);
} else {
q->import = yesno(_("Import PGP key %d%c/%s, \"%s\", created: %s?"),
q->key->length, q->key->pubkey_algo, q->key->fingerprint, q->key->uid, created);
}
}
break;
}
if(config->noask) {
if(config->ask & question->type) {
/* inverse the default answer */
question->any.answer = !question->any.answer;
}
}
}
/* prepare a list of pkgs to display */
static void _display_targets(alpm_list_t *targets, int verbose)
{
char *str;
const char *label;
double size;
off_t isize = 0, rsize = 0, dlsize = 0;
unsigned short cols;
alpm_list_t *i, *rows = NULL, *names = NULL;
if(!targets) {
return;
}
/* gather package info */
for(i = targets; i; i = alpm_list_next(i)) {
pm_target_t *target = i->data;
if(target->install) {
dlsize += alpm_pkg_download_size(target->install);
isize += alpm_pkg_get_isize(target->install);
}
if(target->remove) {
/* add up size of all removed packages */
rsize += alpm_pkg_get_isize(target->remove);
}
}
/* form data for both verbose and non-verbose display */
for(i = targets; i; i = alpm_list_next(i)) {
pm_target_t *target = i->data;
rows = alpm_list_add(rows, create_verbose_row(target));
if(target->install) {
pm_asprintf(&str, "%s-%s", alpm_pkg_get_name(target->install),
alpm_pkg_get_version(target->install));
} else if(isize == 0) {
pm_asprintf(&str, "%s-%s", alpm_pkg_get_name(target->remove),
alpm_pkg_get_version(target->remove));
} else {
pm_asprintf(&str, "%s-%s [removal]", alpm_pkg_get_name(target->remove),
alpm_pkg_get_version(target->remove));
}
names = alpm_list_add(names, str);
}
/* print to screen */
pm_asprintf(&str, _("Packages (%d):"), alpm_list_count(targets));
printf("\n");
cols = getcols(fileno(stdout));
if(verbose) {
alpm_list_t *header = create_verbose_header();
if(table_display(str, header, rows, cols) != 0) {
/* fallback to list display if table wouldn't fit */
list_display(str, names, cols);
}
alpm_list_free(header);
} else {
list_display(str, names, cols);
}
printf("\n");
/* rows is a list of lists of strings, free inner lists here */
for(i = rows; i; i = alpm_list_next(i)) {
alpm_list_t *lp = i->data;
FREELIST(lp);
}
alpm_list_free(rows);
FREELIST(names);
free(str);
if(dlsize > 0 || config->op_s_downloadonly) {
size = humanize_size(dlsize, 'M', 2, &label);
printf(_("Total Download Size: %.2f %s\n"), size, label);
}
if(!config->op_s_downloadonly) {
if(isize > 0) {
size = humanize_size(isize, 'M', 2, &label);
printf(_("Total Installed Size: %.2f %s\n"), size, label);
}
if(rsize > 0 && isize == 0) {
size = humanize_size(rsize, 'M', 2, &label);
printf(_("Total Removed Size: %.2f %s\n"), size, label);
}
/* only show this net value if different from raw installed size */
if(isize > 0 && rsize > 0) {
size = humanize_size(isize - rsize, 'M', 2, &label);
printf(_("Net Upgrade Size: %.2f %s\n"), size, label);
}
}
}
/* callback to handle display of download progress */
void cb_dl_progress(const char *filename, off_t file_xfered, off_t file_total)
{
int infolen;
int filenamelen;
char *fname, *p;
/* used for wide character width determination and printing */
int len, wclen, wcwid, padwid;
wchar_t *wcfname;
int totaldownload = 0;
off_t xfered, total;
double rate = 0.0, timediff = 0.0;
unsigned int eta_h = 0, eta_m = 0, eta_s = 0;
double rate_human, xfered_human;
const char *rate_label, *xfered_label;
int file_percent = 0, total_percent = 0;
const int cols = getcols();
if(config->noprogressbar || cols == 0 || file_total == -1) {
if(file_xfered == 0) {
printf(_("downloading %s...\n"), filename);
fflush(stdout);
}
return;
}
infolen = cols * 6 / 10;
if(infolen < 50) {
infolen = 50;
}
/* explanation of magic 28 number at the end */
filenamelen = infolen - 28;
/* only use TotalDownload if enabled and we have a callback value */
if(config->totaldownload && list_total) {
/* sanity check */
if(list_xfered + file_total <= list_total) {
totaldownload = 1;
} else {
/* bogus values : don't enable totaldownload and reset */
list_xfered = 0;
list_total = 0;
}
}
if(totaldownload) {
xfered = list_xfered + file_xfered;
total = list_total;
} else {
xfered = file_xfered;
total = file_total;
}
/* bogus values : stop here */
if(xfered > total) {
return;
}
/* this is basically a switch on xfered: 0, total, and
* anything else */
if(file_xfered == 0) {
/* set default starting values, ensure we only call this once
* if TotalDownload is enabled */
if(!totaldownload || (totaldownload && list_xfered == 0)) {
gettimeofday(&initial_time, NULL);
xfered_last = (off_t)0;
rate_last = 0.0;
get_update_timediff(1);
}
} else if(file_xfered == file_total) {
/* compute final values */
struct timeval current_time;
double diff_sec, diff_usec;
gettimeofday(¤t_time, NULL);
diff_sec = current_time.tv_sec - initial_time.tv_sec;
diff_usec = current_time.tv_usec - initial_time.tv_usec;
timediff = diff_sec + (diff_usec / 1000000.0);
rate = xfered / timediff;
/* round elapsed time to the nearest second */
eta_s = (int)(timediff + 0.5);
} else {
/* compute current average values */
timediff = get_update_timediff(0);
if(timediff < UPDATE_SPEED_SEC) {
/* return if the calling interval was too short */
return;
}
rate = (xfered - xfered_last) / timediff;
/* average rate to reduce jumpiness */
rate = (rate + 2 * rate_last) / 3;
eta_s = (total - xfered) / rate;
rate_last = rate;
xfered_last = xfered;
}
file_percent = (file_xfered * 100) / file_total;
if(totaldownload) {
total_percent = ((list_xfered + file_xfered) * 100) /
list_total;
/* if we are at the end, add the completed file to list_xfered */
if(file_xfered == file_total) {
list_xfered += file_total;
}
}
/* fix up time for display */
eta_h = eta_s / 3600;
eta_s -= eta_h * 3600;
eta_m = eta_s / 60;
eta_s -= eta_m * 60;
fname = strdup(filename);
/* strip package or DB extension for cleaner look */
if((p = strstr(fname, ".pkg")) || (p = strstr(fname, ".db"))) {
*p = '\0';
}
/* In order to deal with characters from all locales, we have to worry
* about wide characters and their column widths. A lot of stuff is
* done here to figure out the actual number of screen columns used
* by the output, and then pad it accordingly so we fill the terminal.
*/
/* len = filename len + null */
len = strlen(filename) + 1;
wcfname = calloc(len, sizeof(wchar_t));
wclen = mbstowcs(wcfname, fname, len);
wcwid = wcswidth(wcfname, wclen);
padwid = filenamelen - wcwid;
/* if padwid is < 0, we need to trim the string so padwid = 0 */
if(padwid < 0) {
int i = filenamelen - 3;
wchar_t *wcp = wcfname;
/* grab the max number of char columns we can fill */
while(i > 0 && wcwidth(*wcp) < i) {
i -= wcwidth(*wcp);
wcp++;
}
/* then add the ellipsis and fill out any extra padding */
wcscpy(wcp, L"...");
padwid = i;
}
rate_human = humanize_size((off_t)rate, '\0', 0, &rate_label);
xfered_human = humanize_size(xfered, '\0', 0, &xfered_label);
/* 1 space + filenamelen + 1 space + 7 for size + 1 + 7 for rate + 2 for /s + 1 space + 8 for eta */
printf(" %ls%-*s %6.1f%s %#6.1f%s/s %02u:%02u:%02u", wcfname,
padwid, "", xfered_human, xfered_label, rate_human, rate_label,
eta_h, eta_m, eta_s);
free(fname);
free(wcfname);
if(totaldownload) {
fill_progress(file_percent, total_percent, cols - infolen);
} else {
fill_progress(file_percent, file_percent, cols - infolen);
}
return;
}
/* TODO this is one of the worst ever functions written. void *data ? wtf */
void cb_question(alpm_question_t event, void *data1, void *data2,
void *data3, int *response)
{
if(config->print) {
if(event == ALPM_QUESTION_INSTALL_IGNOREPKG) {
*response = 1;
} else {
*response = 0;
}
return;
}
switch(event) {
case ALPM_QUESTION_INSTALL_IGNOREPKG:
if(!config->op_s_downloadonly) {
*response = yesno(_("%s is in IgnorePkg/IgnoreGroup. Install anyway?"),
alpm_pkg_get_name(data1));
} else {
*response = 1;
}
break;
case ALPM_QUESTION_REPLACE_PKG:
*response = yesno(_("Replace %s with %s/%s?"),
alpm_pkg_get_name(data1),
(char *)data3,
alpm_pkg_get_name(data2));
break;
case ALPM_QUESTION_CONFLICT_PKG:
/* data parameters: target package, local package, conflict (strings) */
/* print conflict only if it contains new information */
if(strcmp(data1, data3) == 0 || strcmp(data2, data3) == 0) {
*response = noyes(_("%s and %s are in conflict. Remove %s?"),
(char *)data1,
(char *)data2,
(char *)data2);
} else {
*response = noyes(_("%s and %s are in conflict (%s). Remove %s?"),
(char *)data1,
(char *)data2,
(char *)data3,
(char *)data2);
}
break;
case ALPM_QUESTION_REMOVE_PKGS:
{
alpm_list_t *unresolved = data1;
alpm_list_t *namelist = NULL, *i;
size_t count = 0;
for(i = unresolved; i; i = i->next) {
namelist = alpm_list_add(namelist,
(char *)alpm_pkg_get_name(i->data));
count++;
}
colon_printf(_n(
"The following package cannot be upgraded due to unresolvable dependencies:\n",
"The following packages cannot be upgraded due to unresolvable dependencies:\n",
count));
list_display(" ", namelist, getcols(fileno(stdout)));
printf("\n");
*response = noyes(_n(
"Do you want to skip the above package for this upgrade?",
"Do you want to skip the above packages for this upgrade?",
count));
alpm_list_free(namelist);
}
break;
case ALPM_QUESTION_SELECT_PROVIDER:
{
alpm_list_t *providers = data1;
size_t count = alpm_list_count(providers);
char *depstring = alpm_dep_compute_string((alpm_depend_t *)data2);
colon_printf(_("There are %zd providers available for %s:\n"), count,
depstring);
free(depstring);
select_display(providers);
*response = select_question(count);
}
break;
case ALPM_QUESTION_CORRUPTED_PKG:
*response = yesno(_("File %s is corrupted (%s).\n"
"Do you want to delete it?"),
(char *)data1,
alpm_strerror(*(alpm_errno_t *)data2));
break;
case ALPM_QUESTION_IMPORT_KEY:
{
alpm_pgpkey_t *key = data1;
char created[12];
time_t time = (time_t)key->created;
strftime(created, 12, "%Y-%m-%d", localtime(&time));
if(key->revoked) {
*response = yesno(_("Import PGP key %d%c/%s, \"%s\", created: %s (revoked)?"),
key->length, key->pubkey_algo, key->fingerprint, key->uid, created);
} else {
*response = yesno(_("Import PGP key %d%c/%s, \"%s\", created: %s?"),
key->length, key->pubkey_algo, key->fingerprint, key->uid, created);
}
}
break;
}
if(config->noask) {
if(config->ask & event) {
/* inverse the default answer */
*response = !*response;
}
}
}
/**
* Display the details of a search.
* @param db the database we're searching
* @param targets the targets we're searching for
* @param show_status show if the package is also in the local db
*/
int dump_pkg_search(alpm_db_t *db, alpm_list_t *targets, int show_status)
{
int freelist = 0;
alpm_db_t *db_local;
alpm_list_t *i, *searchlist;
unsigned short cols;
const colstr_t *colstr = &config->colstr;
if(show_status) {
db_local = alpm_get_localdb(config->handle);
}
/* if we have a targets list, search for packages matching it */
if(targets) {
searchlist = alpm_db_search(db, targets);
freelist = 1;
} else {
searchlist = alpm_db_get_pkgcache(db);
freelist = 0;
}
if(searchlist == NULL) {
return 1;
}
cols = getcols(fileno(stdout));
for(i = searchlist; i; i = alpm_list_next(i)) {
alpm_list_t *grp;
alpm_pkg_t *pkg = i->data;
if(config->quiet) {
fputs(alpm_pkg_get_name(pkg), stdout);
} else {
printf("%s%s/%s%s %s%s%s", colstr->repo, alpm_db_get_name(db),
colstr->title, alpm_pkg_get_name(pkg),
colstr->version, alpm_pkg_get_version(pkg), colstr->nocolor);
if((grp = alpm_pkg_get_groups(pkg)) != NULL) {
alpm_list_t *k;
printf(" %s(", colstr->groups);
for(k = grp; k; k = alpm_list_next(k)) {
const char *group = k->data;
fputs(group, stdout);
if(alpm_list_next(k)) {
/* only print a spacer if there are more groups */
putchar(' ');
}
}
printf(")%s", colstr->nocolor);
}
if(show_status) {
print_installed(db_local, pkg);
}
/* we need a newline and initial indent first */
fputs("\n ", stdout);
indentprint(alpm_pkg_get_desc(pkg), 4, cols);
}
fputc('\n', stdout);
}
/* we only want to free if the list was a search list */
if(freelist) {
alpm_list_free(searchlist);
}
return 0;
}
/* prepare a list of pkgs to display */
static void _display_targets(alpm_list_t *targets, int verbose)
{
char *str;
off_t isize = 0, rsize = 0, dlsize = 0;
unsigned short cols;
alpm_list_t *i, *names = NULL, *header = NULL, *rows = NULL;
if(!targets) {
return;
}
/* gather package info */
for(i = targets; i; i = alpm_list_next(i)) {
pm_target_t *target = i->data;
if(target->install) {
dlsize += alpm_pkg_download_size(target->install);
isize += alpm_pkg_get_isize(target->install);
}
if(target->remove) {
/* add up size of all removed packages */
rsize += alpm_pkg_get_isize(target->remove);
}
}
/* form data for both verbose and non-verbose display */
for(i = targets; i; i = alpm_list_next(i)) {
pm_target_t *target = i->data;
if(verbose) {
rows = alpm_list_add(rows, create_verbose_row(target));
}
if(target->install) {
pm_asprintf(&str, "%s-%s", alpm_pkg_get_name(target->install),
alpm_pkg_get_version(target->install));
} else if(isize == 0) {
pm_asprintf(&str, "%s-%s", alpm_pkg_get_name(target->remove),
alpm_pkg_get_version(target->remove));
} else {
pm_asprintf(&str, "%s-%s [%s]", alpm_pkg_get_name(target->remove),
alpm_pkg_get_version(target->remove), _("removal"));
}
names = alpm_list_add(names, str);
}
/* print to screen */
pm_asprintf(&str, "%s (%zd)", _("Packages"), alpm_list_count(targets));
printf("\n");
cols = getcols(fileno(stdout));
if(verbose) {
header = create_verbose_header(alpm_list_count(targets));
if(table_display(header, rows, cols) != 0) {
/* fallback to list display if table wouldn't fit */
list_display(str, names, cols);
}
} else {
list_display(str, names, cols);
}
printf("\n");
table_free(header, rows);
FREELIST(names);
free(str);
rows = NULL;
if(dlsize > 0 || config->op_s_downloadonly) {
add_transaction_sizes_row(&rows, _("Total Download Size:"), dlsize);
}
if(!config->op_s_downloadonly) {
if(isize > 0) {
add_transaction_sizes_row(&rows, _("Total Installed Size:"), isize);
}
if(rsize > 0 && isize == 0) {
add_transaction_sizes_row(&rows, _("Total Removed Size:"), rsize);
}
/* only show this net value if different from raw installed size */
if(isize > 0 && rsize > 0) {
add_transaction_sizes_row(&rows, _("Net Upgrade Size:"), isize - rsize);
}
}
table_display(NULL, rows, cols);
table_free(NULL, rows);
}
/* callback to handle display of transaction progress */
void cb_progress(alpm_progress_t event, const char *pkgname, int percent,
size_t howmany, size_t current)
{
static int prevpercent;
static size_t prevcurrent;
/* size of line to allocate for text printing (e.g. not progressbar) */
int infolen;
int digits, textlen;
size_t tmp;
char *opr = NULL;
/* used for wide character width determination and printing */
int len, wclen, wcwid, padwid;
wchar_t *wcstr;
const unsigned short cols = getcols();
if(config->noprogressbar || cols == 0) {
return;
}
if(percent == 0) {
get_update_timediff(1);
} else if(percent == 100) {
/* no need for timediff update, but unconditionally continue unless we
* already completed on a previous call */
if(prevpercent == 100) {
return;
}
} else {
if(current != prevcurrent) {
/* update always */
} else if(!pkgname || percent == prevpercent ||
get_update_timediff(0) < UPDATE_SPEED_MS) {
/* only update the progress bar when we have a package name, the
* percentage has changed, and it has been long enough. */
return;
}
}
prevpercent = percent;
prevcurrent = current;
/* set text of message to display */
switch(event) {
case ALPM_PROGRESS_ADD_START:
opr = _("installing");
break;
case ALPM_PROGRESS_UPGRADE_START:
opr = _("upgrading");
break;
case ALPM_PROGRESS_DOWNGRADE_START:
opr = _("downgrading");
break;
case ALPM_PROGRESS_REINSTALL_START:
opr = _("reinstalling");
break;
case ALPM_PROGRESS_REMOVE_START:
opr = _("removing");
break;
case ALPM_PROGRESS_CONFLICTS_START:
opr = _("checking for file conflicts");
break;
case ALPM_PROGRESS_DISKSPACE_START:
opr = _("checking available disk space");
break;
case ALPM_PROGRESS_INTEGRITY_START:
opr = _("checking package integrity");
break;
case ALPM_PROGRESS_KEYRING_START:
opr = _("checking keys in keyring");
break;
case ALPM_PROGRESS_LOAD_START:
opr = _("loading package files");
break;
default:
return;
}
infolen = cols * 6 / 10;
if(infolen < 50) {
infolen = 50;
}
/* find # of digits in package counts to scale output */
digits = 1;
tmp = howmany;
while((tmp /= 10)) {
++digits;
}
/* determine room left for non-digits text [not ( 1/12) part] */
textlen = infolen - 3 /* (/) */ - (2 * digits) - 1 /* space */;
/* In order to deal with characters from all locales, we have to worry
* about wide characters and their column widths. A lot of stuff is
* done here to figure out the actual number of screen columns used
* by the output, and then pad it accordingly so we fill the terminal.
*/
/* len = opr len + pkgname len (if available) + space + null */
len = strlen(opr) + ((pkgname) ? strlen(pkgname) : 0) + 2;
wcstr = calloc(len, sizeof(wchar_t));
/* print our strings to the alloc'ed memory */
#if defined(HAVE_SWPRINTF)
wclen = swprintf(wcstr, len, L"%s %s", opr, pkgname);
#else
/* because the format string was simple, we can easily do this without
* using swprintf, although it is probably not as safe/fast. The max
* chars we can copy is decremented each time by subtracting the length
* of the already printed/copied wide char string. */
wclen = mbstowcs(wcstr, opr, len);
wclen += mbstowcs(wcstr + wclen, " ", len - wclen);
wclen += mbstowcs(wcstr + wclen, pkgname, len - wclen);
#endif
wcwid = wcswidth(wcstr, wclen);
padwid = textlen - wcwid;
/* if padwid is < 0, we need to trim the string so padwid = 0 */
if(padwid < 0) {
int i = textlen - 3;
wchar_t *p = wcstr;
/* grab the max number of char columns we can fill */
while(i - wcwidth(*p) > 0) {
i -= wcwidth(*p);
p++;
}
/* then add the ellipsis and fill out any extra padding */
wcscpy(p, L"...");
padwid = i;
}
printf("(%*ld/%*ld) %ls%-*s", digits, (unsigned long)current,
digits, (unsigned long)howmany, wcstr, padwid, "");
free(wcstr);
/* call refactored fill progress function */
fill_progress(percent, percent, cols - infolen);
if(percent == 100) {
alpm_list_t *i = NULL;
on_progress = 0;
fflush(stdout);
for(i = output; i; i = i->next) {
fputs((const char *)i->data, stderr);
}
fflush(stderr);
FREELIST(output);
} else {
on_progress = 1;
}
}
/**
* Display the details of a package.
* Extra information entails 'required by' info for sync packages and backup
* files info for local packages.
* @param pkg package to display information for
* @param from the type of package we are dealing with
* @param extra should we show extra information
*/
void dump_pkg_full(alpm_pkg_t *pkg, int extra)
{
unsigned short cols;
time_t bdate, idate;
alpm_pkgfrom_t from;
double size;
char bdatestr[50] = "", idatestr[50] = "";
const char *label, *reason;
alpm_list_t *validation = NULL, *requiredby = NULL, *optionalfor = NULL;
from = alpm_pkg_get_origin(pkg);
/* set variables here, do all output below */
bdate = (time_t)alpm_pkg_get_builddate(pkg);
if(bdate) {
strftime(bdatestr, 50, "%c", localtime(&bdate));
}
idate = (time_t)alpm_pkg_get_installdate(pkg);
if(idate) {
strftime(idatestr, 50, "%c", localtime(&idate));
}
switch(alpm_pkg_get_reason(pkg)) {
case ALPM_PKG_REASON_EXPLICIT:
reason = _("Explicitly installed");
break;
case ALPM_PKG_REASON_DEPEND:
reason = _("Installed as a dependency for another package");
break;
default:
reason = _("Unknown");
break;
}
alpm_pkgvalidation_t v = alpm_pkg_get_validation(pkg);
if(v) {
if(v & ALPM_PKG_VALIDATION_NONE) {
validation = alpm_list_add(validation, _("None"));
} else {
if(v & ALPM_PKG_VALIDATION_MD5SUM) {
validation = alpm_list_add(validation, _("MD5 Sum"));
}
if(v & ALPM_PKG_VALIDATION_SHA256SUM) {
validation = alpm_list_add(validation, _("SHA256 Sum"));
}
if(v & ALPM_PKG_VALIDATION_SIGNATURE) {
validation = alpm_list_add(validation, _("Signature"));
}
}
} else {
validation = alpm_list_add(validation, _("Unknown"));
}
if(extra || from == ALPM_PKG_FROM_LOCALDB) {
/* compute this here so we don't get a pause in the middle of output */
requiredby = alpm_pkg_compute_requiredby(pkg);
optionalfor = alpm_pkg_compute_optionalfor(pkg);
}
cols = getcols(fileno(stdout));
/* actual output */
if(from == ALPM_PKG_FROM_SYNCDB) {
string_display(_("Repository :"),
alpm_db_get_name(alpm_pkg_get_db(pkg)), cols);
}
string_display(_("Name :"), alpm_pkg_get_name(pkg), cols);
string_display(_("Version :"), alpm_pkg_get_version(pkg), cols);
string_display(_("Description :"), alpm_pkg_get_desc(pkg), cols);
string_display(_("Architecture :"), alpm_pkg_get_arch(pkg), cols);
string_display(_("URL :"), alpm_pkg_get_url(pkg), cols);
list_display(_("Licenses :"), alpm_pkg_get_licenses(pkg), cols);
list_display(_("Groups :"), alpm_pkg_get_groups(pkg), cols);
deplist_display(_("Provides :"), alpm_pkg_get_provides(pkg), cols);
deplist_display(_("Depends On :"), alpm_pkg_get_depends(pkg), cols);
optdeplist_display(pkg, cols);
if(extra || from == ALPM_PKG_FROM_LOCALDB) {
list_display(_("Required By :"), requiredby, cols);
list_display(_("Optional For :"), optionalfor, cols);
}
deplist_display(_("Conflicts With :"), alpm_pkg_get_conflicts(pkg), cols);
deplist_display(_("Replaces :"), alpm_pkg_get_replaces(pkg), cols);
size = humanize_size(alpm_pkg_get_size(pkg), '\0', 2, &label);
if(from == ALPM_PKG_FROM_SYNCDB) {
printf("%s%s%s %6.2f %s\n", config->colstr.title, _("Download Size :"),
config->colstr.nocolor, size, label);
} else if(from == ALPM_PKG_FROM_FILE) {
printf("%s%s%s %6.2f %s\n", config->colstr.title, _("Compressed Size:"),
config->colstr.nocolor, size, label);
} else {
// autodetect size for "Installed Size"
label = "\0";
}
size = humanize_size(alpm_pkg_get_isize(pkg), label[0], 2, &label);
printf("%s%s%s %6.2f %s\n", config->colstr.title, _("Installed Size :"),
config->colstr.nocolor, size, label);
string_display(_("Packager :"), alpm_pkg_get_packager(pkg), cols);
string_display(_("Build Date :"), bdatestr, cols);
if(from == ALPM_PKG_FROM_LOCALDB) {
string_display(_("Install Date :"), idatestr, cols);
string_display(_("Install Reason :"), reason, cols);
}
if(from == ALPM_PKG_FROM_FILE || from == ALPM_PKG_FROM_LOCALDB) {
string_display(_("Install Script :"),
alpm_pkg_has_scriptlet(pkg) ? _("Yes") : _("No"), cols);
}
if(from == ALPM_PKG_FROM_SYNCDB && extra) {
const char *base64_sig = alpm_pkg_get_base64_sig(pkg);
alpm_list_t *keys = NULL;
if(base64_sig) {
unsigned char *decoded_sigdata = NULL;
size_t data_len;
alpm_decode_signature(base64_sig, &decoded_sigdata, &data_len);
alpm_extract_keyid(config->handle, alpm_pkg_get_name(pkg),
decoded_sigdata, data_len, &keys);
} else {
keys = alpm_list_add(keys, _("None"));
}
string_display(_("MD5 Sum :"), alpm_pkg_get_md5sum(pkg), cols);
string_display(_("SHA256 Sum :"), alpm_pkg_get_sha256sum(pkg), cols);
list_display(_("Signatures :"), keys, cols);
} else {
list_display(_("Validated By :"), validation, cols);
}
if(from == ALPM_PKG_FROM_FILE) {
alpm_siglist_t siglist;
int err = alpm_pkg_check_pgp_signature(pkg, &siglist);
if(err && alpm_errno(config->handle) == ALPM_ERR_SIG_MISSING) {
string_display(_("Signatures :"), _("None"), cols);
} else if(err) {
string_display(_("Signatures :"),
alpm_strerror(alpm_errno(config->handle)), cols);
} else {
signature_display(_("Signatures :"), &siglist, cols);
}
alpm_siglist_cleanup(&siglist);
}
/* Print additional package info if info flag passed more than once */
if(from == ALPM_PKG_FROM_LOCALDB && extra) {
dump_pkg_backups(pkg);
}
/* final newline to separate packages */
printf("\n");
FREELIST(requiredby);
alpm_list_free(validation);
}
/* callback to handle display of download progress */
void cb_dl_progress(const char *filename, off_t file_xfered, off_t file_total)
{
static double rate_last;
static off_t xfered_last;
static int64_t initial_time = 0;
int infolen;
int filenamelen;
char *fname, *p;
/* used for wide character width determination and printing */
int len, wclen, wcwid, padwid;
wchar_t *wcfname;
int totaldownload = 0;
off_t xfered, total;
double rate = 0.0;
unsigned int eta_h = 0, eta_m = 0, eta_s = 0;
double rate_human, xfered_human;
const char *rate_label, *xfered_label;
int file_percent = 0, total_percent = 0;
const unsigned short cols = getcols();
if(config->noprogressbar || cols == 0 || file_total == -1) {
if(file_xfered == 0) {
printf(_("downloading %s...\n"), filename);
fflush(stdout);
}
return;
}
infolen = cols * 6 / 10;
if(infolen < 50) {
infolen = 50;
}
/* only use TotalDownload if enabled and we have a callback value */
if(config->totaldownload && list_total) {
/* sanity check */
if(list_xfered + file_total <= list_total) {
totaldownload = 1;
} else {
/* bogus values : don't enable totaldownload and reset */
list_xfered = 0;
list_total = 0;
}
}
if(totaldownload) {
xfered = list_xfered + file_xfered;
total = list_total;
} else {
xfered = file_xfered;
total = file_total;
}
/* bogus values : stop here */
if(xfered > total || xfered < 0) {
return;
}
/* this is basically a switch on xfered: 0, total, and
* anything else */
if(file_xfered == 0) {
/* set default starting values, ensure we only call this once
* if TotalDownload is enabled */
if(!totaldownload || (totaldownload && list_xfered == 0)) {
initial_time = get_time_ms();
xfered_last = (off_t)0;
rate_last = 0.0;
get_update_timediff(1);
}
} else if(file_xfered == file_total) {
/* compute final values */
int64_t timediff = get_time_ms() - initial_time;
if(timediff > 0) {
rate = (double)xfered / (timediff / 1000.0);
/* round elapsed time (in ms) to the nearest second */
eta_s = (unsigned int)(timediff + 500) / 1000;
} else {
eta_s = 0;
}
} else {
/* compute current average values */
int64_t timediff = get_update_timediff(0);
if(timediff < UPDATE_SPEED_MS) {
/* return if the calling interval was too short */
return;
}
rate = (double)(xfered - xfered_last) / (timediff / 1000.0);
/* average rate to reduce jumpiness */
rate = (rate + 2 * rate_last) / 3;
if(rate > 0.0) {
eta_s = (total - xfered) / rate;
} else {
eta_s = UINT_MAX;
}
rate_last = rate;
xfered_last = xfered;
}
if(file_total) {
file_percent = (file_xfered * 100) / file_total;
} else {
file_percent = 100;
}
if(totaldownload) {
total_percent = ((list_xfered + file_xfered) * 100) /
list_total;
/* if we are at the end, add the completed file to list_xfered */
if(file_xfered == file_total) {
list_xfered += file_total;
}
}
/* fix up time for display */
eta_h = eta_s / 3600;
eta_s -= eta_h * 3600;
eta_m = eta_s / 60;
eta_s -= eta_m * 60;
len = strlen(filename);
fname = malloc(len + 1);
memcpy(fname, filename, len);
/* strip package or DB extension for cleaner look */
if((p = strstr(fname, ".pkg")) || (p = strstr(fname, ".db")) || (p = strstr(fname, ".files"))) {
/* tack on a .sig suffix for signatures */
if(memcmp(&filename[len - 4], ".sig", 4) == 0) {
memcpy(p, ".sig", 4);
/* adjust length for later calculations */
len = p - fname + 4;
} else {
len = p - fname;
}
}
fname[len] = '\0';
/* 1 space + filenamelen + 1 space + 6 for size + 1 space + 3 for label +
* + 2 spaces + 4 for rate + 1 for label + 2 for /s + 1 space +
* 8 for eta, gives us the magic 30 */
filenamelen = infolen - 30;
/* see printf() code, we omit 'HH:' in these conditions */
if(eta_h == 0 || eta_h >= 100) {
filenamelen += 3;
}
/* In order to deal with characters from all locales, we have to worry
* about wide characters and their column widths. A lot of stuff is
* done here to figure out the actual number of screen columns used
* by the output, and then pad it accordingly so we fill the terminal.
*/
/* len = filename len + null */
wcfname = calloc(len + 1, sizeof(wchar_t));
wclen = mbstowcs(wcfname, fname, len);
wcwid = wcswidth(wcfname, wclen);
padwid = filenamelen - wcwid;
/* if padwid is < 0, we need to trim the string so padwid = 0 */
if(padwid < 0) {
int i = filenamelen - 3;
wchar_t *wcp = wcfname;
/* grab the max number of char columns we can fill */
while(i > 0 && wcwidth(*wcp) < i) {
i -= wcwidth(*wcp);
wcp++;
}
/* then add the ellipsis and fill out any extra padding */
wcscpy(wcp, L"...");
padwid = i;
}
rate_human = humanize_size((off_t)rate, '\0', -1, &rate_label);
xfered_human = humanize_size(xfered, '\0', -1, &xfered_label);
printf(" %ls%-*s ", wcfname, padwid, "");
/* We will show 1.62M/s, 11.6M/s, but 116K/s and 1116K/s */
if(rate_human < 9.995) {
printf("%6.1f %3s %4.2f%c/s ",
xfered_human, xfered_label, rate_human, rate_label[0]);
} else if(rate_human < 99.95) {
printf("%6.1f %3s %4.1f%c/s ",
xfered_human, xfered_label, rate_human, rate_label[0]);
} else {
printf("%6.1f %3s %4.f%c/s ",
xfered_human, xfered_label, rate_human, rate_label[0]);
}
if(eta_h == 0) {
printf("%02u:%02u", eta_m, eta_s);
} else if(eta_h < 100) {
printf("%02u:%02u:%02u", eta_h, eta_m, eta_s);
} else {
fputs("--:--", stdout);
}
free(fname);
free(wcfname);
if(totaldownload) {
fill_progress(file_percent, total_percent, cols - infolen);
} else {
fill_progress(file_percent, file_percent, cols - infolen);
}
return;
}
/*********************************************************************************
* *
* G A T E W A Y R O U T I N E *
* *
*********************************************************************************/
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/*
>>>>>>>>>>>>>>>>>> VARIABLE DECLARATIONS <<<<<<<<<<<<<<<<<<<
*/
matrix *PI_vector;
matrix *NetDef, *W1, *W2, *PHI, *Y, *L_hidden, *H_hidden;
double *M, lambda;
int iter, hidden, inputs, outputs, a, n, decays;
trparmstruct *trparms;
mxArray *Matmatrix;
char *infolevelstr[] = {"infolevel", "Infolevel", "INFOLEVEL", "InfoLevel"};
char *maxiterstr[] = {"maxiter", "MAXITER", "Maxiter", "MaxIter"};
char *critminstr[] = {"critmin", "Critmin", "CRITMIN", "CritMin"};
char *crittermstr[] = {"critterm", "Critterm", "CRITTERM", "CritTerm"};
char *gradtermstr[] = {"gradterm", "Gradterm", "GRADTERM", "GradTerm"};
char *paramtermstr[] = {"paramterm", "Paramterm", "PARAMTERM", "ParamTerm"};
char *Dstr[] = {"D", "d"};
char *lambdastr[] = {"lambda", "Lambda", "LAMBDA"};
char *skipstr[] = {"skip", "Skip", "SKIP"};
/*
>>>>>>>>>>>>>>>> CHECK FOR PROPER NUMBER OF ARGUMENTS <<<<<<<<<<<<<<<
*/
if (nrhs<5 || nrhs>6)
{
mexErrMsgTxt("Wrong number of input arguments");
}
else if (nlhs > 5)
{
mexErrMsgTxt("Too many output arguments");
}
/*
>>>>>>>>>>>>>>>>> CONVERT INPUT ARGUMENTS TO SM FORMAT <<<<<<<<<<<<<<<<
*/
NetDef = matstring2sm(prhs[0]);
PHI = mat2sm(prhs[3]);
Y = mat2sm(prhs[4]);
inputs = mxGetM(prhs[3]);
outputs = mxGetM(prhs[4]);
L_hidden = neuvector(NetDef,1,'L'); /* Location of linear hidden units */
H_hidden = neuvector(NetDef,1,'H'); /* Location of tanh hidden units */
hidden = L_hidden->row*L_hidden->col + H_hidden->row*H_hidden->col;
if(mxGetM(prhs[1])==0 || mxGetN(prhs[1])==0 || mxGetM(prhs[2])==0\
|| mxGetN(prhs[2])==0){
W1 = mmake(hidden,inputs+1);
W2 = mmake(outputs,hidden+1);
mrand(W1); smul(W1,W1,0.5);
mrand(W2); smul(W2,W2,0.5);
}
else{
if(mxGetM(prhs[1])!=hidden) mexErrMsgTxt("W1 has the wrong dimension");
if(mxGetN(prhs[1])!=inputs+1) mexErrMsgTxt("W1 has the wrong dimension");
if(mxGetM(prhs[2])!=outputs) mexErrMsgTxt("W2 has the wrong dimension");
if(mxGetN(prhs[2])!=hidden+1) mexErrMsgTxt("W2 has the wrong dimension");
W1 = mat2sm(prhs[1]); /* Input-to-hidden layer weights */
W2 = mat2sm(prhs[2]); /* Hidden-to-output layer weights */
}
trparms = (trparmstruct*)malloc(sizeof(trparmstruct));
a = 5;
if (nrhs==6){
/* INFOLEVEL */
trparms->infolevel = TRDINFOLEVEL;
for(n=0;n<4;n++){
if ((Matmatrix=mxGetField(prhs[a], 0, infolevelstr[n]))!=NULL){
trparms->infolevel=(int)(*mxGetPr(Matmatrix));
break;
}
}
/* MAXITER */
trparms->maxiter = TRDMAXITER;
for(n=0;n<4;n++){
if ((Matmatrix=mxGetField(prhs[a], 0, maxiterstr[n]))!=NULL){
trparms->maxiter=(int)(*mxGetPr(Matmatrix));
break;
}
}
/* CRITMIN */
trparms->critmin = TRDCRITMIN;
for(n=0;n<4;n++){
if ((Matmatrix=mxGetField(prhs[a], 0, critminstr[n]))!=NULL){
trparms->critmin=(double)(*mxGetPr(Matmatrix));
break;
}
}
/* CRITTERM */
trparms->critterm = TRDCRITTERM;
for(n=0;n<4;n++){
if ((Matmatrix=mxGetField(prhs[a], 0, crittermstr[n]))!=NULL){
trparms->critterm=(double)(*mxGetPr(Matmatrix));
break;
}
}
/* GRADTERM */
trparms->gradterm = TRDGRADTERM;
for(n=0;n<4;n++){
if ((Matmatrix=mxGetField(prhs[a], 0, gradtermstr[n]))!=NULL){
trparms->gradterm=(double)(*mxGetPr(Matmatrix));
break;
}
}
/* PARAMTERM */
trparms->paramterm = TRDPARAMTERM;
for(n=0;n<4;n++){
if ((Matmatrix=mxGetField(prhs[a], 0, paramtermstr[n]))!=NULL){
trparms->paramterm=(double)(*mxGetPr(Matmatrix));
break;
}
}
/* Lambda */
trparms->lambda = TRDLAMBDA;
for(n=0;n<3;n++){
if ((Matmatrix=mxGetField(prhs[a], 0, lambdastr[n]))!=NULL){
trparms->lambda=(double)(*mxGetPr(Matmatrix));
break;
}
}
/* D */
for(n=0;n<2;n++){
if ((Matmatrix=mxGetField(prhs[a], 0, Dstr[n]))!=NULL){
decays = mxGetM(Matmatrix)*mxGetN(Matmatrix);
trparms->D = mmake(1,decays);
M = mxGetPr(Matmatrix);
for(n=0;n<decays;n++){
rvput(trparms->D,n,M[n]);
}
break;
}
}
if(Matmatrix==NULL){
trparms->D = mmake(1,1);
put_val(trparms->D,0,0,TRDD);
}
}
else
{
trparms->infolevel = TRDINFOLEVEL;
trparms->maxiter = TRDMAXITER;
trparms->critmin = TRDCRITMIN;
trparms->critterm = TRDCRITTERM;
trparms->gradterm = TRDGRADTERM;
trparms->paramterm = TRDPARAMTERM;
trparms->D = mmake(1,1);
put_val(trparms->D,0,0,TRDD);
trparms->lambda = TRDLAMBDA;
trparms->skip = TRDSKIP;
}
/*
>>>>>>>>>>>>>>>>>>>>>> CALL THE C-ROUTINE <<<<<<<<<<<<<<<<<<<<<
*/
marqc(&PI_vector, &iter, &lambda, NetDef, W1, W2, PHI, Y, trparms);
/*
>>>>>>>>>>>>>>>>>>> CREATE OUTPUT MATICES <<<<<<<<<<<<<<<<<<
*/
plhs[0] = mxCreateDoubleMatrix(getrows(W1),getcols(W1),mxREAL);
plhs[1] = mxCreateDoubleMatrix(getrows(W2),getcols(W2),mxREAL);
plhs[2] = mxCreateDoubleMatrix(getrows(PI_vector),getcols(PI_vector),mxREAL);
plhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
plhs[4] = mxCreateDoubleMatrix(1,1,mxREAL);
sm2mat(plhs[0],W1);
sm2mat(plhs[1],W2);
sm2mat(plhs[2],PI_vector);
M = mxGetPr(plhs[3]); M[0] = (double)iter;
M = mxGetPr(plhs[4]); M[0] = (double)lambda;
/*
>>>>>>>>>>>>>>>>>>>> FREE ARGUMENT MATRICES <<<<<<<<<<<<<<<<<<<<<
*/
mfree(NetDef); mfree(PHI); mfree(Y); mfree(L_hidden); mfree(H_hidden);
mfree(trparms->D);
free(trparms);
}
