计算混合积分的一个中间函数gαβ

本文介绍了使用Slater型轨道计算两中心Coulomb、混合和一电子积分的方法。作者提供了数学公式并实现了一个Java程序,通过gαβq方法验证了La和Lb小于等于2的所有情况,与文献数值相符。程序中包含了阶乘计算、F函数及gαβ函数的实现,并展示了一些特定参数组合的计算示例。

Analytical evaluation  of  two-centre Coulomb, hybrid and one-electron integrals for Slater-type orbitals

I. I.  GUSEINOV

Mathematical Institute, University of Oxford

MS.  received  9th  February  1970

在这篇文中给出了计算混合积分的方法,其中有一个中间函数gαβ,这个函数的表达式为

其中函数F的表达式为

其中第三项累加项,

不计算负数的阶乘,因此

这4项为负时,不计入累加。

因为i为奇数时,会出现开负数的平方根,因此当i奇数时不计入累加。

用如上表达式地编写了

gαβq( int La, int Lb, int λ, int α,int β  ,int q );

方法,用这个方法验算当La,Lb小于等于2的所有情况与文中数值一致

如计算

double d1=gαβq( 2, 2, 2,   2, 2, 4 );  //0.9375

java代码为

package greenwood;

import java.io.DataInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;

public class gαβP {
 
 
				
				public static  double FACT( double n ) throws IOException, ParseException {
					
					
					double prodt=1.0;
					for(int a=1 ;a<n+1 ;a++)
					{
						prodt=prodt*a;
					}
					
					if(n<0){
						   System.out.println( prodt+   "  负数阶乘 "  );

					   }
					  
					
					return prodt;
					
				}
				

				
				//38a
				public static  double FmNN( int m ,int N, int N1    ) throws IOException, ParseException, InterruptedException {
					
					 //System.out.println(  m+"  "+N+"  "+N1+ " **** m N N1"  );
					
					double d=0.0;
					double d1=0.0;
					double d2=0.0;
					 
					double f1=0;
					 
					for(int k=0 ;k<N1+1;k++){
					
						 
						if(k<0||m-k<0||N1-k<0 || N-m+k<0 ){
							d2=0;
						}
						
						if(k>=0&&m-k>=0&&N1-k>=0 && N-m+k>=0 ){
							d=Math.pow( -1, k );
							d1=FACT(k)*FACT(m-k)*FACT(N1-k)*FACT(N-m+k);
							d2=d/d1;
						}
					
						f1=f1+d2;
						
						//System.out.println(k+"  "+  (m-k)+"  "+(N1-k)+"  "+(N-m+k)+" ** FmNN  "+d1+"  "+d2 +"  "+f1 );
						
					}
					
					double d3=FACT(N)*FACT(N1)*f1;
					
					//System.out.println(  d3+"  "+f1+" ** d3 FmNN "  );
							
					
					return d3;
				}
			      
				
			
				
				//10a
				public static  double gαβ( int La, int Lb, int λ, int α ,int β   ) throws IOException, ParseException, InterruptedException {
					
					 double f9=0;
			
					double d1=1/Math.pow(2, La+Lb+1);
					double f1=(2*La+1)*FACT(La-λ)*(2*Lb+1)*FACT(Lb-λ);
					double f2=FACT(La+λ)*FACT(Lb+λ);
					double d2=Math.pow(f1/f2, 0.5);
					
					double f3=Math.pow(-1, 0.5*((La-α)+(Lb-β)-2*λ) )*FACT(Lb+β);
					
					
					double f4=FACT(0.5*(Lb-β))*FACT(0.5*(Lb+β))*FACT( β-λ );
					double d3=f3/f4;
					
					//System.out.println( α+"  "+λ+ "  *** * " );
					
					//System.out.println(  f3+"  "+f4+"    f34 *** "+Math.pow(-1, 0.5*((La-α)+(La-β)-2*λ) ));
					
					double f5=0;
					double f6=0;
					 
					double d4=0;
					
					 
					 for(int i=0 ; i<2*λ+1;i++){
						 double f7=0;
						 
						 double p1=La+α+2*λ-i;
						 double p2=0.5*(La-α)-λ+i/2;
						 double p3=0.5*(La+α)+λ-i/2;
						 double p4=α+λ-i;
						
						// System.out.println(i+"  "+  f7+ "  i *** *** "+p1+"  "+p2+"  "+p3+"  "+p4);
						
						 if(p1>=0&&p2>=0&&p3>=0&&p4>=0&&i%2==0){
							// System.out.println(  f7+ "  xx*** *** "+p1+"  "+p2+"  "+p3+"  "+p4);
							 
						f5=Math.pow(-1, 0.5*i )*FACT(La+α+2*λ-i)*FmNN( i,λ, λ   );
						f6=FACT(0.5*(La-α)-λ+i/2)*FACT(0.5*(La+α)+λ-i/2)*FACT( α+λ-i);
						
						f7=f5/f6;
						 }
						
						d4=d4+f7;
				 
						//System.out.println(i+" "+ d4+"  "+f7+ "  d4 f7 *** *** " +(La+α+2*λ-i)+"  "+(0.5*(La-α)-λ+i/2)+ "  "+(0.5*(La+α)+λ-i/2)+"  "+ ( α+λ-i));
						//System.out.println(  f5+"  "+f6+"  "+d4+" *** f5" );
					}
					
					 f9=d1*d2*d3*d4;
					 
					  //System.out.println(  d1+"  "+d2+"  "+d3+" *** "+d4  );

					// System.out.println(  f9+" ** f9 gαβ0 "  );
					
					return f9;
				}
				
				//10
				public static  double gαβq( int La, int Lb, int λ, int α,int β  ,int q ) throws IOException, ParseException, InterruptedException {
					
					double f1=0;
					
					double d1=gαβ(  La,  Lb , λ, α, β  );
					
					
				 	double d2=FmNN( q, α+λ, β-λ    );
					
					
					   f1=d1*d2;
					
					System.out.println( f1+"  "+ d1+" "+d2+" ** gαβq "  );
					
					return f1;
				}
					
			   
			
				
				public static  void so(    ) throws IOException, ParseException, InterruptedException {
				
					
					//gαβq( int La, int Lb, int λ, int α,int β  ,int q )
					//double d1=gαβq( 0, 0  , 0 ,0, 0  , 0 ); //0.5
					//double d1=gαβq( 0, 1, 0,   0, 1, 0 ); //0.8660254037844386
					//double d1=gαβq( 0, 2, 0,   0, 0, 0 );  //-0.5590169943749475
					//double d1=gαβq( 0, 2, 0,   0, 2, 0 );  //1.6770509831248424 
					//double d1=gαβq( 0, 2, 0,   0, 2, 1 );  //-3.3541019662496847
					//double d1=gαβq( 0, 2, 0,   0, 2, 2 );  //1.6770509831248424 
					//double d1=gαβq( 0, 3, 0,   0, 1, 0 );  //-1.984313483298443 
					//double d1=gαβq( 0, 3, 0,   0, 1, 1 );  //1.984313483298443
					//double d1=gαβq( 0, 3, 0,   0, 3, 0 );  //3.307189138830738
					//double d1=gαβq( 0, 3, 0,   0, 3, 1 );  //-9.921567416492215
					//double d1=gαβq( 0, 3, 0,   0, 3, 2 );  //9.921567416492215
					//double d1=gαβq( 0, 3, 0,   0, 3, 3 );  //-3.307189138830738
					//double d1=gαβq( 1, 1, 0,   1, 1, 0 );  //1.5
					//double d1=gαβq( 1, 1, 0,   1, 1, 2 );  //-1.5
					//double d1=gαβq( 1, 1, 1,   -1, 1, 0 );  //0.75
					//double d1=gαβq( 1, 1, 1,   1, 1, 0 );  //-0.75 
					//double d1=gαβq( 1, 1, 1,   1, 1, 1 );  //-1.5
					//double d1=gαβq( 1, 1, 1,   1, 1, 2 );  //-0.75 
					//double d1=gαβq( 1, 2, 0,   1, 0, 0 );  //-0.9682458365518543
					//double d1=gαβq( 1, 2, 0,   1, 0, 1 );  //-0.9682458365518543
					//double d1=gαβq( 1, 2, 0,   1, 2, 0 );  //2.904737509655563 
					//double d1=gαβq( 1, 2, 0,   1, 2, 1 );  //-2.904737509655563
					//double d1=gαβq( 1, 2, 0,   1, 2, 2 );  //-2.904737509655563
					//double d1=gαβq( 1, 2, 0,   1, 2, 3 );  //2.904737509655563
					//double d1=gαβq( 1, 2, 1,   -1, 2, 0 );  //1.6770509831248424
					//double d1=gαβq( 1, 2, 1,   -1, 2, 1 );  //-1.6770509831248424 
					//double d1=gαβq( 1, 2, 1,   1, 2, 0 );  //-1.6770509831248424
					//double d1=gαβq( 1, 2, 1,   1, 2, 1 );  //-1.6770509831248424
					//double d1=gαβq( 1, 2, 1,   1, 2, 2 );  //1.6770509831248424 
					//double d1=gαβq( 1, 2, 1,   1, 2, 3 );  //1.6770509831248424
					//double d1=gαβq( 1, 3, 0,   1, 1, 0 );  //-3.43693177121688
					//double d1=gαβq( 1, 3, 0,   1, 1, 2 );  //3.43693177121688 
					//double d1=gαβq( 1, 3, 0,   1, 3, 0 );  //5.7282196186948
					//double d1=gαβq( 1, 3, 0,   1, 3, 1 );  //-11.4564392373896
					//double d1=gαβq( 1, 3, 0,   1, 3, 3 );  //11.4564392373896 
					//double d1=gαβq( 1, 3, 0,   1, 3, 4 );  //-5.7282196186948
					//double d1=gαβq( 1, 3, 1,   -1, 1, 0 );  //-0.701560760020114 
					//double d1=gαβq( 1, 3, 1,   -1, 3, 0 );  //3.50780380010057
					//double d1=gαβq( 1, 3, 1,   -1, 3, 1 );  //-7.01560760020114
					//double d1=gαβq( 1, 3, 1,   -1, 3, 2 );  //3.50780380010057
					//double d1=gαβq( 1, 3, 1,   1, 1, 0 );  //0.701560760020114
					//double d1=gαβq( 1, 3, 1,   1, 1, 1 );  //1.403121520040228
					//double d1=gαβq( 1, 3, 1,   1, 1, 2 );  //0.701560760020114
					//double d1=gαβq( 1, 3, 1,   1, 3, 0 );  //-3.50780380010057
					//double d1=gαβq( 1, 3, 1,   1, 3, 2 );   //7.01560760020114
					//double d1=gαβq( 1, 3, 1,   1, 3, 4 );  //-3.50780380010057 
					//double d1=gαβq( 2, 2, 0,   0, 0, 0 );  //0.625
					//double d1=gαβq( 2, 2, 0,   2, 0, 0 );  //-1.875
					//double d1=gαβq( 2, 2, 0,   2, 0, 1 );  //-3.75
					//double d1=gαβq( 2, 2, 0,   2, 0, 2 );  //-1.875
					//double d1=gαβq( 2, 2, 0,   2, 2, 0 );  //5.625
					//double d1=gαβq( 2, 2, 0,   2, 2, 2 );  //-11.25
					//double d1=gαβq( 2, 2, 0,   2, 2, 4 );  //5.625
					//double d1=gαβq( 2, 2, 1,   0, 2, 0 );  //3.75 
					//double d1=gαβq( 2, 2, 1,   0, 2, 2 );  //-3.75
					//double d1=gαβq( 2, 2, 1,   2, 2, 0 );   //-3.75 
					//double d1=gαβq( 2, 2, 1,   2, 2, 1 );  //-7.5 
					//double d1=gαβq( 2, 2, 1,   2, 2, 3 );  //7.5
					//double d1=gαβq( 2, 2, 1,   2, 2, 4 );  //3.75
					//double d1=gαβq( 2, 2, 2,   -2, 2, 0 );  //0.9375 
					//double d1=gαβq( 2, 2, 2,   0, 2, 0 );  //-1.875
					//double d1=gαβq( 2, 2, 2,   0, 2, 1 );  //-3.75
					//double d1=gαβq( 2, 2, 2,   0, 2, 2 );  //-1.875 
					//double d1=gαβq( 2, 2, 2,   2, 2, 0 );  //0.9375
					//double d1=gαβq( 2, 2, 2,   2, 2, 1 );  //3.75 
					//double d1=gαβq( 2, 2, 2,   2, 2, 2 );   //5.625
					//double d1=gαβq( 2, 2, 2,   2, 2, 3 );  //3.75
					double d1=gαβq( 2, 2, 2,   2, 2, 4 );  //0.9375
					
					
					System.out.println( d1+ "       *** d "  );
					
				}
				 public static void main(String[] args) throws IOException, ParseException, InterruptedException {
					  
					   so(    );
				
					 
			    		}

			}

 

下载方式:https://pan.quark.cn/s/a4b39357ea24 布线问题(分支限界算法)是计算机科学和电子工程领域中一个广为人知的议题,它主要探讨如何在印刷电路板上定位两个节点间最短的连接路径。 在这一议题中,电路板被构建为一个包含 n×m 个方格的矩阵,每个方格能够被界定为可通行或不可通行,其核心任务是定位从初始点到最终点的最短路径。 分支限界算法是处理布线问题的一种常用策略。 该算法与回溯法有相似之处,但存在差异,分支限界法仅需获取满足约束条件的一个最优路径,并按照广度优先或最小成本优先的原则来探索解空间树。 树 T 被构建为子集树或排列树,在探索过程中,每个节点仅被赋予一次成为扩展节点的机会,且会一次性生成其全部子节点。 针对布线问题的解决,队列式分支限界法可以被采用。 从起始位置 a 出发,将其设定为首个扩展节点,并将与该扩展节点相邻且可通行的方格加入至活跃节点队列中,将这些方格标记为 1,即从起始方格 a 到这些方格的距离为 1。 随后,从活跃节点队列中提取队首节点作为下一个扩展节点,并将与当前扩展节点相邻且未标记的方格标记为 2,随后将这些方格存入活跃节点队列。 这一过程将持续进行,直至算法探测到目标方格 b 或活跃节点队列为空。 在实现上述算法时,必须定义一个类 Position 来表征电路板上方格的位置,其成员 row 和 col 分别指示方格所在的行和列。 在方格位置上,布线能够沿右、下、左、上四个方向展开。 这四个方向的移动分别被记为 0、1、2、3。 下述表格中,offset[i].row 和 offset[i].col(i=0,1,2,3)分别提供了沿这四个方向前进 1 步相对于当前方格的相对位移。 在 Java 编程语言中,可以使用二维数组...
源码来自:https://pan.quark.cn/s/a4b39357ea24 在VC++开发过程中,对话框(CDialog)作为典型的用户界面组件,承担着与用户进行信息交互的重要角色。 在VS2008SP1的开发环境中,常常需要满足为对话框配置个性化背景图片的需求,以此来优化用户的操作体验。 本案例将系统性地阐述在CDialog框架下如何达成这一功能。 首先,需要在资源设计工具中构建一个新的对话框资源。 具体操作是在Visual Studio平台中,进入资源视图(Resource View)界面,定位到对话框(Dialog)分支,通过右键选择“插入对话框”(Insert Dialog)选项。 完成对话框内控件的布局设计后,对对话框资源进行保存。 随后,将着手进行背景图片的载入工作。 通常有两种主要的技术路径:1. **运用位图控件(CStatic)**:在对话框界面中嵌入一个CStatic控件,并将其属性设置为BST_OWNERDRAW,从而具备自主控制绘制过程的权限。 在对话框的类定义中,需要重写OnPaint()函数,负责调用图片资源并借助CDC对象将其渲染到对话框表面。 此外,必须合理处理WM_CTLCOLORSTATIC消息,确保背景图片的展示不会受到其他界面元素的干扰。 ```cppvoid CMyDialog::OnPaint(){ CPaintDC dc(this); // 生成设备上下文对象 CBitmap bitmap; bitmap.LoadBitmap(IDC_BITMAP_BACKGROUND); // 获取背景图片资源 CDC memDC; memDC.CreateCompatibleDC(&dc); CBitmap* pOldBitmap = m...
混合函数通常是指通过组合多个基本核函数来构建一个新的核函数。这种技术能够使模型适应更复杂的模式,同时保留各个基础核函数的优点。以下是常见的用于构成混合函数的基本核函数及其特点: ### 常见的基础核函数 #### 1. 线性核函数 (Linear Kernel) 线性核是最简单的核函数之一,适用于特征空间本身已经具有良好的可分性的场景[^1]。其形式如下: ```python K(x, y) = x · y.T ``` #### 2. 多项式核函数 (Polynomial Kernel) 多项式核函数允许捕捉更高维度的空间关系,适合于非线性分类问题。它的定义为: ```python K(x, y) = (γ * x · y.T + c₀)^d ``` 其中 `γ` 是系数,`c₀` 是常数偏移量,`d` 表示多项式的阶数。 #### 3. 高斯径向基核函数 (RBF Kernel / Gaussian Radial Basis Function) 高斯核函数是一种广泛使用的非线性核函数,在处理复杂数据分布时表现出色。它基于欧几里得距离计算相似度,表达式为: ```python K(x, y) = exp(-γ ||x - y||²) ``` 这里 `γ` 控制着决策边界的平滑程度。 #### 4. Sigmoid 核函数 Sigmoid 核类似于神经网络中的激活函数,尽管在实际应用中不如前几种常见。公式表示为: ```python K(x, y) = tanh(γ * x · y.T + c₀) ``` 除了上述标准核外,还有一些特定领域内的专用核也可以参与混合同构,比如字符串匹配任务下的 **字符串核** 或图像分析里的 **直方图交集核** 和 **卡方核** 等[^2]。 ### 构建混合核的方法 混合核可以通过加权求和或者乘积的方式实现。例如两个核 K₁ 和 K₂ 的简单叠加写成: \[ K_{mix}(x,y)=α*K_1(x,y)+β*K_2(x,y)\] 或者是它们的乘法组合: \[ K_{prod}(x,y)=K_1(x,y)*K_2(x,y).\] 当面对大规模多模态数据集合时,合理设计并优化这些权重参数 α β 就显得尤为重要了[^3]。 ### 总结 综上所述,混合函数可以由多种类型的单个核函数组成,包括但不限于线性核、多项式核、RBF核以及sigmoid核等功能模块;甚至还可以引入针对特殊应用场景定制化的高级版本如字符序列对比用到的StringKernel等等。最终的选择取决于目标系统的特性需求与实验验证效果之间的平衡考量。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黑榆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值