Класс для представления модели графа доходностей

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.sql.Date;

import java.util.ArrayList;

/**

* The performance matrix for the given country and time period.

*/

public class PerformanceMatrix {

private ArrayList<Integer> stocks;

private String country;

private Date startDate;

private Date endDate;

private int[][] C;

private int N;

/**

* Create an initial matrix (with all zeros).

*

* @param country the country

* @param startDate the first date

* @param endDate the last date

* @param stocks the list of stock ID's

*/

public PerformanceMatrix(String country, Date startDate, Date endDate,

ArrayList<Integer> stocks) {

C = new int[stocks.size()][stocks.size()];

this.N = stocks.size();

this.country = country;

this.startDate = startDate;

this.endDate = endDate;

this.stocks = stocks;

}

/**

* Get the country.

*

* @return the country

*/

public String getCountry() {

return country;

}

/**

* Get the first date.

*

* @return the first date

*/

public Date getStartDate() {

return startDate;

}

/**

* Get the last date.

*

* @return the last date

*/

public Date getEndDate() {

return endDate;

}

/**

* Read the matrix from a file.

*

* @param file the file

* @return the matrix

* @throws NumberFormatException if file is invalid

* @throws IOException if an I/O error occurs

*/

public static PerformanceMatrix readFromFile(File file)

throws NumberFormatException, IOException {

BufferedReader br = new BufferedReader(

new InputStreamReader(new FileInputStream(file)));

// Read country

String country = br.readLine();

// Read dates

String[] dates = br.readLine().split(";");

Date startDate = Date.valueOf(dates[0]);

Date endDate = Date.valueOf(dates[1]);



// Read stock list

int N = Integer.parseInt(br.readLine());

ArrayList<Integer> stocks = new ArrayList<Integer>(N);

String[] ids = br.readLine().split(";");

for (int i = 0; i < ids.length; i++)

stocks.add(i, Integer.parseInt(ids[i]));

PerformanceMatrix m = new PerformanceMatrix(country,

startDate, endDate, stocks);

for (int i = 0; i < (N - 1); i++) {

String[] correlations = br.readLine().split(";");

int j = i + 1;

for (String Cij: correlations)

m.set(i, j++, Integer.parseInt(Cij));

}

br.close();

return m;

}

/**

* Write the matrix to a file.

*

* @param file the file

* @throws IOException if an I/O error occurs

*/

public void dumpToFile(File file) throws IOException {

PrintWriter out = new PrintWriter(new FileWriter(file));

out.println(country);

out.println(startDate + ";" + endDate);

out.println(stocks.size());

for (int i = 0; i < stocks.size() - 1; i++)

out.print(stocks.get(i) + ";");

out.println(stocks.get(stocks.size() - 1));

for (int i = 0; i < C.length; i++) {

for (int j = i + 1; j < C[i].length; j++) {

out.print(C[i][j]);

if (j < C[i].length - 1)

out.print(";");

}

out.println();

}

out.close();

}

/**

* Set the performance measure value <i>C(i, j)</i>.

*

* @param i the first stock number

* @param j the second stock number

* @param c the value

*/

public void set(int i, int j, int c) {

C[i][j] = C[j][i] = c;

}



/**

* Increment the performance measure value <i>C(i, j)</i>.

*

* @param i the first stock number

* @param j the second stock number

*/

public void increment(int i, int j) {

C[i][j]++;

C[j][i]++;

}

/**

* Get list of stocks.

*

* @return the list of stocks

*/

public ArrayList<Integer> getStocks() {

return stocks;

}

/**

* Performance distribution.

*

* @return the vector containing distribution values

*/

public double[] distribution() {

double[] distr = new double[53];

for (int i = 0; i < N; i++)

for (int j = i + 1; j < N; j++)

distr[C[i][j]]++;

for (int i = 0; i < 53; i++)

distr[i] *= 2.0 / (N * (N - 1));

return distr;

}

/**

* Mean value.

*

* @return the mean performance value

*/

public double mean() {

double mean = 0;

for (int i = 0; i < N; i++)

for (int j = i + 1; j < N; j++)

mean += C[i][j];

mean *= 2.0 / (N * (N-1));

return mean;

}

/**

* Standard error.

*

* @return the standard error value for performance

*/

public double stderr() {

double mean = mean();

double Var = 0.0;

for (int i = 0; i < N; i++)

for (int j = i + 1; j < N; j++)

Var += (C[i][j] - mean) * (C[i][j] - mean);

Var *= 2.0 / (N * (N-1));

return Math.sqrt(Var);

}

/**

* Create an unweighted graph for given threshold.

*

* @param t the threshold value

* @return the corresponding graph

*/

public Graph graph(int t) {

Graph g = new Graph(N);

for (int i = 0; i < N; i++)

for (int j = i + 1; j < N; j++)

if (C[i][j] >= t)

g.addEdge(i, j);

return g;

}

}



Приложение 5

Программа для построения модели графа доходностей

import java.io.File;

import java.io.IOException;

import java.sql.Date;

import java.sql.SQLException;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.HashMap;

import java.util.Iterator;

import java.util.TreeMap;

/**

* Program to calculate the stock market's performance measure.

*

* The program will split the given time interval in periods of length 52

* weeks using 1-week shifts. For each period the performance matrix is

* calculated. Each matrix is saved in a separate file in the specified

* directory.

*/

public class CalculatePerformance {

private static final int PERIOD_LENGTH = 52;

private static final int PERIOD_SHIFT = 1;

private static File dir;

private static DatabaseSession db;



private static boolean[] calculatePerformance(int stock,

ArrayList<Week> weeks, double[] inflation) throws SQLException {

// Get quotes

Date first = weeks.get(0).getStart();

Date last = weeks.get(weeks.size() - 1).getEnd();

ArrayList<Quote> quotes = db.selectQuotes(stock, first, last);

Iterator<Quote> quoteIterator = quotes.iterator();

if (!quoteIterator.hasNext()) {

System.err.println("No quotes for " + stock + " in " +

first + " - " + last);

//System.exit(1);

return null;

}

// For each week, determine the last close price

double[] prices = new double[weeks.size()];

int currWeek = 0;

while (quoteIterator.hasNext()) {

Quote q = quoteIterator.next();

Date date = q.getDate();

double price = q.getClose();

while (weeks.get(currWeek).getEnd().compareTo(date) < 0)

currWeek++;

prices[currWeek] = price;

}

// For each week, determine profitability

boolean[] profitable = new boolean[weeks.size()];

double lastPrice = 0.0;

for (int i = 0; i < weeks.size(); i++) {

if (prices[i] == 0.0)

continue; // no quotes for this week

if (lastPrice == 0.0) // first time - always profitable

profitable[i] = true;

else {

double R = (prices[i] - lastPrice) * 100.0 / lastPrice;

profitable[i] = R > inflation[i];

}

lastPrice = prices[i];

}

return profitable;

}

private static double[] getWeeklyInflation(String country,

ArrayList<Week> weeks) throws SQLException {

TreeMap<Integer, double[]> dailyInflation =

db.dailyInflation(country);

double[] weeklyInflation = new double[weeks.size()];

for (int i = 0; i < weeks.size(); i++) {

Week w = weeks.get(i);

Calendar start = Calendar.getInstance();

start.setTime(w.getStart());

Calendar end = Calendar.getInstance();

end.setTime(w.getEnd());



while (start.compareTo(end) <= 0) {

weeklyInflation[i] += dailyInflation.get(

start.get(Calendar.YEAR))[start.get(Calendar.MONTH)];

start.add(Calendar.DATE, 1);

}

}

return weeklyInflation;

}

public static void main(String[] args) throws IOException, SQLException {

if (args.length!= 4) {

System.err.println("Usage: java CalculateCorrelations <dir> " +

"<country> <first_date> <last_date>");

System.exit(1);

}

// Open directory

dir = new File(args[0]);

if (!dir.exists()) {

dir.mkdirs();

} else if (!dir.isDirectory()) {

System.err.println("Not a directory: " + args[0]);

System.exit(1);

}

String country = args[1];

// Parse dates

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

Date fromDate = null;

try {

fromDate = new Date(sdf.parse(args[2]).getTime());

} catch (ParseException e) {

System.err.println("Invalid Date: " + args[2]);

System.exit(1);

}

Date toDate = null;

try {

toDate = new Date(sdf.parse(args[3]).getTime());

} catch (ParseException e) {

System.err.println("Invalid Date: " + args[3]);

System.exit(1);

}

db = new DatabaseSession();

// Get all stocks

ArrayList<Integer> stocks = db.selectStocks(country, fromDate,

toDate, 200);

// List all weeks

ArrayList<Week> weeks = Week.listWeeks(fromDate, toDate);

// For each week compute inflation

double[] inflation = getWeeklyInflation(country, weeks);

HashMap<Integer, boolean[]> performance =

new HashMap<Integer, boolean[]>();

for (int i = 0; i < stocks.size(); i++) {

System.out.println("Calculating performance (" + (i + 1) + "/" +

stocks.size() + ")");

performance.put(stocks.get(i), сalculatePerformance(

stocks.get(i), weeks, inflation));

}

// For each period calculate C(i,j)

int count = 0;

int total = (weeks.size() - PERIOD_LENGTH) / PERIOD_SHIFT + 1;

for (int w = 0; w <= (weeks.size()-PERIOD_LENGTH); w += PERIOD_SHIFT)

{

count++;

System.out.println("Generating file (" + count + "/" +

total + ")");

Date firstDate = weeks.get(w).getStart();

Date lastDate = weeks.get(w + PERIOD_LENGTH - 1).getEnd();

ArrayList<Integer> ids = db.selectStocks(country, firstDate,

lastDate, 200);

PerformanceMatrix c = new PerformanceMatrix(country,

firstDate, lastDate, ids);

for (int i = 0; i < ids.size(); i++)

for (int j = i + 1; j < ids.size(); j++)

for (int v = w; v < w + PERIOD_LENGTH; v++)

if (performance.get(ids.get(i))[v] &&

performance.get(ids.get(j))[v])

c.increment(i, j);

// Write the matrix to file

String fileName = dir.getAbsolutePath() + File.separator +

country + "_" + count + ".csv";

c.dumpToFile(new File(fileName));

}

db.close();

}

}

/**

* Class for representing weeks.

*/

class Week {

private final Date start;

private final Date end;

/**

* Create a week object.

*

* @param start the first date

* @param end the end date

*/

public Week(Date start, Date end) {

this.start = start;

this.end = end;

}

/**

* Get the first day of the week.

*

* @return the first day of the week

*/

public Date getStart() {

return start;

}

/**

* Get the last day of the week.

*

* @return the last day of the week

*/

public Date getEnd() {

return end;

}

/**

* Create a list of all weeks in the given time period.

*

* @param from the first date of the period

* @param to the last date of the period

* @return the list of weeks

*/

public static ArrayList<Week> listWeeks(Date from, Date to) {

ArrayList<Week> weeks = new ArrayList<Week>();

Calendar cal = Calendar.getInstance();

cal.setTime(from);

while (cal.getTime().compareTo(to) <= 0) {

Date startDate = new Date(cal.getTime().getTime());

int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);

cal.add(Calendar.DATE, 8 - dayOfWeek);

if (cal.getTime().compareTo(to) > 0)

break;

Date endDate = new Date(cal.getTime().getTime());

cal.add(Calendar.DATE, 1);

weeks.add(new Week(startDate, endDate));

}

return weeks;

}

}



Приложение 6

Класс для представления невзвешенного графа

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.util.LinkedList;

/**

* Class to represent graphs (unweighted).

*

* This implementation uses adjacency lists to represent the graph, which

* may be inefficient for very dense graphs.

*/

public class Graph {

private final int V;

private int E;

private LinkedList<Integer>[] adj;

/**

* Construct a new graph with V vertices.

*

* @param V the number of vertices.

*/

public Graph(int V) {

this.V = V;

this.E = 0;

adj = (LinkedList<Integer>[]) new LinkedList[V];

for (int v = 0; v < V; v++)

adj[v] = new LinkedList<Integer>();

}

/**

* Read graph from file.

*

* @param f the file

* @throws NumberFormatException if the file contains invalid data

* @throws IOException if an I/O error occurs

*/

public Graph(File f) throws NumberFormatException, IOException {

BufferedReader br = new BufferedReader(

new InputStreamReader(new FileInputStream(f)));

String[] h = br.readLine().split(" ");

this.V = Integer.parseInt(h[2]);

adj = (LinkedList<Integer>[]) new LinkedList[V];

for (int v = 0; v < V; v++)

adj[v] = new LinkedList<Integer>();

int E = Integer.parseInt(h[3]);

for (int i = 0; i < E; i++) {

String[] v = br.readLine().split(" ");

addEdge(Integer.parseInt(v[1])-1, Integer.parseInt(v[2])-1);

}

br.close();

}

/**

* Dump this graph to a file (using the format suitable for the MCS

* algorithm).

*

* @param file the file to read from

* @throws IOException if an I/O error occurs

*/

public void dump(File file) throws IOException {

PrintWriter out = new PrintWriter(new FileWriter(file));

out.println("p edge " + V + " " + E);

for (int v = 0; v < V; v++) {

for (int w: adj(v))

if (w > v)

out.println("e " + (v + 1) + " " + (w + 1));

}

out.close();

}

/**

* Number of vertices.

*

* @return the number of vertices

*/

public int V() {

return V;

}



/**

* Number of edges.

*

* @return the number of edges

*/

public int E() {

return E;

}

/**

* Add a new edge between two vertices.

*

* @param v the one vertex

* @param w the other vertex

*/

public void addEdge(int v, int w) {

E++;

adj[v].add(w);

adj[w].add(v);

}

/**

* Get list f vertices adjacent to v.

*

* @param v the vertex

* @return the list of adjacent vertices

*/

public LinkedList<Integer> adj(int v) {

return adj[v];

}

Приложение 7

Программы для расчета характеристик графа

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.PrintStream;

import java.util.LinkedList;

/**

* Compute the clustering coefficient.

*/

class Clustering {

public static double local(Graph g, int v) {

LinkedList<Integer> N = g.adj(v);

if (N.size() < 2)

return 0;

int count = 0;

for (int j: N) {

for (int k: g.adj(j)) {

if (N.contains(k))

count++;

}

}

return (double) count / (N.size() * (N.size() - 1));

}

public static double global(Graph g) {

double c = 0.0;

for (int v = 0; v < g.V(); v++)

c += local(g, v);

c /= g.V();

return c;

}

}

/**

* Calculate the edge density.

*/

class EdgeDensity {

public static double density(Graph g) {

return (double) g.E() * 2.0 / (g.V() * (g.V() - 1));

}

}

/**

* Calculate the degree distributon.

*/

class DegreeDistribution {

public static int[] degreeDistribution(Graph g) {

int[] degree = new int[g.V()];

for (int v = 0; v < g.V(); v++)

degree[g.adj(v).size()]++;

return degree;

}

}

Размещено на Allbest.ru