计算正方形和三角形网格中所选站点的最近邻居

Question

I'm new in programming, and I've been trying to make functions (in C) that compute the nearest neighbours of a site i in a square lattice of NxN sites and, in a triangular lattice.

So far, for the square lattice Square lattice example. We have 4 nearest neighbours is easy, the first four nerest neighbours of a site i can be written as:

• i+1 , for the right neighbour,
• i-1 , for the left neighbour, and so on for the upper and bottom neighbours.

The problem is when I consider a triangular lattice triangular lattice example. We have 6 nearest neighbours . I can't find a similar formula using the label i , for the other sites neigbours than the left and right respectively. Should I include some angles in my formulation?

Note: The site i is chosen at random, next, I have to find its nearest neighbours in each case.

EDIT: The following, is the code corresponding to the neighbours of a square lattice. There, I'm not considering still periodic boundary conditions. This program gives us the nearest four neighbours of a site (introduced by the user)

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define L 5 // The lattice is LxL

int site;

int calculate_neighbours(int i){ //we define a function that calculate the desired neighbours of a site introduced by the user

    /*We define functions for each neigbours*/

    //Right neighbour
    int nr;
    nr=i+1;

/*If the selected site is is the right border of the lattice*/
    for(int k=0;k<L+1;k++){
        if(site==k*L){
            nr=L*(k-1)+1;
        }
    }
    printf("\n right= %d",nr);

//////////////////////////////////////////

//Left neighbour
    int nl;
    nl=i-1;

/*If the selected site is is the left border of the lattice*/
    for(int k=1;k<L+1;k++){
        if(site==(k-1)*L+1){
            nl=L*k;
        }
    }
    printf("\n left= %d",nl);
    //////////////////////////////////

    //Upper neigbour

     int nu;
     nu=i-L;

 /*If the selected site is in the upper border of the lattice*/
     for(int p=L-1;p>-1;p--){
        if(site==L-p){
            nu=L*L-p;
        }
    }
    printf("\n up= %d",nu);

    ////////////////////////////////////////

    //Bottom neighbour

    int nd;
    nd=i+L;

 /*If The chosen site is in the bottom border*/
    for(int p=L-1;p>-1;p--){
        if(site==L*L-p){
            nd=L-p;
        }
    }
    printf("\n down= %d",nd);


/////////////////////////

 /*Main function*/

 int main(void){
    int cont, M[L][L];
     cont=1;

   /*Print the matrix elements in order*/
    while(cont<L){
        printf("The M-matrix is:\n");
         for (int m=0;m<L;m++){
         printf("\n\n");
            for(int n=0;n<L;n++){
                M[m][n]=cont++;
                printf("%5d",M[m][n]);
            }
        }
}

/*Print the nearest neighbours*/
    printf("\n\nTamaño de la red L= %d",L);
    printf("\nNumero de sitios LxL=%d",L*L);
    printf("\n\nintroduzca un sitio= ");
    scanf("%d",&site);

    if(site==0 || site<0){printf("\nDebes introducir un numero        mayor a cero!\n");}
    else  if(site>0 && site<L*L+1){
        calculate_neighbours(site);
        printf("\n");
    }
    else {
        printf("\nExcediste el tamaño de la red\n");
     }


  }

I still don't know how to start applying something similar to a triangular lattice. That is, introducing some angles? I'm a bit confused.

Answer 1

Consider (X,Y) coordinate of square lattice:

//4x4 Square lattice
Y=0 : 0 1 2 3  //0-3 is X value
Y=1 : 0 1 2 3
Y=2 : 0 1 2 3
Y=3 : 0 1 2 3

Then, let's consider this 4x4 data as a Triangle lattice. If you shift the rows with odd Y values to the right by 0.5, the result shape will look like a Triangle lattice. And, to consider the neighborhood problem, introduce another coordinate here (U,V) as:

//4x4 Triangle lattice
V=0 : 0 2 4 6  //U value for Even rows is {0,2,4,6}
V=1 :  1 3 5 7  //U value for Odd rows is {1,3,5,7}
V=2 : 0 2 4 6
V=3 :  1 3 5 7

On this (U,V) cooridnate system, enumerating the 6-neighbors is very easy:

(U+2,V)    //right
(U-2,V)    //left
(U-1,V-1) //up left
(U+1,V-1) //up right
(U-1,V+1) //down left
(U+1,V+1) //down right

All that is left is the coordinate transformation between (X,Y) and (U,V). This is also easy:

//(X,Y) --> (U,V)
inline void XY2UV( int X, int Y, int &U, int &V )
{
    U = X*2 + ( Y%2 );
    V = Y;
}

//(U,V) --> (X,Y)
inline void UV2XY( int U, int V, int &X, int &Y )
{
    X = U / 2;
    Y = V;
}