有时数据需要比向量更复杂的存储方式。幸运的是，R软件提供了很多的数据结构。常见的有数据框（data.frame）、矩阵（matrix）、列表（list）以及数组（array）。数据框类似于电子表格，矩阵类似于人们熟悉的矩阵数学计算，列表对于程序员比较熟悉。
2024年09月09日
有时数据需要比向量更复杂的存储方式。幸运的是，R软件提供了很多的数据结构。常见的有数据框（data.frame）、矩阵（matrix）、列表（list）以及数组（array）。数据框类似于电子表格，矩阵类似于人们熟悉的矩阵数学计算，列表对于程序员比较熟悉。
2024年09月09日
R语言的数据对象中，列表可以说是最为复杂的一项，列表可以包含不同类型的元素，包括数字、字符串、向量，甚至是另一个列表，使用list()创建。
object1、object2等可为任何数据类型的对象
name1、name2是为列表中的对象进行命名
代码1：
根据列表对象的命名方式，将列表的创建分为两种，上面代码中在建立列表时直接对对象进行了命名，而未被命名的c和d的名称则会被自动命名为[[3]]、[[4]]
2024年09月09日
R语言中的数据类型（Data Types）
R语言的对象（Objects）主要包括向量、矩阵、数组、数据框和列表。
R语言的对象有五种最基本的类型，即，字符型（character）、数值型（numeric，包括小数）、整型（integer）、复数型（complex）以及逻辑型（logical，TRUE/FALSE）
属性是R语言对象的一部分。主要包括以下几种：名字（names，dimnames），维度（dimensions，包括矩阵等），类别（class，包括数字、整数等），长度（length），以及其他。可通过 attributes()函数查看对象的属性，不是所有对象都有属性，如果没有则返回NULL。
2024年09月09日
R语言中的列表与R语言中的向量、数组和矩阵不同，它的每个分量的数据类型可以是不同的。列表是对象的集合，可以包含向量、矩阵、数组，数据框，甚至是另外一个列表，且在列表中要求每一个成分都要有一个名称。列表中的对象又称为它的分量（components）。
在R语言中可以使用list()函数来创建列表，其语法格式为：
list(name1=object1, name2 = object2,...)
下面是创建一个列表的例子：
2024年09月09日
from numpy import *
import numpy.matlib as mtl
import matplotlib.pyplot as plt
import matplotlib
from matplotlib import cm
### lattice and orbit
# s py pz px dxy dyz dz2 dxz d(x2-y2)
# 0 1 2 3 4 5 6 7 8
lat = [[1,0],[-1/2, sqrt(3)/2]]
lat=array(lat)
o1 = [2/3,1/3, 5]
o2 = [2/3,1/3, 7]
o3 = [1/3,2/3, 5]
o4 = [1/3,2/3, 7]
dd_sigma = 0
dd_pi = 0.4096
dd_delta = 0.0259
#orb = [o1,o2,o3,o4]
#orb = [array(i) for i in orb]
num = 4
#r=o2(x,y) - o1(0,0)
def vector(o1,o2,x,y):
r = (o2[0:2]+array([x,y])-o1[0:2]).dot(lat)
l = r[0]/sqrt(r[0]**2+r[1]**2)
m = r[1]/sqrt(r[0]**2+r[1]**2)
return r,l, m
# s py pz px dxy dyz dz2 dxz d(x2-y2)
# 0 1 2 3 4 5 6 7 8
def sk(l,m,d1,d2,dd_sigma,dd_pi,dd_delta):
sk = zeros((9,9))
sk[4,4] = 3*l**2 *m**2 * dd_sigma + (l**2 + m**2 - 4 * l**2 * m**2) * dd_pi + l**2 * m**2 * dd_delta
sk[4,5] = 0
sk[4,6] = -0.5*sqrt(3)*l*m*(l**2+m**2)*dd_sigma + 0.5*l*m*dd_delta
sk[4,7] = 0
sk[4,8] = 3/2 * l * m *(l**2-m**2) * dd_sigma + 2*l*m*(m**2-l**2) * dd_pi + 0.5*l*m*(l**2-m**2)*dd_delta
sk[5,4] = 0
sk[5,5] = m**2*dd_pi+ l**2*dd_delta
sk[5,6] = 0
sk[5,7] = l*m*dd_pi -l*m*dd_delta
sk[5,8] = 0
sk[6,4] = sk[4,6]
sk[6,5] = 0
sk[6,6] = 1/4 * (l**2+m**2)**2 * dd_sigma + 3/4 * (l**2+m**2)**2 * dd_delta
sk[6,7] = 0
sk[6,8] = sqrt(3)/4 * (l**2-m**2) * dd_delta - sqrt(3)/4 * (l**2-m**2) * (l**2+m**2) * dd_sigma
sk[7,4] = 0
sk[7,5] = sk[5,7]
sk[7,6] = 0
sk[7,7] = l**2 * dd_pi + m**2 * dd_delta
sk[7,8] = 0
sk[8,4] = sk[4,8]
sk[8,5] = 0
sk[8,6] = sk[6,8]
sk[8,7] = sk[7,8]
sk[8,8] = 3/4 * (l**2-m**2) * dd_sigma + (l**2 + m**2 - (l**2-m**2)**2) * dd_pi + \
1/4 * (l**2-m**2)**2 * dd_delta
return sk[d1,d2]
def hop_vec(o1,o2,x,y):
r,l,m =vector(o1,o2,x,y)
d1,d2 = o1[2],o2[2]
t=sk(l,m,d1,d2,dd_sigma,dd_pi,dd_delta)
return t,r
t131,r131 = hop_vec(o1,o3,0,0)
t141,r141 = hop_vec(o1,o4,0,0)
t132,r132 = hop_vec(o1,o3,1,0)
t142,r142 = hop_vec(o1,o4,1,0)
t133,r133 = hop_vec(o1,o3,0,-1)
t143,r143 = hop_vec(o1,o4,0,-1)
t231,r231 = hop_vec(o2,o3,0,0)
t241,r241 = hop_vec(o2,o4,0,0)
t232,r232 = hop_vec(o2,o3,1,0)
t242,r242 = hop_vec(o2,o4,1,0)
t233,r233 = hop_vec(o2,o3,0,-1)
t243,r243 = hop_vec(o2,o4,0,-1)
def H(K):
H=zeros((num,num),dtype=complex)
H[0,2] = t131 * exp(1.j*K.dot(r131)) + t132 * exp(1.j*K.dot(r132)) + t133 * exp(1.j*K.dot(r133))
H[0,3] = t141 * exp(1.j*K.dot(r141)) + t142 * exp(1.j*K.dot(r142)) + t143 * exp(1.j*K.dot(r143))
H[1,2] = t231 * exp(1.j*K.dot(r231)) + t232 * exp(1.j*K.dot(r232)) + t233 * exp(1.j*K.dot(r233))
H[1,3] = t241 * exp(1.j*K.dot(r241)) + t242 * exp(1.j*K.dot(r242)) + t243 * exp(1.j*K.dot(r243))
for i in range(num):
for j in range(num):
if j > i:
H[j,i] = conj(H[i,j])
return H
def eH(K):
return linalg.eigh(H(K))[0]
#reciprocal lattice
b1=array([1,1/sqrt(3)])*pi*2
b2=array([0,2/sqrt(3)])*pi*2
#高对称点
G=array([0,0])
M=0.5*b1
K= 1/3 * b1 + 1/3 * b2
#K点路径G-M
kgm = linspace(G,M,100,endpoint=False)
kmk = linspace(M,K,100,endpoint=False)
kkg = linspace(K,G,100)
##K点相对距离
def Dist(r1,r2):
return linalg.norm(r1-r2)
lgm=Dist(G,M)
lmk=Dist(M,K)
lkg=Dist(K,G)
lk = linspace(0,1,100)
xgm = lgm * lk
xmk = lmk * lk + xgm[-1]
xkg = lkg * lk + xmk[-1]
kpath = concatenate((xgm,xmk,xkg),axis=0)
Node = [0,xgm[-1],xmk[-1],xkg[-1]]
Eig_gm = array(list(map(eH,kgm)))
Eig_mk = array(list(map(eH,kmk)))
Eig_kg = array(list(map(eH,kkg)))
eig_1 = hstack((Eig_gm[:,0],Eig_mk[:,0],Eig_kg[:,0]))
eig_2 = hstack((Eig_gm[:,1],Eig_mk[:,1],Eig_kg[:,1]))
eig_3 = hstack((Eig_gm[:,2],Eig_mk[:,2],Eig_kg[:,2]))
eig_4 = hstack((Eig_gm[:,3],Eig_mk[:,3],Eig_kg[:,3]))
plt.plot(kpath,eig_1)
plt.plot(kpath,eig_2)
plt.plot(kpath,eig_3)
plt.plot(kpath,eig_4)
#plt.plot(kpath,eig_5)
#plt.plot(kpath,eig_6)
plt.xticks(Node,[r'$\Gamma#39;,'M','K',r'$\Gamma#39;])
plt.show()2024年09月09日
2024年09月09日
学过线性代数和深度学习先关的一定知道特征向量和拉普拉斯矩阵，这两者是很多模型的基础，有着很重要的地位，那用python要怎么实现呢？
numpy和scipy两个库中模块中都提供了线性代数的库linalg,scipy更全面些。
特征值和特征向量
import scipy as sc
#返回特征值，按照升序排列，num定义返回的个数
def eignvalues(matrix, num):
return sc.linalg.eigh(matrix, eigvalues(0, num-1))[0]
2024年09月09日
前面说到，使用python构建了自动生成Slater-Koster系数以及连接矢的代码，这一节在此基础上，构建一个六角晶格的TB模型，可以跟前文提到的两个案例和对比。这个体系是量子反常霍尔效应，