void rfree(void* x) {
if ((x != NIL) &&
(x != TRUE) &&
(x != FALSE) &&
(x != NULL)) {
switch(type(x)) {
case SPECIAL:
/* can't be freed */
return;
case FUNCTION:
/* TODO */
return;
case INT:
/* no members to free */
break;
case SYMBOL:
free(SVAL(x));
break;
case CONS:
rfree(CAR(x));
rfree(CDR(x));
break;
}
free(x);
}
}
const Choice*
Space::choice(void) {
if (!stable())
throw SpaceNotStable("Space::choice");
if (failed() || (b_status == Brancher::cast(&bl))) {
// There are no more choices to be generated
// Delete all branchers
Brancher* b = Brancher::cast(bl.next());
while (b != Brancher::cast(&bl)) {
Brancher* d = b;
b = Brancher::cast(b->next());
rfree(d,d->dispose(*this));
}
bl.init();
b_status = b_commit = Brancher::cast(&bl);
return NULL;
}
/*
* The call to choice() says that no older choices
* can be used. Hence, all branchers that are exhausted can be deleted.
*/
Brancher* b = Brancher::cast(bl.next());
while (b != b_status) {
Brancher* d = b;
b = Brancher::cast(b->next());
d->unlink();
rfree(d,d->dispose(*this));
}
// Make sure that b_commit does not point to a deleted brancher!
b_commit = b_status;
return b_status->choice(*this);
}
/**
* \brief Frees selector component.
* \param[in,out] dev Selector base component device.
*/
static void selector_free(struct comp_dev *dev)
{
struct comp_data *cd = comp_get_drvdata(dev);
trace_selector("selector_free()");
rfree(cd);
rfree(dev);
}
static void test_keyword_free(struct comp_dev *dev)
{
struct comp_data *cd = comp_get_drvdata(dev);
trace_keyword("test_keyword_free()");
free_mem_load(cd);
rfree(cd);
rfree(dev);
}
static rpmfcAttr rpmfcAttrFree(rpmfcAttr attr)
{
if (attr) {
ruleFree(&attr->incl);
ruleFree(&attr->excl);
rfree(attr->name);
rfree(attr);
}
return NULL;
}
BOOL DialogProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_CLOSE:
{
SelectObject(g_hdc, g_hbmpOld);
DeleteObject(g_hbmp);
DeleteDC(g_hdc);
EndDialog(hDlg, 0);
break;
}
case WM_INITDIALOG:
{
int i;
t_region *region, *rgnExclude = NULL, *rgnNew;
g_hdc = CreateCompatibleDC(NULL);
g_hbmp = CreateCompatibleBitmap(GetDC(NULL), 640, 480);
g_hbmpOld = SelectObject(g_hdc, g_hbmp);
region = create_rect_region(g_rcInclude.left, g_rcInclude.top, g_rcInclude.right, g_rcInclude.bottom);
for (i=0;i<EXCLUDES;i++)
rgnExclude = append_regions(rgnExclude, create_rect_region(g_rcExclude[i].left, g_rcExclude[i].top, g_rcExclude[i].right, g_rcExclude[i].bottom));
rgnNew = difference_regions(region, rgnExclude);
rfree(®ion);
rfree(&rgnExclude);
region = rgnNew;
while (region)
{
Rectangle(g_hdc, region->rcRegion.left, region->rcRegion.top, region->rcRegion.right, region->rcRegion.bottom);
region = region->next;
}
rfree(&rgnNew);
SendMessage(hDlg, WM_SETTEXT, 0, (LPARAM)"Region Test");
break;
}
case WM_PAINT:
{
PAINTSTRUCT ps;
BeginPaint(hDlg, &ps);
BitBlt(ps.hdc, ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right - ps.rcPaint.left, ps.rcPaint.bottom - ps.rcPaint.top, g_hdc, ps.rcPaint.left, ps.rcPaint.top, SRCCOPY);
EndPaint(hDlg, &ps);
break;
}
default:
return FALSE;
}
return TRUE;
}
void ferite_classic_free( void *targetptr, char *file, int line, FeriteScript *script )
{
#ifdef FERITE_MEM_DEBUG
struct ferite_memory_block *ptr, *temp_ptr;
if( targetptr == NULL )
printf( "Trying to free NULL ptr on %s:%d\n", file, line );
LOCK_MEMORY;
for( ptr = mem_rootblk; ptr->next != NULL; ptr = ptr->next )
{
if( ptr->next->data == targetptr )
{
# ifdef SUPER_VERBOSE
FUD(("INFO: Found memory block (%p). Freeing.\n", ptr->next->data));
# endif
ferite_classic_free_count++;
temp_ptr = ptr->next;
ptr->next = temp_ptr->next;
# ifdef SUPER_VERBOSE
FUD(("INFO: Freeing %p\n", temp_ptr->data ));
# endif
rfree( temp_ptr->data );
# ifdef SUPER_VERBOSE
FUD((" * Free'd data\n"));
# endif
free( temp_ptr->file );
# ifdef SUPER_VERBOSE
FUD((" * Free'd filename\n"));
# endif
free( temp_ptr );
# ifdef SUPER_VERBOSE
FUD((" * Free'd memory block\n"));
# endif
UNLOCK_MEMORY;
return;
}
}
FUD(("* URGH. Can't find block(%p) in memory list. Freeing Anyways.\n", targetptr));
free( targetptr );
UNLOCK_MEMORY;
#else
LOCK_MEMORY;
if( targetptr == NULL )
printf( "Trying to free null in %s at %d\n", file, line );
else
ferite_classic_free_count++;
rfree( targetptr );
UNLOCK_MEMORY;
#endif
}
/**
* \brief Creates selector component.
* \param[in,out] data Selector base component device.
* \return Pointer to selector base component device.
*/
static struct comp_dev *selector_new(struct sof_ipc_comp *comp)
{
struct sof_ipc_comp_process *ipc_process =
(struct sof_ipc_comp_process *)comp;
size_t bs = ipc_process->size;
struct comp_dev *dev;
struct comp_data *cd;
int ret;
trace_selector("selector_new()");
if (IPC_IS_SIZE_INVALID(ipc_process->config)) {
IPC_SIZE_ERROR_TRACE(TRACE_CLASS_SELECTOR, ipc_process->config);
return NULL;
}
dev = rzalloc(RZONE_RUNTIME, SOF_MEM_CAPS_RAM,
COMP_SIZE(struct sof_ipc_comp_process));
if (!dev)
return NULL;
assert(!memcpy_s(&dev->comp, sizeof(struct sof_ipc_comp_process), comp,
sizeof(struct sof_ipc_comp_process)));
cd = rzalloc(RZONE_RUNTIME, SOF_MEM_CAPS_RAM, sizeof(*cd));
if (!cd) {
rfree(dev);
return NULL;
}
comp_set_drvdata(dev, cd);
assert(!memcpy_s(&cd->config, sizeof(cd->config), ipc_process->data,
bs));
/* verification of initial parameters */
ret = sel_set_channel_values(cd, cd->config.in_channels_count,
cd->config.out_channels_count,
cd->config.sel_channel);
if (ret < 0) {
rfree(cd);
rfree(dev);
return NULL;
}
dev->state = COMP_STATE_READY;
return dev;
}
/**
@brief 密行列AをHessenberg型行列Bに相似変換する.
@param[in] n 正方行列A,Bのサイズ
@param[in] A 行列
@param[in] LDA Aの第1次元
@param[out] B 相似変換により得られたHessenberg型行列
@param[in] LDB Bの第1次元
*/
void chsnbrg_simtr(int n, cmulti **B, int LDB, cmulti **A, int LDA)
{
int i,prec=53;
rmulti *alpha=NULL;
cmulti **h=NULL;
// allocate
prec=cmat_get_prec_max(n,n,B,LDB);
alpha=rallocate_prec(prec);
h=cvec_allocate_prec(n,prec);
// copy
cmat_copy(n,n,B,LDB,A,LDA);
// compute
for(i=0; i<n-2; i++){
// Householder vector
chouseholder_vec(n,i+1,h,alpha,&COL(B,i,LDB));
// similarity transformation
chouseholder_right(n,n,B,LDB,B,LDB,i+1,h,alpha);
chouseholder_left(n,n,B,LDB,B,LDB,i+1,h,alpha);
// set lower part as zeros
cvec_set_zeros(n-2-i,&MAT(B,i+2,i,LDB));
}
// done
alpha=rfree(alpha);
h=cvec_free(n,h);
}
/**
* bgp_close - close a BGP instance
* @p: BGP instance
* @apply_md5: 0 to disable unsetting MD5 auth
*
* This function frees and deconfigures shared BGP resources.
* @apply_md5 is set to 0 when bgp_close is called as a cleanup
* from failed bgp_open().
*/
static void
bgp_close(struct bgp_proto *p, int apply_md5)
{
ASSERT(bgp_counter);
bgp_counter--;
if (p->cf->password && apply_md5)
sk_set_md5_auth(bgp_listen_sk, p->cf->remote_ip, p->cf->iface, NULL);
if (!bgp_counter)
{
rfree(bgp_listen_sk);
bgp_listen_sk = NULL;
rfree(bgp_linpool);
bgp_linpool = NULL;
}
}
/**
@brief ハウスホルダー・ベクトルへの変換.
@details h[0]=0; ...; h[k-1]=0; h[k]=-s*xi; h[k+1]=x[k+1]; ...; h[n-1]=x[n-1];
@param[in] h 初期化済みのベクトル.サイズはn.
@param[in] x 初期化済みのベクトル.サイズはn.
@param[in] n ベクトルのサイズ.
@param[in] k 第k要素が基準.
@param[out] h ハウスホルダー・ベクトル.
*/
void rhouseholder_vec(int n, int k, rmulti **h, rmulti *alpha, rmulti **x)
{
int p0,p1,prec;
rmulti *eta=NULL,*zeta=NULL,*xi=NULL,*axk=NULL;
// allocate
p0=rget_prec(alpha);
p1=rvec_get_prec_max(n,h);
prec=MAX2(p0,p1);
eta=rallocate_prec(prec);
zeta=rallocate_prec(prec);
xi=rallocate_prec(prec);
axk=rallocate_prec(prec);
//----------- norm
rvec_sum_pow2(xi,n-k-1,&x[k+1]); // xi=sum(abs(x((k+1):end)).^2);
rmul(axk,x[k],x[k]); // axk=|x[k]|^2
radd(eta,axk,xi); // eta=|x[k]|^2+...
rsqrt(axk,axk); // axk=|x[k]|
rsqrt(eta,eta); // eta=sqrt(|x[k]|^2+...)
if(req_d(eta,0)){rsub(xi,eta,axk);} // xi=eta-|x(k)|
else{ // xi=xi/(|x(k)|+eta)
radd(zeta,axk,eta);
rdiv(xi,xi,zeta);
}
//----------- h
rvec_set_zeros(k,h);
rvec_copy(n-k-1,&h[k+1],&x[k+1]); // h((k+1):end)=x((k+1):end);
if(ris_zero(x[k])){
rcopy(h[k],xi); rneg(h[k],h[k]); // h[k]=-xi
}else{
rdiv(zeta,xi,axk); rneg(zeta,zeta); // zeta=-xi/axk;
rmul(h[k],x[k],zeta); // h[k]=zeta*x[k];
}
//----------- alpha
if(req_d(xi,0) || req_d(eta,0)){
rset_d(alpha,0);
}else{
rmul(alpha,xi,eta); // alpha=1/(xi*eta)
rinv(alpha,alpha);
}
// free
eta=rfree(eta);
zeta=rfree(zeta);
xi=rfree(xi);
axk=rfree(axk);
}
/**
* bgp_close_conn - close a BGP connection
* @conn: connection to close
*
* This function takes a connection described by the &bgp_conn structure,
* closes its socket and frees all resources associated with it.
*/
void
bgp_close_conn(struct bgp_conn *conn)
{
// struct bgp_proto *p = conn->bgp;
DBG("BGP: Closing connection\n");
conn->packets_to_send = 0;
rfree(conn->connect_retry_timer);
conn->connect_retry_timer = NULL;
rfree(conn->keepalive_timer);
conn->keepalive_timer = NULL;
rfree(conn->hold_timer);
conn->hold_timer = NULL;
rfree(conn->sk);
conn->sk = NULL;
rfree(conn->tx_ev);
conn->tx_ev = NULL;
}
static int TestSingleMatch()
{
regex* re = regex_create("a", NULL);
program* prog = &(re->prog);
mu_assert("program length", prog->size == 2);
mu_assert("first inst is rule", prog->code[0].op == I_CHAR);
mu_assert("second inst is match", prog->code[1].op == I_MATCH);
rfree(re);
return 1;
}
void EvalCcRqGETFONTSIZES (CrossCallInfo *pcci) // textptr; no result.
{
HDC hdc;
hdc = GetDC (ghMainWindow);
EnumFontFamilies (hdc, (char *) pcci->p1, (FONTENUMPROC) EnumFontSizeProc, 0);
ReleaseDC (ghMainWindow, hdc);
rfree ((char *) pcci->p1);
MakeReturn0Cci (pcci);
}
static int TestConcat()
{
regex* re = regex_create("ab", NULL);
program* prog = &(re->prog);
mu_assert("program length", prog->size == 3);
mu_assert("first inst is split", prog->code[0].op == I_CHAR);
mu_assert("second inst is rule", prog->code[1].op == I_CHAR);
mu_assert("third inst is match", prog->code[2].op == I_MATCH);
rfree(re);
return 1;
}
static void free_mem_load(struct comp_data *cd)
{
if (!cd) {
trace_keyword_error("free_mem_load() error: invalid cd");
return;
}
if (cd->load_memory) {
rfree(cd->load_memory);
cd->load_memory = NULL;
}
}
/**
* bgp_incoming_connection - handle an incoming connection
* @sk: TCP socket
* @dummy: unused
*
* This function serves as a socket hook for accepting of new BGP
* connections. It searches a BGP instance corresponding to the peer
* which has connected and if such an instance exists, it creates a
* &bgp_conn structure, attaches it to the instance and either sends
* an Open message or (if there already is an active connection) it
* closes the new connection by sending a Notification message.
*/
static int
bgp_incoming_connection(sock *sk, int dummy UNUSED)
{
struct proto_config *pc;
DBG("BGP: Incoming connection from %I port %d\n", sk->daddr, sk->dport);
WALK_LIST(pc, config->protos)
if (pc->protocol == &proto_bgp && pc->proto)
{
struct bgp_proto *p = (struct bgp_proto *) pc->proto;
if (ipa_equal(p->cf->remote_ip, sk->daddr) &&
(!ipa_has_link_scope(sk->daddr) || (p->cf->iface == sk->iface)))
{
/* We are in proper state and there is no other incoming connection */
int acc = (p->p.proto_state == PS_START || p->p.proto_state == PS_UP) &&
(p->start_state >= BSS_CONNECT) && (!p->incoming_conn.sk);
if (p->conn && (p->conn->state == BS_ESTABLISHED) && p->gr_ready)
{
bgp_store_error(p, NULL, BE_MISC, BEM_GRACEFUL_RESTART);
bgp_handle_graceful_restart(p);
bgp_conn_enter_idle_state(p->conn);
acc = 1;
}
BGP_TRACE(D_EVENTS, "Incoming connection from %I%J (port %d) %s",
sk->daddr, ipa_has_link_scope(sk->daddr) ? sk->iface : NULL,
sk->dport, acc ? "accepted" : "rejected");
if (!acc)
goto reject;
int hops = p->cf->multihop ? : 1;
if (sk_set_ttl(sk, p->cf->ttl_security ? 255 : hops) < 0)
goto err;
if (p->cf->ttl_security)
if (sk_set_min_ttl(sk, 256 - hops) < 0)
goto err;
bgp_setup_conn(p, &p->incoming_conn);
bgp_setup_sk(&p->incoming_conn, sk);
bgp_send_open(&p->incoming_conn);
return 0;
err:
sk_log_error(sk, p->p.name);
log(L_ERR "%s: Incoming connection aborted", p->p.name);
rfree(sk);
return 0;
}
}
void solveSudoku(vector<vector<char> > &board) {
vector<vector<bool> >rfree(9, vector<bool>(9, true));
vector<vector<bool> >cfree(9, vector<bool>(9, true));
vector<vector<bool> >sfree(9, vector<bool>(9, true));
vector<int> ei;
vector<int> ej;
// init
init(board, rfree, cfree, sfree, ei, ej);
int size = ei.size();
helper(board, rfree, cfree, sfree, ei, ej, 0, size-1);
}
static int TestStar()
{
regex* re = regex_create("a*", NULL);
program* prog = &(re->prog);
mu_assert("program length", prog->size == 4);
mu_assert("first inst is split", prog->code[0].op == I_SPLIT);
mu_assert("second inst is rule", prog->code[1].op == I_CHAR);
mu_assert("third inst is jmp", prog->code[2].op == I_JMP);
mu_assert("final inst is match", prog->code[3].op == I_MATCH);
rfree(re);
return 1;
}
static void processVerDef(Elf_Scn *scn, GElf_Shdr *shdr, elfInfo *ei)
{
Elf_Data *data = NULL;
unsigned int offset, auxoffset;
char *soname = NULL;
while ((data = elf_getdata(scn, data)) != NULL) {
offset = 0;
for (int i = shdr->sh_info; --i >= 0; ) {
GElf_Verdef def_mem, *def;
def = gelf_getverdef (data, offset, &def_mem);
if (def == NULL)
break;
auxoffset = offset + def->vd_aux;
offset += def->vd_next;
for (int j = def->vd_cnt; --j >= 0; ) {
GElf_Verdaux aux_mem, * aux;
const char *s;
aux = gelf_getverdaux (data, auxoffset, &aux_mem);
if (aux == NULL)
break;
s = elf_strptr(ei->elf, shdr->sh_link, aux->vda_name);
if (s == NULL)
break;
if (def->vd_flags & VER_FLG_BASE) {
rfree(soname);
soname = rstrdup(s);
auxoffset += aux->vda_next;
continue;
} else if (soname && !soname_only && !skipPrivate(s)) {
addDep(&ei->provides, soname, s, ei->marker);
}
}
}
}
rfree(soname);
}
static void processVerNeed(Elf_Scn *scn, GElf_Shdr *shdr, elfInfo *ei)
{
Elf_Data *data = NULL;
char *soname = NULL;
while ((data = elf_getdata(scn, data)) != NULL) {
unsigned int offset = 0, auxoffset;
for (int i = shdr->sh_info; --i >= 0; ) {
const char *s = NULL;
GElf_Verneed need_mem, *need;
need = gelf_getverneed (data, offset, &need_mem);
if (need == NULL)
break;
s = elf_strptr(ei->elf, shdr->sh_link, need->vn_file);
if (s == NULL)
break;
rfree(soname);
soname = rstrdup(s);
auxoffset = offset + need->vn_aux;
for (int j = need->vn_cnt; --j >= 0; ) {
GElf_Vernaux aux_mem, * aux;
aux = gelf_getvernaux (data, auxoffset, &aux_mem);
if (aux == NULL)
break;
s = elf_strptr(ei->elf, shdr->sh_link, aux->vna_name);
if (s == NULL)
break;
if (ei->isExec && soname && !soname_only && !skipPrivate(s)) {
addDep(&ei->requires, soname, s, ei->marker);
}
auxoffset += aux->vna_next;
}
offset += need->vn_next;
}
}
rfree(soname);
}
void refbuf_free_help(refbuf_t rbuf) {
refbuf_free_t rfree = rbuf->free ;
env_t env = rbuf->env ;
buf_t buf = rbuf->buf ;
assert(rbuf->count == 1) ;
assert(rbuf != &zero_rbuf) ;
record_free(rbuf) ;
nactive -- ;
if (rfree) {
rfree(env, buf) ;
} else {
sys_free(buf) ;
}
}
void EvalCcRqINSERTMENUITEM (CrossCallInfo *pcci)
{
gchar *title;
GtkWidget *menu, *menu_item, *label;
GtkAccelGroup *accel_group;
guint graystate, checkstate;
printf("EvalCcRqINSERTMENUITEM\n");
printf("Inserting item with position %d and name %s\n", pcci->p5, (char*)pcci->p3);
printf("Checking graystate: ");
if (pcci->p1)
{
graystate = 1; // MF_ENABLED
} else {
graystate = 0; // MF_GRAYED;
}
printf("%s\n", (graystate ? "enabled" : "grayed"));
printf("Checking checkstate: ");
if (pcci->p4)
{
checkstate = 1; // MF_CHECKED
} else {
checkstate = 0; // MF_UNCHECKED
}
printf("%s\n", (checkstate ? "checked" : "unchecked"));
printf("Calling Make Mnemonic string with: %s\n", (gchar*)pcci->p3);
title = createMnemonicString((gchar *) pcci->p3);
printf("Got title: %s\n", title);
menu = GTK_WIDGET(pcci->p2);
printf("Creating new menu item\n");
menu_item = gtk_menu_item_new_with_mnemonic(title);
gtk_menu_shell_insert( GTK_MENU_SHELL (menu), menu_item, (gint) pcci->p5);
gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
GTK_SIGNAL_FUNC (menuitem_activate_handler), menu_item);
gtk_widget_show(menu_item);
printf("About to free title: %s\n", title);
rfree(title);
printf("Freed title\n");
printf("Creating return Cci\n");
MakeReturn1Cci (pcci, (int64_t) menu_item);
}
static void objcode_fix(cmd_rec *cmd)
/* For $ strings. Fixes object redirection if neccessary */
{
int actorword;
word nounword, objword;
int dobj_obj, iobj_obj;
int savedobj, saveactor;
parse_rec *savedrec, *saveactrec, *saveirec;
rbool achange, dchange, ichange; /* Did the given _rec ptr change? */
/* dobj_obj/iobj_obj take precedence over anything else */
actorword=cmd->actor; nounword=cmd->nouncmd; objword=cmd->objcmd;
dobj_obj=cmd->noun_obj; iobj_obj=cmd->obj_obj;
/* Make temporary copies of things for when more than one thing is
being shuffled around; we don't need to save iobj since
it's processed last */
saveactor=actor; saveactrec=actor_rec;
savedobj=dobj; savedrec=dobj_rec;
saveirec=iobj_rec; /* Saved only so it can be freed */
/* Fix object numbers... */
fix_objnum(&actor,actorword,0,saveactor,savedobj,iobj);
fix_objnum(&dobj,nounword,dobj_obj,saveactor,savedobj,iobj);
fix_objnum(&iobj,objword,iobj_obj,saveactor,savedobj,iobj);
/* ... and records */
achange=fix_objrec(&actor_rec,actorword,0,saveactrec,savedrec,iobj_rec);
dchange=fix_objrec(&dobj_rec,nounword,dobj_obj,saveactrec,savedrec,iobj_rec);
ichange=fix_objrec(&iobj_rec,objword,iobj_obj,saveactrec,savedrec,iobj_rec);
/* Free up whatever needs freeing */
if (achange) rfree(saveactrec);
if (dchange) rfree(savedrec);
if (ichange) rfree(saveirec);
}
static regex_t *rpmfcAttrReg(const char *name,
const char *attr_prefix, const char *attr)
{
regex_t *reg = NULL;
char *pattern = rpmfcAttrMacro(name, attr_prefix, attr);
if (pattern) {
reg = xcalloc(1, sizeof(*reg));
if (regcomp(reg, pattern, REG_EXTENDED) != 0) {
rpmlog(RPMLOG_WARNING, _("Ignoring invalid regex %s\n"), pattern);
reg = _free(reg);
}
rfree(pattern);
}
return reg;
}
void EvalCcRqMODIFYMENUITEM (CrossCallInfo *pcci) /* hitem, hmenu, textptr; no result. */
{
GtkWidget *menu, *menu_item, *label;
gchar *title;
printf("EvalCcRqMODIFYMENUITEM\n");
title = createMnemonicString((gchar *) pcci->p3);
menu = GTK_WIDGET(pcci->p2);
menu_item = GTK_WIDGET(pcci->p1);
label = gtk_bin_get_child(GTK_BIN(menu_item));
gtk_label_set_text_with_mnemonic(GTK_LABEL(label), title);
rfree(title);
MakeReturn0Cci (pcci);
}
/**
@brief ハウスホルダー変換を右から作用 B=A*H, H=I-alpha*h*h'
@details h[0]=0; ...; h[k-1]=0; h[k]=-s*xi; h[k+1]=x[k+1]; ...; h[n-1]=x[n-1];
@param[in] m 行列Aの行の個数.
@param[in] n 行列Aの列の個数.
@param[in] k 第k要素が基準.
@param[in] h ハウスホルダー・ベクトル.
@param[in] alpha ハウスホルダー・ベクトルの規格化定数.
@param[out] B 変換された行列B.
*/
void rhouseholder_right(int m, int n, rmulti **B, int LDB, rmulti **A, int LDA, int k, rmulti **h, rmulti *alpha)
{
int prec;
rmulti *a=NULL,**p=NULL;
// allocate
prec=rmat_get_prec_max(m,n,B,LDB);
a=rallocate_prec(prec);
p=rvec_allocate_prec(m,prec);
// p=A*h
rvec_lintr(m,n-k,p,&COL(A,k,LDA),LDA,&h[k]);
// B=A*H=A-alpha*(A*h)*h'=A-alpha*p*h'
rneg(a,alpha);
rmat_rank1op(m,n-k,&COL(B,k,LDB),LDB,&COL(A,k,LDA),LDA,a,p,&h[k]);
// done
a=rfree(a);
p=rvec_free(m,p);
}
void
Space::kill_brancher(unsigned int id) {
if (failed())
return;
for (Brancher* b = Brancher::cast(bl.next());
b != Brancher::cast(&bl); b = Brancher::cast(b->next()))
if (b->id() == id) {
// Make sure that neither b_status nor b_commit does not point to b
if (b_commit == b)
b_commit = Brancher::cast(b->next());
if (b_status == b)
b_status = Brancher::cast(b->next());
b->unlink();
rfree(b,b->dispose(*this));
return;
}
}
/**
@brief ハウスホルダー変換を左から作用 B=H*A, H=I-alpha*h*h'
@details h[0]=0; ...; h[k-1]=0; h[k]=-s*xi; h[k+1]=x[k+1]; ...; h[n-1]=x[n-1];
@param[in] m 行列Aの行の個数.
@param[in] n 行列Aの列の個数.
@param[in] k 第k要素が基準.
@param[in] h ハウスホルダー・ベクトル.
@param[in] alpha ハウスホルダー・ベクトルの規格化定数.
@param[out] B 変換された行列B.
*/
void rhouseholder_left(int m, int n, rmulti **B, int LDB, rmulti **A, int LDA, int k, rmulti **h, rmulti *alpha)
{
int prec;
rmulti *a=NULL,**p=NULL;
// allocate
prec=rmat_get_prec_max(m,n,B,LDB);
a=rallocate_prec(prec);
p=rvec_allocate_prec(m,prec);
// p=A'*h
rvec_lintr_t(m-k,n,p,&MAT(A,k,0,LDA),LDA,&h[k]);
// B=H*A=A-alpha*h*(A'*h)'=A-alpha*h*p'
rneg(a,alpha);
rmat_rank1op(m-k,n,&MAT(B,k,0,LDB),LDB,&MAT(A,k,0,LDA),LDA,a,&h[k],p);
// done
a=rfree(a);
p=rvec_free(m,p);
}
/* Insert a menu into the menu bar. */
void EvalCcRqINSERTMENU (CrossCallInfo *pcci)
{
gint i;
gchar *title;
GtkWidget *parent_menu, *root_menu, *sub_menu;
GtkAccelGroup *accel_group;
printf("EvalCcRqINSERTMENU\n");
title = createMnemonicString((gchar *) pcci->p3);
parent_menu = GTK_WIDGET(pcci->p2);
sub_menu = GTK_WIDGET(pcci->p4);
if (GTK_IS_MENU_BAR(parent_menu))
{
printf("Adding to a menu bar.\n");
GtkWidget *frame = gtk_widget_get_parent(gtk_widget_get_parent(parent_menu));
if (!G_IS_OBJECT(frame))
frame = gtk_widget_get_parent(parent_menu);
accel_group = ((GtkAccelGroup*)gtk_accel_groups_from_object (G_OBJECT(frame))->data);
}
else
{
printf("We're not adding to a menu bar!?!\n");
accel_group = gtk_menu_get_accel_group (GTK_MENU(parent_menu));
}
gtk_menu_set_accel_group (GTK_MENU(sub_menu), accel_group);
root_menu = gtk_menu_item_new_with_mnemonic(title);
gtk_widget_set_sensitive(root_menu, (gboolean) pcci->p1);
gtk_widget_show (root_menu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), sub_menu);
if (GTK_IS_MENU_BAR(parent_menu))
{
gtk_menu_shell_insert(GTK_MENU_SHELL(parent_menu), root_menu, (gint) pcci->p5);
} else {
gtk_menu_insert(GTK_MENU(parent_menu), root_menu, (gint) pcci->p5);
}
rfree(title);
MakeReturn1Cci (pcci, (int64_t) sub_menu);
}