golangsqrt的簡單介紹

本文目錄一覽：

• 1、正則表達式查找特定函數類型的函數(C語言)
• 2、coldblocks如何使用sqrt
• 3、蟻群演算法JAVA版

正則表達式查找特定函數類型的函數(C語言)

函數定義double sqrt(x)

double x

{

….

return **

}

函數聲明時，只用double sqrt()

函數調用時，一般是x2=sqrt(x)

函數調用時，一般是x2 = sqrt(x)

函數定義double sqrt (x)

函數定義double sqrt( x )

函數定義double sqrt( x2 )

函數定義double sqrt( _x )

函數定義double sqrt( x_ )

函數定義double sqrt( x_y )

函數定義double sqrt( _x, y )

函數定義double sqrt ( xy )

函數定義double sqrt( xy )

你的函數都有形參的么

egrep -in ‘[[:alpha:]]+[[:space:]]+sqrt[[:space:]]*\([[:space:]]*.*[[:alpha:]]+.*[[:space:]]*\)’

考慮了以上幾種情形，包括製表符，都符合條件，你看還有什麼情形遺漏，可以自行補充一下，共匹配10個結果

coldblocks如何使用sqrt

1

打開Codeblocks軟體。

2

點擊新建按鈕，選擇File…

3

選擇C/C++source，點擊Go。

4

點擊Next。

5

根據自己的需求選擇C或C++，此處以C為例。

6

點擊路徑選擇按鈕並設置文件名，確認後點擊Finish按鈕。

7

接下來進入程序編輯界面，輸入helloworld測試代碼。

8

點擊Build and run按鈕。

9

下面為程序運行結果，展示了運行時間，從而可以判斷自己演算法的複雜度。

蟻群演算法JAVA版

說明：信息素權重，路徑權重和信息素蒸發率對最後的結果影響很大，需要微調。

目前發現2 / 5 / 0.5 能達到稍微讓人滿意的效果。本程序離完美的ACO還差很遠，僅供參考。

本蟻群演算法為AS演算法。

用法：

1.new一個對象

ACOforTSP tsp = new ACPforTSP(tsp數據文件名,迭代次數，螞蟻數量，信息素權重，路徑權重，信息素蒸發率）;

2.用go()方法運行

tsp.go();

ACOforTSP.java

___________________________________________________________________

import java.io.File;

import static java.lang.Math.pow;

import static java.lang.Math.sqrt;

import static java.lang.Math.random;

import java.util.HashMap;

import java.io.FileReader;

import java.io.BufferedReader;

/**

*

* @author dvdface

*/

public class ACOforTSP {

//城市的距離表

private double[][] distance;

//距離的倒數表

private double[][] heuristic;

//啟發信息表

private double[][] pheromone;

//權重

private int alpha, beta;

//迭代的次數

private int iterationTimes;

//螞蟻的數量

private int numbersOfAnt;

//蒸發率

private double rate;

ACOforTSP (String file, int iterationTimes, int numbersOfAnt, int alpha, int beta, double rate) {

//載入文件

this.initializeData(file);

//初始化參數

this.iterationTimes = iterationTimes;

//設置螞蟻數量

this.numbersOfAnt = numbersOfAnt;

//設置權重

this.alpha = alpha;

this.beta = beta;

//設置蒸發率

this.rate = rate;

}

private void initializeData(String filename) {

//定義內部類

class City {

int no;

double x;

double y;

City(int no, double x, double y) {

this.no = no;

this.x = x;

this.y = y;

}

private double getDistance(City city) {

return sqrt(pow((x – city.x), 2) + pow((y – city.y), 2));

}

}

try {

//定義HashMap保存讀取的坐標信息

HashMapInteger, City map = new HashMapInteger, City();

//讀取文件

BufferedReader reader = new BufferedReader(new FileReader(new File(filename)));

for (String str = reader.readLine(); str != null; str = reader.readLine()) {

//將讀到的信息保存入HashMap

if (str.matches(“([0-9]+)(\\s*)([0-9]+)(.?)([0-9]*)(\\s*)([0-9]+)(.?)([0-9]*)”)) {

String[] data = str.split(“(\\s+)”);

City city = new City(Integer.parseInt(data[0]),

Double.parseDouble(data[1]),

Double.parseDouble(data[2]));

map.put(city.no, city);

}

}

//分配距離矩陣存儲空間

distance = new double[map.size() + 1][map.size() + 1];

//分配距離倒數矩陣存儲空間

heuristic = new double[map.size() + 1][map.size() + 1];

//分配信息素矩陣存儲空間

pheromone = new double[map.size() + 1][map.size() + 1];

for (int i = 1; i map.size() + 1; i++) {

for (int j = 1; j map.size() + 1; j++) {

//計算城市間的距離，並存入距離矩陣

distance[i][j] = map.get(i).getDistance(map.get(j));

//計算距離倒數，並存入距離倒數矩陣

heuristic[i][j] = 1 / distance[i][j];

//初始化信息素矩陣

pheromone[i][j] = 1;

}

}

} catch (Exception exception) {

System.out.println(“初始化數據失敗！”);

}

}

class Ant {

//已訪問城市列表

private boolean[] visited;

//訪問順序表

private int[] tour;

//已訪問城市的個數

private int n;

//總的距離

private double total;

Ant() {

//給訪問順序表分配空間

tour = new int[distance.length+1];

//已存入城市數量為n，剛開始為0

n = 0;

//將起始城市1,放入訪問結點順序表第一項

tour[++n] = 1;

//給已訪問城市結點分配空間

visited = new boolean[distance.length];

//第一個城市為出發城市，設置為已訪問

visited[tour[n]] = true;

}

private int chooseCity() {

//用來random的隨機數

double m = 0;

//獲得當前所在的城市號放入j,如果和j相鄰的城市沒有被訪問，那麼加入m

for (int i = 1, j = tour[n]; i pheromone.length; i++) {

if (!visited[i]) {

m += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);

}

}

//保存隨機到的數

double p = m * random();

//尋找被隨機到的城市

double k = 0;

//保存找到的城市

int q = 0;

for (int i = 1, j = tour[n]; k p; i++) {

if (!visited[i]) {

k += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);

q = i;

}

}

return q;

}

private void constructSolution () {

while (n != (distance.length-1) ) {

//選取下一個城市

int p = chooseCity();

//計算總的距離

total += distance[tour[n]][p];

//將選取到的城市放入已訪問列表

tour[++n] = p;

//將選取到的城市標記為已訪問

visited[p] = true;

}

//回到起點

total += distance[tour[1]][tour[n]];

//將起點加入訪問順序表的最後

tour[++n] = tour[1];

}

private void releasePheromone() {

//釋放信息素的大小

double t = 1/total;

//釋放信息素

for (int i=1;itour.length-1;i++) {

pheromone[tour[i]][tour[i+1]] += t;

pheromone[tour[i+1]][tour[i]] += t;

}

}

}

public void go() {

//保存最好的路徑和路徑長度

double bestTotal = Double.MAX_VALUE;

int[] bestTour = new int[distance.length+1];

//新建螞蟻數組，用來引用所創建的螞蟻

Ant[] ant = new Ant[numbersOfAnt];

//進行iterationTimes次迭代

while (iterationTimes != 0) {

//初始化新的一批螞蟻（這裡用構造新的螞蟻代替重置螞蟻狀態）

for (int i=0; inumbersOfAnt; i++) {

ant[i] = new Ant();

}

//進行一次迭代（即讓所有的螞蟻構建一條路徑）

for (int i=0; inumbersOfAnt; i++) {

ant[i].constructSolution();

//如果螞蟻構建的路徑長度比上次最好的還好，那麼保存這個長度和它所走的路徑

if (ant[i].totalbestTotal) {

bestTotal = ant[i].total;

System.arraycopy(ant[i].tour, 1, bestTour, 1, bestTour.length-1);

}

}

//蒸發信息素

evaporatePheromone();

//釋放信息素

for (int i=0; inumbersOfAnt; i++) {

ant[i].releasePheromone();

}

//報告本次迭代的信息

System.out.format(“本次為倒數第%d次迭代,當前最優路徑長度為%10.2f\n”,iterationTimes,bestTotal);

//迭代總數減去1，進行下次迭代

iterationTimes–;

}

//輸出最好的路徑長度

System.out.format(“得到的最優的路徑長度為:%10.2f\n”,bestTotal);

//輸出最好的路徑

System.out.println(“最優路徑如下：”);

for (int i=1; ibestTour.length; i++) {

System.out.print(“→”+bestTour[i]);

}

}

private void evaporatePheromone() {

for (int i = 1; i pheromone.length; i++)

for (int j = 1; j pheromone.length; j++) {

pheromone[i][j] *= 1-rate;

}

}

}