A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/bNNI_8cpp_source.html below:

NCBI C++ ToolKit: src/algo/phy_tree/fastme/bNNI.cpp Source File

63 void reHeapElement

(

int

*p,

int

*q,

double

*v,

int

length,

int i

);

64 void pushHeap

(

int

*p,

int

*q,

double

*v,

int

length,

int i

);

65 void popHeap

(

int

*p,

int

*q,

double

*v,

int

length,

int i

);

69  double

*weights,

int

*

location

,

int

*possibleSwaps)

89 int makeThreshHeap

(

int

*p,

int

*q,

double

*v,

int

arraySize,

double

thresh);

96

fprintf(ofile,

"%d\n"

,dim-1);

99

fprintf(ofile,

"%s "

,e->

head

->

label

);

101

fprintf(ofile,

"%lf "

,

M

[e->

head

->

index

][

f

->head->index]);

102

fprintf(ofile,

"\n"

);

125

weights = (

double

*)

malloc

((

T

->size+1)*

sizeof

(double));

127  for

(

i

=0;

i

<

T

->size+1;

i

++)

157  while

(weights[p[1]] < -1e-8)

159

centerEdge = edgeArray[p[1]];

163  T

->weight =

T

->weight + weights[p[1]];

164

printf(

"New tree weight is %lf.\n"

,

T

->weight);

170  popHeap

(p,q,weights,possibleSwaps--,1);

196  double

dcoeff,

int

direction)

207  updatePair

(

A

, rootEdge, rootEdge, closer, further, dcoeff,

UP

);

231  updatePair

(

A

, rootEdge, rootEdge, closer, further, dcoeff,

UP

);

264

printf(

"Performing branch swap across edge %s "

,e->

label

);

266  if

(

LEFT

== direction)

268  else

printf(

"right "

);

269

printf(

"subtree.\n"

);

274  if

(

LEFT

== direction)

295 double wf5

(

double

D_AD,

double

D_BC,

double

D_AC,

double

D_BD,

296  double

D_AB,

double

D_CD)

299  weight

= 0.25*(D_AC + D_BD + D_AD + D_BC) + 0.5*(D_AB + D_CD);

306  double

D_LR, D_LU, D_LD, D_RD, D_RU, D_DU;

322

w0 =

wf5

(D_RU,D_LD,D_LU,D_RD,D_DU,D_LR);

323

w1 =

wf5

(D_RU,D_LD,D_DU,D_LR,D_LU,D_RD);

324

w2 =

wf5

(D_DU,D_LR,D_LU,D_RD,D_RU,D_LD);

337

printf(

"Possible swap across %s. "

,e->

label

);

338

printf(

"Weight dropping by %lf.\n"

,w0 - w2);

339

printf(

"New weight would be %lf.\n"

,

T

->weight + w2 - w0);

349

printf(

"Possible swap across %s. "

,e->

label

);

350

printf(

"Weight dropping by %lf.\n"

,w0 - w2);

351

printf(

"New weight should be %lf.\n"

,

T

->weight + w2 - w0);

360

printf(

"Possible swap across %s. "

,e->

label

);

361

printf(

"Weight dropping by %lf.\n"

,w0 - w1);

362

printf(

"New weight should be %lf.\n"

,

T

->weight + w1 - w0);

376  g

=

f

->tail->parentEdge;

397

-

A

[

g

->head->index][

f

->head->index]);

405

-

A

[

f

->head->index][

g

->head->index]);

411  int

up, down, left, right;

416

e->

distance

= 0.25*(

A

[up][left] +

A

[up][right] +

A

[left][down] +

A

[right][down]) - 0.5*(

A

[down][up] +

A

[left][right]);

double wf5(double D_AD, double D_BC, double D_AC, double D_BD, double D_AB, double D_CD)

void printMatrix(double **M, int dim, FILE *ofile, meTree *T)

void bNNI(meTree *T, double **avgDistArray, int *count)

void updateSubTreeAfterNNI(double **A, meNode *v, meEdge *rootEdge, meNode *closer, meNode *further, double dcoeff, int direction)

void bNNIRetestEdge(int *p, int *q, meEdge *e, meTree *T, double **avgDistArray, double *weights, int *location, int *possibleSwaps)

void limitedFillTableUp(meEdge *e, meEdge *f, double **A, meEdge *trigger)

meEdge * findBottomLeft(meEdge *e)

meEdge * siblingEdge(meEdge *e)

void updatePair(double **A, meEdge *nearEdge, meEdge *farEdge, meNode *closer, meNode *further, double dcoeff, int direction)

void pushHeap(int *p, int *q, double *v, int length, int i)

void bNNItopSwitch(meTree *T, meEdge *e, int direction, double **A)

void WFint(meEdge *e, double **A)

void reHeapElement(int *p, int *q, double *v, int length, int i)

int makeThreshHeap(int *p, int *q, double *v, int arraySize, double thresh)

meEdge * moveUpRight(meEdge *e)

void weighTree(meTree *T)

void updateAveragesMatrix(meTree *T, double **A, meNode *v, int direction)

void popHeap(int *p, int *q, double *v, int length, int i)

meEdge * depthFirstTraverse(meTree *T, meEdge *e)

meEdge * topFirstTraverse(meTree *T, meEdge *e)

void WFext(meEdge *e, double **A)

void bNNIupdateAverages(double **A, meNode *v, meEdge *par, meEdge *skew, meEdge *swap, meEdge *fixed)

int bNNIEdgeTest(meEdge *e, meTree *T, double **A, double *weight)

void permInverse(int *p, int *q, int length)

void assignBalWeights(meTree *T, double **A)

static const char location[]

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

#define BEGIN_SCOPE(ns)

Define a new scope.

unsigned int

A callback function used to compare two keys in a database.

const struct ncbi::grid::netcache::search::fields::SIZE size

struct meEdge * rightEdge

struct meEdge * parentEdge

int g(Seg_Gsm *spe, Seq_Mtf *psm, Thd_Gsm *tdg)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4