bool symmetric(TreeNode *left, TreeNode *right){
if(left==NULL && right==NULL) return true;
if(left==NULL || right==NULL) return false;
if((left->val) != (right->val)) return false;
return symmetric(left->right, right->left)
&&symmetric(left->left, right->right);
}
bool symmetric(TreeNode* first, TreeNode* second) {
if (first == NULL && second == NULL) return true;
if (first == NULL || second == NULL) return false;
if (first->val != second->val) return false;
return symmetric(first->left, second->right) && symmetric(first->right, second->left);
}
bool symmetric(struct TreeNode *lhs,struct TreeNode *rhs)
{
if(lhs==NULL&&rhs==NULL)
return true;
else if(lhs!=NULL&&rhs!=NULL&&lhs->val==rhs->val)
return symmetric(lhs->left,rhs->right)&&symmetric(lhs->right,rhs->left);
else
return false;
}
//version 1 recursive
bool symmetric( struct TreeNode* left, struct TreeNode* right )
{
if(!left && !right)
return true;
else if(!left || !right)
return false;
if(left->val != right->val)
return false;
return symmetric(left->left, right->right) && symmetric(left->right, right->left);
}
scoreAndLoc BoardThread::alphabeta(bool maximize, int alpha, int beta,
size_t depth, int justPlayed){
recursionCount++;
if (depth > 0 && memberOfAP(justPlayed))
{ return ((grid[justPlayed]=='R')?r_win:b_win); }
if (depth == n) { return draw; }
int max = -10; int min = 10; int loc = -1;
//symmetry -> don't bother checking rhs
bool s = symmetric();
//Loop
for(int i = ((n%2)?(n/2):((n/2) - 1)); i > -1; i--){
if (depth == 0 && i%numThreads != id) { continue; }
//Check i
if (!(depth == 0 && i==0) &&
alphabeta_helper(i, maximize, depth, max, min, loc, alpha, beta))
{ break; }
if (s) {continue;}
int j = n-i-1;
if (alphabeta_helper(j, maximize, depth, max, min, loc, alpha, beta))
{ break; }
}
return scoreAndLoc((maximize?max:min), loc);
}
bool symmetric(TreeNode *left, TreeNode *right) {
if (left == NULL && right != NULL)
return false;
if (left != NULL && right == NULL)
return false;
if (left == NULL && right == NULL)
return true;
if (left->val != right->val)
return false;
bool lsym = symmetric(left->left, right->right);
bool rsym = symmetric(left->right, right->left);
return lsym && rsym;
}
int main(){
int a;
printf("Digite um número: > ");
scanf("%d",&a);
printf("O simétrico de %d é %d\n",a,symmetric(a));
return 0;
}
Graph undirected(Graph g) {
using ConstNode = typename Graph::ConstNode_t;
Graph symm = symmetric(g);
symm.eachEdges([&g, &symm](ConstNode begin, ConstNode end) {
g.connect(g[begin.getName()], g[end.getName()], symm.getEdgeProperty(begin, end));
});
return g;
}
std::set<typename Graph::ConstNode_t> stronglyConnectedComponent(
Graph const& g,
typename Graph::ConstNode_t const& vertex) {
using Node = typename Graph::ConstNode_t;
std::set<Node> verticesToCheck{vertex}, existPathToVertex{vertex},
existPathToVertexSym{vertex};
while(!verticesToCheck.empty()) {
auto currentVertex = *verticesToCheck.begin();
verticesToCheck.erase(currentVertex);
g.eachAdjacents(currentVertex,
[&existPathToVertex, &verticesToCheck](Node i) {
if(existPathToVertex.find(i) == existPathToVertex.end()) {
verticesToCheck.insert(i);
existPathToVertex.insert(i);
}
});
}
Graph sym = symmetric(g);
verticesToCheck = std::set<Node>{sym[vertex.getName()]};
while(!verticesToCheck.empty()) {
auto currentVertex = *verticesToCheck.begin();
verticesToCheck.erase(currentVertex);
sym.eachAdjacents(currentVertex,
[&existPathToVertexSym, &verticesToCheck, &g](Node i) {
if(existPathToVertexSym.find(i) == existPathToVertexSym.end()) {
verticesToCheck.insert(i);
existPathToVertexSym.insert(i);
}
});
}
std::set<Node> existPathToVertexSymTemp, component;
for(auto const& node : existPathToVertexSym) {
existPathToVertexSymTemp.insert(g[node.getName()]);
}
std::set_intersection(existPathToVertex.begin(),
existPathToVertex.end(),
existPathToVertexSymTemp.begin(),
existPathToVertexSymTemp.end(),
std::inserter(component, component.begin()));
return component;
}
std::set<typename Graph::ConstNode_t> connectedComponent(
Graph const& g,
typename Graph::ConstNode_t const& vertex) {
using Node = typename Graph::ConstNode_t;
std::set<std::string> verticesToCheck{vertex.getName()}, component{vertex.getName()};
Graph sym = symmetric(g);
while(!verticesToCheck.empty()) {
auto currentVertex = *verticesToCheck.begin();
verticesToCheck.erase(currentVertex);
g.eachAdjacents(g[currentVertex],
[&component, &verticesToCheck](Node i) {
std::string nodeName = i.getName();
if(component.find(nodeName) == component.end()) {
verticesToCheck.insert(nodeName);
component.insert(nodeName);
}
});
sym.eachAdjacents(sym[currentVertex],
[&component, &verticesToCheck, &g](Node i) {
std::string nodeName = i.getName();
if(component.find(nodeName) == component.end()) {
verticesToCheck.insert(nodeName);
component.insert(nodeName);
}
});
}
std::set<Node> nodeComponent;
for(auto const& nodeName : component) {
nodeComponent.insert(g[nodeName]);
}
return nodeComponent;
}
bool isSymmetric(TreeNode *root) {
if (root == NULL) return true;
return symmetric(root->left, root->right);
}
void Foam::lduMatrix::operator-=(const lduMatrix& A)
{
if (A.diagPtr_)
{
diag() -= A.diag();
}
if (symmetric() && A.symmetric())
{
upper() -= A.upper();
}
else if (symmetric() && A.asymmetric())
{
if (upperPtr_)
{
lower();
}
else
{
upper();
}
upper() -= A.upper();
lower() -= A.lower();
}
else if (asymmetric() && A.symmetric())
{
if (A.upperPtr_)
{
lower() -= A.upper();
upper() -= A.upper();
}
else
{
lower() -= A.lower();
upper() -= A.lower();
}
}
else if (asymmetric() && A.asymmetric())
{
lower() -= A.lower();
upper() -= A.upper();
}
else if (diagonal())
{
if (A.upperPtr_)
{
upper() = -A.upper();
}
if (A.lowerPtr_)
{
lower() = -A.lower();
}
}
else if (A.diagonal())
{
}
else
{
if (debug > 1)
{
WarningIn("lduMatrix::operator-=(const lduMatrix& A)")
<< "Unknown matrix type combination" << nl
<< " this :"
<< " diagonal:" << diagonal()
<< " symmetric:" << symmetric()
<< " asymmetric:" << asymmetric() << nl
<< " A :"
<< " diagonal:" << A.diagonal()
<< " symmetric:" << A.symmetric()
<< " asymmetric:" << A.asymmetric()
<< endl;
}
}
}
void Foam::BlockLduMatrix<Type>::AmulCore
(
TypeField& Ax,
const TypeField& x
) const
{
typedef typename TypeCoeffField::scalarTypeField scalarTypeField;
typedef typename TypeCoeffField::linearTypeField linearTypeField;
typedef typename TypeCoeffField::squareTypeField squareTypeField;
const unallocLabelList& u = lduAddr().upperAddr();
const unallocLabelList& l = lduAddr().lowerAddr();
const TypeCoeffField& Diag = this->diag();
const TypeCoeffField& Upper = this->upper();
// Create multiplication function object
typename BlockCoeff<Type>::multiply mult;
// Diagonal multiplication, no indirection
multiply(Ax, Diag, x);
// Lower multiplication
if (symmetric())
{
if (Upper.activeType() == blockCoeffBase::SCALAR)
{
const scalarTypeField& activeUpper = Upper.asScalar();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
Ax[u[coeffI]] += mult(activeUpper[coeffI], x[l[coeffI]]);
}
}
else if (Upper.activeType() == blockCoeffBase::LINEAR)
{
const linearTypeField& activeUpper = Upper.asLinear();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
Ax[u[coeffI]] += mult(activeUpper[coeffI], x[l[coeffI]]);
}
}
else if (Upper.activeType() == blockCoeffBase::SQUARE)
{
const squareTypeField& activeUpper = Upper.asSquare();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
// Use transpose upper coefficient
Ax[u[coeffI]] +=
mult(activeUpper[coeffI].T(), x[l[coeffI]]);
}
}
}
else // Asymmetric matrix
{
const TypeCoeffField& Lower = this->lower();
if (Lower.activeType() == blockCoeffBase::SCALAR)
{
const scalarTypeField& activeLower = Lower.asScalar();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
Ax[u[coeffI]] += mult(activeLower[coeffI], x[l[coeffI]]);
}
}
else if (Lower.activeType() == blockCoeffBase::LINEAR)
{
const linearTypeField& activeLower = Lower.asLinear();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
Ax[u[coeffI]] += mult(activeLower[coeffI], x[l[coeffI]]);
}
}
else if (Lower.activeType() == blockCoeffBase::SQUARE)
{
const squareTypeField& activeLower = Lower.asSquare();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
Ax[u[coeffI]] += mult(activeLower[coeffI], x[l[coeffI]]);
}
}
}
// Upper multiplication
if (Upper.activeType() == blockCoeffBase::SCALAR)
{
const scalarTypeField& activeUpper = Upper.asScalar();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
Ax[l[coeffI]] += mult(activeUpper[coeffI], x[u[coeffI]]);
}
}
else if (Upper.activeType() == blockCoeffBase::LINEAR)
{
const linearTypeField& activeUpper = Upper.asLinear();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
Ax[l[coeffI]] += mult(activeUpper[coeffI], x[u[coeffI]]);
}
}
else if (Upper.activeType() == blockCoeffBase::SQUARE)
{
const squareTypeField& activeUpper = Upper.asSquare();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
Ax[l[coeffI]] += mult(activeUpper[coeffI], x[u[coeffI]]);
}
}
}
static int squares_remaining(int row, int col)
{
int rowsquares = N * (N - 2 * row);
int n = (row == symmetric(row) ? 1 : 2) * (N - col + 1);
return rowsquares > 0 ? n + rowsquares : n;
}
bool isSymmetric(TreeNode* root) {
return symmetric(root, root);
}
bool isSymmetric( struct TreeNode * root )
{
if(!root)
return true;
return symmetric(root->left, root->right);
}
/***********************************************************************//**
* @brief Test matrix allocation
***************************************************************************/
void TestGMatrixSparse::alloc_matrix(void)
{
// Allocate zero matrix. The allocation should fail.
test_try("Allocate zero matrix");
try {
GMatrixSparse test(0,0);
test_try_failure("Expected GException::empty exception.");
}
catch (GException::empty &e) {
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Setup a symmetric sparse matrix
int size = 30;
GMatrixSparse symmetric(size,size);
for (int i = 0; i < size; i+=2) {
for (int j = 0; j < size; j+=2) {
symmetric(i,j) = 1.0+i+j;
}
}
// Convert to GMatrix
test_try("Test symmetric GMatrix conversion");
try {
GMatrix cnv_matrix = GMatrix(symmetric);
GMatrixSparse back_matrix = GMatrixSparse(cnv_matrix);
test_assert((symmetric == back_matrix),
"Test symmetric GMatrixSparse - GMatrix conversion",
"Found:\n"+back_matrix.print()+"\nExpected:\n"+symmetric.print());
test_try_success();
}
catch (GException::empty &e) {
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Test GMatrix conversion
test_try("Test GMatrix conversion");
try {
GMatrix cnv_matrix = GMatrix(m_test);
GMatrixSparse back_matrix = GMatrixSparse(cnv_matrix);
test_assert((m_test == back_matrix),
"Test GMatrixSparse - GMatrix conversion",
"Found:\n"+back_matrix.print()+"\nExpected:\n"+m_test.print());
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Test GMatrixSparse <-> GMatrixSymmetric conversion
test_try("Test GMatrixSymmetric conversion");
try {
GMatrixSymmetric cnv_sym = GMatrixSymmetric(symmetric);
GMatrixSparse back_sym = GMatrixSparse(cnv_sym);
test_assert((symmetric == back_sym),
"Test GMatrixSparse - GMatrixSymmetric conversion",
"Found:\n"+back_sym.print()+"\nExpected:\n"+symmetric.print());
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Test invalid GMatrixSparse <-> GMatrixSymmetric conversion
test_try("Test invalid GMatrixSymmetric conversion");
try {
GMatrixSymmetric bad_sym = GMatrixSymmetric(m_test);
test_try_failure("Expected GException::matrix_not_symmetric exception.");
}
catch (GException::matrix_not_symmetric &e) {
test_try_success();
}
catch (std::exception &e) {
test_try_failure(e);
}
// Return
return;
}
/*******************************************************************************
*
* The main function.
*
******************************************************************************/
int main(int argc, char** argv) {
if (argc <= 1) {
printf("\n Please provide a filename as a command line argument.\n");
exit(-1);
}
FILE *inputfile;
int matrixOrder = 0, i = 0, j = 0, edges = 0;
int** matrix;
node* vertices;
node* mergedArray;
inputfile = fopen(argv[1], "r");
if (inputfile == NULL) {
printf("\nThere was an error in opening the file.\n");
exit(-1);
}
//Read the number of elements.
fscanf(inputfile, "%d", &matrixOrder);
//Initialize the values of the pointers to NULL.
matrix = (int**) malloc(matrixOrder * sizeof (int *));
vertices = (node*) malloc(matrixOrder * sizeof (node));
mergedArray = (node*) malloc(matrixOrder * sizeof (node));
//Initialise to zero.
for (i = 0; i < matrixOrder; i++) {
matrix[i] = (int*) malloc(matrixOrder * sizeof (int));
vertices[i].degree = 0;
vertices[i].colour = 0;
}
//Read in the matrix from the input file.
for (i = 0; i < matrixOrder; i++) {
vertices[i].index = i;
for (j = 0; j < matrixOrder; j++) {
fscanf(inputfile, "%d", &matrix[i][j]);
}
}
fclose(inputfile);
//Ensure graph is undirected.
symmetric(matrix, matrixOrder);
//Calculate degrees
for (i = 0; i < matrixOrder; i++) {
for (j = 0; j < matrixOrder; j++) {
if (matrix[i][j]) {
vertices[i].degree++;
}
}
}
//DFS Algorithm:
DFS(vertices, -1, 0, 1, matrix, matrixOrder);
printOutput(vertices, matrix, matrixOrder, "DFS");
//DFS Improved Algorithm:
DFSimproved(vertices, matrix, matrixOrder);
printOutput(vertices, matrix, matrixOrder, "DFS Improved");
//Applying Merge Sort for the above Greedy-based Algorithm:
mergeSort(vertices, 0, matrixOrder, mergedArray);
greedyPartition(vertices, matrix, matrixOrder);
printOutput(vertices, matrix, matrixOrder, "Greedy-based Algorithm");
free(vertices);
free(matrix);
return (EXIT_SUCCESS);
}
void Foam::lduMatrix::operator+=(const lduMatrix& A)
{
if (A.diagPtr_)
{
diag() += A.diag();
}
if (symmetric() && A.symmetric())
{
upper() += A.upper();
}
else if (symmetric() && A.asymmetric())
{
if (upperPtr_)
{
lower();
}
else
{
upper();
}
upper() += A.upper();
lower() += A.lower();
}
else if (asymmetric() && A.symmetric())
{
if (A.upperPtr_)
{
lower() += A.upper();
upper() += A.upper();
}
else
{
lower() += A.lower();
upper() += A.lower();
}
}
else if (asymmetric() && A.asymmetric())
{
lower() += A.lower();
upper() += A.upper();
}
else if (diagonal())
{
if (A.upperPtr_)
{
upper() = A.upper();
}
if (A.lowerPtr_)
{
lower() = A.lower();
}
}
else if (A.diagonal())
{
}
else
{
if (debug > 1)
{
WarningIn("lduMatrix::operator+=(const lduMatrix& A)")
<< "Unknown matrix type combination"
<< endl;
}
}
}
static void numbergrid(int row, int col, int low_clue, int high_clue)
{
if (row == 2 && low_clue == 1 && !ALLBLOT) return;
{
static unsigned long count = 0;
if (K > 0 && ++count >= K) {
printf("At %d, %d:\n", row, col);
show();
count = 0;
}
}
if (high_clue - low_clue + 1 > squares_remaining(row, col)) {
return;
}
if (col > N) {
numbergrid(row + 1, 1, low_clue, high_clue);
} else {
int srow, scol, snum;
srow = symmetric(row);
scol = symmetric(col);
snum = srow + 1;
if (row > srow) {
NUMBERUP(row, 1, N);
if (low_clue == high_clue + 1) show();
} else if (row == symmetric(row) && col > symmetric(col)) {
/*printf("Numbergrid up:\n"); show();*/
NUMBERUP(row, col, N);
NUMBERUP(snum, 1, col - 2);
if (low_clue == high_clue + 1) show();
} else {
int newhi;
if (across[low_clue]
&& (row != firstrow || col != firstcol)
&& !across[grid[row][col-1]]
&& !down[grid[row-1][col]] /* no 1-letter words */
&& (newhi = high_clue,
blot(srow, scol),
blotted(snum, scol)
? 1 /* not blank; no numbergrid issues */
: blotted(snum, scol - 1)
? across[newhi] && down[newhi] /* OK to number */
? (grid[snum][scol] = newhi--, 1)
: 0 /* must number, but newhi won't work here */
: !across[newhi] && down[newhi] /* OK to number */
? (grid[snum][scol] = newhi--, 1)
: 0 /* must number, but newhi won't work here */
)
&& (MINWORD <= 2 || !shortwords(row, col))
) {
blot(row, col);
numbergrid(row, col + 1, low_clue, newhi);
{
if (!blotted(snum, scol))
blank(snum, scol, BLANK);
}
}
if (row > firstrow || col >= firstcol) {
if ((newhi = high_clue,
blank(srow, scol, BLANK),
blotted(snum, scol)
? 1 /* not blank; no numbergrid issues */
: blotted(snum, scol - 1)
? across[newhi] && !down[newhi] /* OK to number */
? (blank(snum, scol, newhi--), 1)
: 0 /* must number, but newhi won't work here */
: 1 /* no blot to left, therefore no number needed */
)) {
if (numberable(row, col, low_clue)
&& low_clue <= high_clue) {
blank(row, col, low_clue);
numbergrid(row,
col + 1,
low_clue + 1,
newhi);
} else if (!numberable(row, col, ANY)) {
blank(row, col, BLANK);
numbergrid(row,
col + 1,
low_clue,
newhi);
}
{ if (!blotted(snum, scol))
blank(snum,
scol,
BLANK); }
}
}
grid[row][col] = grid[srow][scol] = UNKNOWN;
}
}
}
void Foam::BlockLduMatrix<Type>::segregateB
(
TypeField& sMul,
const TypeField& x
) const
{
typedef typename TypeCoeffField::linearType linearType;
typedef typename TypeCoeffField::squareType squareType;
typedef typename TypeCoeffField::linearTypeField linearTypeField;
typedef typename TypeCoeffField::squareTypeField squareTypeField;
const unallocLabelList& u = lduAddr().upperAddr();
const unallocLabelList& l = lduAddr().lowerAddr();
// Diagonal multiplication
if (thereIsDiag())
{
if (diag().activeType() == blockCoeffBase::SQUARE)
{
const squareTypeField& activeDiag = this->diag().asSquare();
linearTypeField lf(activeDiag.size());
squareTypeField sf(activeDiag.size());
// Expand and contract
contractLinear(lf, activeDiag);
expandLinear(sf, lf);
sMul -= (activeDiag - sf) & x;
}
}
// Lower multiplication
if (thereIsLower())
{
if (lower().activeType() == blockCoeffBase::SQUARE)
{
const squareTypeField& activeLower = this->lower().asSquare();
// Auxiliary variables used in expand/contract
linearType lt;
squareType st;
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
contractLinear(lt, activeLower[coeffI]);
expandLinear(st, lt);
sMul[u[coeffI]] -= (activeLower[coeffI] - st) & x[l[coeffI]];
}
}
}
// Upper multiplication
if (thereIsUpper())
{
if (upper().activeType() == blockCoeffBase::SQUARE)
{
const squareTypeField& activeUpper = this->upper().asSquare();
// Auxiliary variables used in expand/contract
linearType lt;
squareType st;
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
contractLinear(lt, activeUpper[coeffI]);
expandLinear(st, lt);
sMul[l[coeffI]] -= (activeUpper[coeffI] - st) & x[u[coeffI]];
}
// If the matrix is symmetric, the lower triangular product
// is also needed
if (symmetric())
{
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
// Use transpose upper coefficient
contractLinear(lt, activeUpper[coeffI]);
expandLinear(st, lt);
sMul[u[coeffI]] -=
(activeUpper[coeffI].T() - st) & x[l[coeffI]];
}
}
}
}
}
void Foam::lduMatrix::operator-=(const lduMatrix& A)
{
if (A.diagPtr_)
{
diag() -= A.diag();
}
if (symmetric() && A.symmetric())
{
upper() -= A.upper();
}
else if (symmetric() && A.asymmetric())
{
if (upperPtr_)
{
lower();
}
else
{
upper();
}
upper() -= A.upper();
lower() -= A.lower();
}
else if (asymmetric() && A.symmetric())
{
if (A.upperPtr_)
{
lower() -= A.upper();
upper() -= A.upper();
}
else
{
lower() -= A.lower();
upper() -= A.lower();
}
}
else if (asymmetric() && A.asymmetric())
{
lower() -= A.lower();
upper() -= A.upper();
}
else if (diagonal())
{
if (A.upperPtr_)
{
upper() = -A.upper();
}
if (A.lowerPtr_)
{
lower() = -A.lower();
}
}
else if (A.diagonal())
{
}
else
{
FatalErrorIn("lduMatrix::operator-=(const lduMatrix& A)")
<< "Unknown matrix type combination"
<< abort(FatalError);
}
}
bool symmetric(TreeNode* l, TreeNode* r) {
if(!l && !r) return true;
if(!l || !r) return false;
return l->val == r->val && symmetric(l->left, r->right) && symmetric(l->right, r->left);
}
scoreAndLoc Board_AB::alphabeta(bool maximize, char alpha, char beta,
num depth, num x){
recursionCount++;
char score = -10;
num loc = 0;
char alphaOrig = alpha;
if (retrieveSmart(score, loc, alpha, beta)){ return scoreAndLoc(score,loc); }
if (depth >= 2*k-1){
if (memberOfAP(x)){
char sign = (maximize?1:-1);
char result = sign * ((!maximize)?R_WIN:B_WIN);
return scoreAndLoc(result, x);
}
if (depth == n) { return draw; }
}
/*
num& killer1 = killers[depth].first;
if (killer1 != n && alphabeta_helper(killer1, maximize, depth, score,
loc, alpha, beta)){
return scoreAndLoc(score,loc);
}
num killer2 = killers[depth].second;
if (killer2 != n && alphabeta_helper(killer2, maximize, depth, score,
loc, alpha, beta)){
return scoreAndLoc(score,loc);
}
*/
//symmetry -> don't bother checking rhs
bool s = symmetric();
bool firstChild = true;
for(int i = ((n%2)?(n/2):((n/2) - 1)); i > -1; i--){
if (//i != killer1 && i != killer2 &&
alphabeta_helper(i, maximize, depth, score, loc, alpha, beta,firstChild))
{
//killers[depth].second = killer1;
//killer1 = i;
break;
}
if (s) {continue;}
int j = n-i-1;
if (//j != killer1 && j != killer2 &&
alphabeta_helper(j, maximize, depth, score, loc, alpha, beta,firstChild))
{
//killers[depth].second = killer1;
//killer1 = i;
break;
}
}
storeSmart(score, loc, alphaOrig, beta);
if (depth == 0) {
cout << "States hit: " << recursionCount << endl;
cout << "Table size: " << tableSize << endl;
}
return scoreAndLoc(score, loc);
}
Foam::tmp<Foam::Field<Type> >
Foam::BlockLduMatrix<Type>::decoupledH(const Field<Type>& x) const
{
typedef typename TypeCoeffField::scalarTypeField scalarTypeField;
typedef typename TypeCoeffField::linearTypeField linearTypeField;
// Create result
tmp<Field<Type> > tresult
(
new Field<Type>(lduAddr().size(), pTraits<Type>::zero)
);
Field<Type>& result = tresult();
const unallocLabelList& u = lduAddr().upperAddr();
const unallocLabelList& l = lduAddr().lowerAddr();
const TypeCoeffField& Upper = this->upper();
// Create multiplication function object
typename BlockCoeff<Type>::multiply mult;
// Lower multiplication
if (symmetric())
{
if (Upper.activeType() == blockCoeffBase::SCALAR)
{
const scalarTypeField& activeUpper = Upper.asScalar();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
result[u[coeffI]] -= mult(activeUpper[coeffI], x[l[coeffI]]);
}
}
else if (Upper.activeType() == blockCoeffBase::LINEAR)
{
const linearTypeField& activeUpper = Upper.asLinear();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
result[u[coeffI]] -= mult(activeUpper[coeffI], x[l[coeffI]]);
}
}
}
else // Asymmetric matrix
{
const TypeCoeffField& Lower = this->lower();
if (Lower.activeType() == blockCoeffBase::SCALAR)
{
const scalarTypeField& activeLower = Lower.asScalar();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
result[u[coeffI]] -= mult(activeLower[coeffI], x[l[coeffI]]);
}
}
else if (Lower.activeType() == blockCoeffBase::LINEAR)
{
const linearTypeField& activeLower = Lower.asLinear();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
result[u[coeffI]] -= mult(activeLower[coeffI], x[l[coeffI]]);
}
}
}
// Upper multiplication
if (Upper.activeType() == blockCoeffBase::SCALAR)
{
const scalarTypeField& activeUpper = Upper.asScalar();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
result[l[coeffI]] -= mult(activeUpper[coeffI], x[u[coeffI]]);
}
}
else if (Upper.activeType() == blockCoeffBase::LINEAR)
{
const linearTypeField& activeUpper = Upper.asLinear();
for (register label coeffI = 0; coeffI < u.size(); coeffI++)
{
result[l[coeffI]] -= mult(activeUpper[coeffI], x[u[coeffI]]);
}
}
return tresult;
}
