Wikipedia

Licence

Lorem

Pouziti

Lorem

Kod

Lorem

Stazeni

Lorem

Introduction

Although the Baron Playfair’s name is attached to one of the better-known classical ciphers, the baron’s friend, scientist Charles Wheatstone, actually devised the Playfair cipher. After its creation in 1854, the baron succesfully lobbied the Brittish government to adopt the cipher for official use, and thus got his name, and not Wheatstone’s, attached to the cipher.

The Playfair is a primitive—by modern reckoning—block cipher. Any new personal computer sold today can break a message encoded with it in a matter of seconds. That is, with the proper software, you could use such a computer to discover the original text without knowing the cipher key. Some skilled cryptogrophists and puzzle experts can even break it with nothing more than pen and paper.

Nonetheless, it uses some principles common to modern computer block ciphers. Understanding the Playfair will give you a beginning insight into modern cryptography—without all the complex mathematics and number theory.

Preparatory Information

To encode a message, you start by preparing your message, known as plaintext, in a specific way, and then transform form this prepared plaintext based upon an alphabet square—again, in a specific way. The alphabet square varies with your chosen keyword.

Decryption is essentially the reverse process.

For the purpose of this example, consider the following as the plaintext:

Congress shall make no law respecting an establishment of religion, or prohibiting the free exercise thereof; or abridging the freedom of speech, or of the press; or the right of the people peaceably to assemble, and to petition the government for a redress of grievances.

The words, „First Amendment,“ will be used as the encryption key.

Preparing the Plaintext

The first step is to prepaire the plaintext. To do so, all letters are written uppercase, in pairs, and without punctuation. All Js are replaced with Is. This particular example contains no Js.

CO NG RE SS SH AL LM AK
EN OL AW RE SP EC TI NG
AN ES TA BL IS HM EN TO
FR EL IG IO NO RP RO HI
BI TI NG TH EF RE EE EX
ER CI SE TH ER EO FO RA
BR ID GI NG TH EF RE ED
OM OF SP EE CH OR OF TH
EP RE SS OR TH ER IG HT
OF TH EP EO PL EP EA CE
AB LY TO AS SE MB LE AN
DT OP ET IT IO NT HG OV
ER NM EN TF OR AR ED RE
SS OF GR IE VA NC ES

Next, double letters—if they occur in a pair—must be divided by an X or a Z. For example, freedom in this example becomes FREXEDOM. Because of the triple s between the first and second words, they are written as CONGRESXSZ SHALL. This rule for double letters reduces the number of visible patterns in the ciphertext.

Finally, if there are an odd number of letters, an extra letter chosen by the person writing the cipher is added to the end.

In its ready-to-encrypt form, the plaintext becomes:

CO NG RE SX SZ SH AL LM
MA KE NO LA WR ES PE CT
IN GA NE ST AB LI SH ME
NT OF RE LI GI ON OR PR
OH IB IT IN GT FR EX EZ
EX ER CI SE TH ER EO FO
RA BR RI DG IN GT HE FR
EX ED OM OF SP EX EC HO
RO FT HE PR ES SO RT HE
RI GH TO FT HE PE OP LE
PE AC EA BL YT OA SX SE
MB LE AN DT OP ET IT IO
NT HE GO VE RN ME NT FO
RA RE DR ES SO FG RI EV
AN CE SB

Notice that, for example, the seventh-from-the-end pair of Ss were not replaced with SXS; this is because previous modifications of double letters shifted everything in a way that they are no longer adjacent.

Preparing the Key

The alphabet square is a five-by-five grid. The key phrase is first written without repeating any letters. The remaining letters of the alphabet are filled in in order:

F I R S T
A M E N D
B C G H K
L O P Q U
V W X Y Z

Note the absence of a J, and that the last three leters of the key had already appeared in the previous ten.

The longer your key, the more secure your message will be—but remember that even the most secure Playfair cipher can be broken easily with the proper tools.

Encryption

Next comes the heart of the Playfair cipher: any pair of letters must both be in the same row, in the same column, or in different rows and columns; no other combinations are possible.

Each letter in a pair that is on the same row is replaced by the letter to the right. The letter to the right of the rightmost letter is the first letter in the same row—it „wraps“ around without going to the next line. With this key, FI becomes IR; OQ becomes PU; KB becomes BC, and so on.

Similarly, letters in the same coumn are replace by the next letter below in the same column. IM becomes MC, GX becomes PR.

The hard one: when the letters are neither in the same row nor column, the substitution is based upon their intersection. Of great importance is preserving the order. Start with the first letter, and move across until it is lined up with the second letter; then start with the second, and move up or down until it is lined up with the first. GU becomes KP, *NOT* PK. YM becomes WN. DH becomes NK.

Remember: first move across (left or right), and then up or down.

Finally, perform this transformation for each pair of letters in the modified plaintext and remove the spaces:

OWEHEGRYTYNQBVOAEMGDMQVBXINRXGKI
SMBEDNTFBLOFNQENDSLIEGOFCRQMPIXE
QCFCRFSMKRISGRDXGRGEOMRNSKGEMPIL
FEGFSREKSMKRGNISGRNAWCLIRQGRMGCQ
IPIFGNXENRIQSFGNSRHKIUIFGNXGPQPA
XGMBNMLVZSLMRYRNACPAMDKDPQDRRFMW
DSGNCPXASEENDSILFEEGETNRIQRBSRAX
MDGMFH

The above is the final ciphertext. Were Playfair to be a perfect, unbreakable cipher—which it is not—it would be impossible to recover the original message without knowing the encryption key, „First Amendment.“

Decryption

To decrypt the message, simply reverse the entire process. Break the ciphertext into pairs of letters:

OW EH EG RY TY NQ BV OA
EM GD MQ VB XI NR XG KI
SM BE DN TF BL OF NQ EN
DS LI EG OF CR QM PI XE
QC FC RF SM KR IS GR DX
GR GE OM RN SK GE MP IL
FE GF SR EK SM KR GN IS
GR NA WC LI RQ GR MG CQ
IP IF GN XE NR IQ SF GN
SR HK IU IF GN XG PQ PA
XG MB NM LV ZS LM RY RN
AC PA MD KD PQ DR RF MW
DS GN CP XA SE EN DS IL
FE EG ET NR IQ RB SR AX
MD GM FH

Write down the alphabet square with the key:

F I R S T
A M E N D
B C G H K
L O P Q U
V W X Y Z

Transform the pairs of letters in the opposite direction from that used for encryption:

CO NG RE SX SZ SH AL LM
MA KE NO LA WR ES PE CT
IN GA NE ST AB LI SH ME
NT OF RE LI GI ON OR PR
OH IB IT IN GT FR EX EZ
EX ER CI SE TH ER EO FO
RA BR RI DG IN GT HE FR
EX ED OM OF SP EX EC HO
RO FT HE PR ES SO RT HE
RI GH TO FT HE PE OP LE
PE AC EA BL YT OA SX SE
MB LE AN DT OP ET IT IO
NT HE GO VE RN ME NT FO
RA RE DR ES SO FG RI EV
AN CE SB

This message is now readable, although removing the extra spaces and substitutions for double letters makes it more readable:

CONGRESS   SHALL  MAKE   NO  LAW
RESPECTING  AN ESTABLISHMENT  OF
RELIGION OR PROHIBITING THE FREE
EXERCISE  THEREOF  OR  ABRIDGING
THE FREEDOM OF  SPEECH OR OF THE
PRESS OR THE RIGHT OF THE PEOPLE
PEACEABLY  TO  ASSEMBLE  AND  TO
PETITION  THE  GOVERNMENT FOR  A
REDRESS OF GRIEVANCES

Modern Comparisons

Computer-run block ciphers work in a manner similar to Playfair’s: they break the original message into blocks of characters and apply a complex mathematical transformation, based upon the key, to each of those blocks.

Naturally, modern ciphers are not restriced to upper-case, no-punctuation, J-less messages. Any form of data that can be stored on a computer can be encrypted with a modern cipher.

A modern block cipher can be run in a mode similar to that of Playfair, where the same block (in Playfair, a pair of letters) always encrypts to the same bit of ciphertext: in our example, CO will always come out as OW. Indeed, many poorly-written encryption programs use just this technique, called Electronic Codebook, or ECB.

More sophisticated implementation of a cipher will use one of many other modes. The most common is called Cipher Feedback Mode, or CFB.

CFB starts by encrypting something other than your message, to get things started. This bit at the front of things is called an initialization vector, or IV. The IV need not be secret, but the same IV should never be re-used with the same encryption key.

First, encrypt the IV. Take the IV and combine it with the first block of the plaintext. With computers, this is done with a mathematical function called a binary XOR; a similar effect could be accomplished with Playfair by „adding“ the two together: C + H = K; W + F = B. It is this value which is written to the ciphertext.

Next, take the result from the last step, encrypt it as normally, and add it to the next block from the plaintext. In this way, the encryption of each block depends upon the encryption of each preceeding block.

Encrypt IV -> XOR (add) result with first block of plaintext -> write as ciphertext -> encrypt from previous -> XOR with next block of plaintext -> write as ciphertext -> repeat

The example encoded with Playfair modified in this way, using an IV of „AB“ might look thus:

OKHKBGVF…

This process greatly increases the security of the encryption system. When done with computers, the speed of the processing of the encryption is not significantly hindered.

Example of usage

PLAYFAIR cipther = new PLAYFAIR();
String OT = "This is a 'secter message', do not read it";
String ST = "";
String KEY = "SECRET";
System.out.println("PLAYFAIR$ : open text : "+OT);
ST = cipther.encode(KEY,OT);
System.out.println("PLAYFAIR$ : encoded : "+ST);
OT = cipther.decode(KEY,ST);
System.out.println("PLAYFAIR$ : decoded : "+OT);

Licence

Lorem

The Code

class PLAYFAIR
{

	private final int w		= 5;
	private final int h		= 5;
	private char[][] matrix	= new char[w][h];

	// EXAMPLE
	// PASSWORD : LOREMIPSUMDOLOR -> LOREMIPSUD
	//
	//   +-----+-----+-----+-----+-----+
	//   +> L <+> O <+> R <+> E <+> M <+
	//   +-----+-----+-----+-----+-----+
	//   +> I <+> P <+> S <+> U <+> D <+
	//   +-----+-----+-----+-----+-----+
	//   |  A  |  B  |  C  |  F  |  G  |
	//   +-----+-----+-----+-----+-----+
	//   |  H  |  K  |  N  |  Q  |  T  |
	//   +-----+-----+-----+-----+-----+
	//   |  V  |  W  |  X  |  Y  |  Z  |
	//   +-----+-----+-----+-----+-----+
	//

	public void setKey(String key)
	{
		if(key == null)
			key = "A";

		int nbIn = 0;

		char[] single	= new char[26];
		boolean[] done	= new boolean[26];
		char[] keyDigit	= key.toUpperCase().toCharArray();

		Loop1:for(char c : keyDigit)
		{
			char actual = c;
			actual = (actual == 'J')?'I':actual;

			int index = actual - 'A';
			if(done[index])
				continue Loop1;
			done[index] = true;
			single[nbIn++] = actual;
		}

		if(nbIn == 0)
		{
			single[nbIn++] = 'A';
			done[0] = true;
		}

		Loop2:for(char c = 'A'; c <= 'Z'; c++)
		{
			if(c == 'J' || done[c - 'A'])
				continue Loop2;
			single[nbIn++] = c;
		}

		for(int x = 0; x < w; x++)
			for(int y = 0; y < h; y++)
				matrix[x][y] = single[x * w + y];

	}

	public String encode(String key,String OT)
	{

		if(OT == null)
			return "";

		this.setKey(key);

		char[] digit = OT.toUpperCase().toCharArray();
		java.util.ArrayList<Pair> list = new java.util.ArrayList<Pair>(10000);
		int index = 0;
		int i = 0;
		Pair lp = null;

		while(i < digit.length)
		{

			digit[i] = (digit[i] == 'J')?'I':digit[i];

			if(index == 0)
			{
				lp = new Pair(digit[i++], true);
				list.add(lp);
				index = 1;
				continue;
			}

			lp.setCharacterAlternative((lp.left == digit[i])?'X':digit[i++]);

			index = 0;
		}

		if(index == 1)
			lp.setCharacterAlternative('X');

		return addSpaces(pairToString(list));
	}

	public String decode(String key,String ST)
	{
		if(ST == null)
			return "";

		this.setKey(key);
		char[] digit = ST.toUpperCase().toCharArray();
		StringBuilder sb = new StringBuilder(digit.length);
		java.util.ArrayList<Pair> aList = new java.util.ArrayList<Pair>(10000);

		for(int i = 0; i < digit.length; i++)
			sb.append((digit[i] == 'J')?'I':digit[i]);

		digit = sb.toString().toCharArray();

		for(int i = 0; i < digit.length; i += 2)
		{
			Pair lp = new Pair(digit[i], false);
			lp.setCharacterAlternative(digit[i+1]);
			aList.add(lp);
		}

		return pairToString(aList);
	}

	private String pairToString(ArrayList<Pair> list)
	{
		String result="";
		for(int i=0; i<list.size(); result+=list.get(i++).getPair());
		return result;
	}

	//
	// AAAAABBBBBCCCCCDDDDDEEEEE -> AAAAA BBBBB CCCCC DDDDD EEEEE
	//

	private String addSpaces(String sb)
	{
		String result = "";
		int i=0;
		int succ=0;
		String[] ar = sb.split("");

		for(String s : ar)
		{
			result+=s;
			if(i==5)
			{
				i=0;
				if(succ!=ar.length-1)
				result+=" ";
			}
			i++;
			succ++;
		}

		return result;
	}

	private class Pair
	{

		private char left;
		private Point point_left, point_right;
		private char[] character = new char[2];
		boolean inverse;

		private Pair(char left, boolean coding)
		{
			this.left		= left;
			this.inverse	= !coding;
			this.point_left	= position(left);
		}

		//	EXAMPLE
		//  _PASSWORD : PSI
		//  _OT : LOREM IPSUM
		//  _ST : RHXLA LSINT
		//
		//    +-------+-------+-------+-------+-------+
		//    | * P * | * S * | * I * |   A   |   B   |
		//    +-------+-------+-------+-------+-------+
		//    |   C   |   D   |   E   |   F   |   G   |
		//    +-------+-------+-------+-------+-------+
		//    |   H   |   K   |   L   |   M   |   N   |
		//    +-------+-------+-------+-------+-------+
		//    |   O   |   Q   |   R   |   T   |   U   |
		//    +-------+-------+-------+-------+-------+
		//    |   V   |   W   |   X   |   Y   |   Z   |
		//    +-------+-------+-------+-------+-------+
		//
		//   LO -> ruleRectangle -> RH
		//   RE -> ruleColumn    -> XL
		//   MI -> ruleRectangle -> AL
		//   PS -> ruleRow       -> SI
		//   UM -> ruleRectangle -> NT
		//

		private void setCharacterAlternative(char c)
		{
			point_right = position(c);

			if(point_left.x == point_right.x)
				ruleRow();
			else if(point_left.y == point_right.y)
				ruleColumn();
			else
				ruleRectangle();

			character[0] = matrix[point_left.x][point_left.y];
			character[1] = matrix[point_right.x][point_right.y];
		}

		//                              ^
		//                              |
		//                              |
		//
		//          +-------+-------+-------+-------+-------+
		//          |       |       |       |       |       |
		//          +-------+-------+-------+-------+-------+
		//          |       |   D   |       |   D   |       |
		//          +-------+-------+-------+-------+-------+
		//          |       | ///// |       | ##### |       |
		//          +-------+-------+-------+-------+-------+
		//          |       |   E   |       |   E   |       |
		//          +-------+-------+-------+-------+-------+
		//          |       |       |       |       |       |
		//          +-------+-------+-------+-------+-------+
		//
		//                              |
		//                              |
		//                              v

		private void ruleRow()
		{
			this.point_left.y	= inverse?((this.point_left.y < 1)	? h-1 : this.point_left.y-1):((this.point_left.y+1)%h);
			this.point_right.y	= inverse?((this.point_right.y < 1)	? h-1 : this.point_right.y-1):((this.point_right.y+1)%h);
		}

		//
		//          +-------+-------+-------+-------+-------+
		//          |       |       |       |       |       |
		//          +-------+-------+-------+-------+-------+
		//   <----- |       |   D   | ///// |   E   |       | ----->
		//          +-------+-------+-------+-------+-------+
		//          |       |       |       |       |       |
		//          +-------+-------+-------+-------+-------+
		//   <----- |       |   D   | ##### |   E   |       | ----->
		//          +-------+-------+-------+-------+-------+
		//          |       |       |       |       |       |
		//          +-------+-------+-------+-------+-------+
		//
		private void ruleColumn()
		{
			this.point_left.x	= inverse?((this.point_left.x < 1)	?	w-1 : this.point_left.x-1):((this.point_left.x+1)%w);
			this.point_right.x	= inverse?((this.point_right.x < 1)	?	w-1 : this.point_right.x-1):((this.point_right.x+1)%w);
		}

		//
		//          +-------+-------+-------+-------+-------+
		//          |       |       |       |       |       |
		//          +-------+-------+-------+-------+-------+
		//   +----> |       |       |  E/D  | ///// |       | -----+
		//   |      +-------+-------+-------+-------+-------+      |
		//   |      |       |       |       |       |       |      |
		//   |      +-------+-------+-------+-------+-------+      |
		//   +----- |       |       | ##### |  E/D  |       | <----+
		//          +-------+-------+-------+-------+-------+
		//          |       |       |       |       |       |
		//          +-------+-------+-------+-------+-------+
		//
		private void ruleRectangle()
		{
			int r			= point_left.y;
			point_left.y	= point_right.y;
			point_right.y	= r;
		}

		//
		//         ---- y ---->
		// +-------+-------+-------+-------+-------+
		// | [0,0] | [1,0] | [2,0] | [3,0] | [4,0] |
		// +-------+-------+-------+-------+-------+  |
		// | [0,1] | [1,1] | [2,1] | [3,1] | [4,1] |  |
		// +-------+-------+-------+-------+-------+  x
		// | [0,2] | [1,2] | [2,2] | [3,2] | [4,2] |  |
		// +-------+-------+-------+-------+-------+  |
		// | [0,3] | [1,3] | [2,3] | [3,3] | [4,3] |  v
		// +-------+-------+-------+-------+-------+
		// | [0,4] | [1,4] | [2,4] | [3,4] | [4,4] |
		// +-------+-------+-------+-------+-------+
		//

		private Point position(char letter)
		{
			for(int x = 0; x < 5; x++)
				for(int y = 0; y < 5; y++)
					if(matrix[x][y] == letter)
						return new Point(x, y);

			throw new IllegalStateException("Pismeno " + letter + " neni v mrizce");
		}

		// EXAMPLE
		// _OT_CHAR : A
		// _ST_CHAR : G
		//
		// getPair -> AG

		private String getPair() { return String.valueOf(character); }
	}

}

Download

Lorem

Lorem

Ukázka

jcGraph graph = new jcGraph();
jcGraphData data = new jcGraphData();
String[] thicks = {"a","b","c"};
graph.setHorizontalThicks(thicks);
data.create("graphA");
data.create("graphB");

for(int i=0; i<3; i++)
{
  data.add("graphA", 0.2f*i);
  data.add("graphB", 0.1f*i);
}

graph.put(data);

JPanel panel = new JPanel();
panel.add(graph);

Screenshot

Kód

Konstanty

package cajthamlConstants;

import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Paint;

public class Constants
{
	public static final Color FONT_COLOR = Color.white;
	public static final Paint THICK_COLOR = new Color(40,40,40);
	public static final Paint SHADE_W = new Color(255,255,255,10);
	public static final Paint SHADE_B = new Color(0,0,0,50);
	public static final Color BG_COLOR = new Color(30,30,30);
	public static final Paint BOX_COLOR = new Color(10,10,10);
	public static final Paint SLIDER_BG = new Color(20,20,20);
	public static final Paint SLIDER_FG = Color.white;
	public static final Paint SLIDER_FONT_COLOR = Color.black;
	public static final Paint SLIDER_FG_FOCUS = new Color(206,255,168);
}

Továrna

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.RenderingHints;
import java.awt.geom.Area;
import java.awt.geom.GeneralPath;
import java.awt.geom.Rectangle2D;
import java.util.Hashtable;
import java.util.LinkedList;
import javax.swing.JPanel;

import cajthamlConstants.Constants;

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

public class jcGraph extends JPanel
{

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

	private static final long serialVersionUID = 1316232270722954338L;
	static int id = 0;
	boolean displayThicks = false;
	boolean displayLabels = false;
	int lineHeight = 10;
	static Hashtable<Integer,jcGraphData> graphs	= new Hashtable<Integer,jcGraphData>();
	Hashtable<Integer,Paint> _fcolors = new Hashtable<Integer,Paint>();
	Hashtable<Integer,Paint> _bcolors = new Hashtable<Integer,Paint>();
	String[] thicksH = {""};
	Paint _bg = new Color(0,0,0);
	Paint _cordsBg = new Color(255,255,255);
	int width = 10;
	int height = 100;
	int h = 1;
	int w = 1;
	int offset = 100;
	float amplitude = 1;
	Paint _shade = new Color(0,0,0,20);
	int thick = 2;

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

	public jcGraph()
	{
		setOpaque(false);

		_fcolors.put(0,new Color(224,27,106));
		_fcolors.put(1,new Color(27,142,224));
		_fcolors.put(2,new Color(139,224,27));
		_fcolors.put(3,new Color(200,200,200));

		_bcolors.put(0,new Color(224,27,106,30));
		_bcolors.put(1,new Color(27,142,224,30));
		_bcolors.put(2,new Color(139,224,27,30));
		_bcolors.put(3,new Color(200,200,200,30));
	}

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

	public void paint(Graphics g)
	{
		Graphics2D g2 = (Graphics2D)g;
		g2.setRenderingHint (RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		g2.setRenderingHint (RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);

		int i=0;

		this.amplitude = graphs.get(0).getAmplitude();

		g.translate(offset/2, offset/2);

		w=getWidth()-offset;
		h=(int) (getHeight()-1.5f*offset);
		height=h;
		width=w/(thicksH.length-1);

		paintHorizontalThicks(g2);
		paintHVerticalThicks(g2);

		for(LinkedList<Float> data : graphs.get(0).iterator())
			drawGraph(g2,data,_fcolors.get(i),_bcolors.get(i++));

		g.translate(-offset/2, -offset/2);		

	}

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

	public void setHorizontalThicks(String[] thicks)
	{ this.thicksH=thicks; }

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

	private void paintHorizontalThicks(Graphics2D g)
	{

		g.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND,30));

		for(int i=0; i<thicksH.length; i++)
		{
			int x=i*width;
			int y=height+offset/4;
			g.setPaint(Constants.THICK_COLOR);
			g.drawLine(x,0,x,y-offset/4);
			g.setPaint(Constants.FONT_COLOR);
			g.drawString(thicksH[i], x-2,y+offset/4);
		}

	}

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

	private void paintHVerticalThicks(Graphics2D g)
	{
		g.setFont(new Font("Arial", Font.PLAIN, 20));
		g.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND,30));

		int x=width*(this.thicksH.length-1);
		g.setPaint(Constants.THICK_COLOR);
		for(int i=0; i<=this.height/this.lineHeight; i++)
		{
			int y=(height)-((i)*this.lineHeight);
			g.drawLine(0,y,x,y);
		}

		g.drawLine(0,0,width*(this.thicksH.length-1),0);
	}

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

	private void drawGraph(Graphics2D g, LinkedList<Float> data, Paint paintF, Paint paintB)
	{

		int x=0;

		GeneralPath body = new GeneralPath();

		body.moveTo(0,0);
		for(float y : data)
		{
			y/=amplitude;
			if(x==0)	body.moveTo(x*width, (h-y*height));
			else	body.lineTo(x*width, (h-y*height));
			x++;
		}

		GeneralPath b2 = (GeneralPath) body.clone();
		b2.lineTo(w,h);
		b2.lineTo(0,h);

		g.setStroke(new BasicStroke(this.thick, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND,30));

		Area area = new Area(new Rectangle2D.Float(0,0,w,h));
		area.intersect(new Area(b2));
		g.setPaint(paintB);
		g.fill(area);
		g.setPaint(paintF);
		g.draw(body);

	}

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

	public void put(jcGraphData a)
	{ graphs.put(id++, a); }

	public static jcGraphData getGraph()
	{
		return graphs.get(0);

	}

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

}

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

Data

import java.util.Collection;
import java.util.Hashtable;
import java.util.LinkedList;

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

public class jcGraphData
{

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

	private Hashtable<String,LinkedList<Float>> map = new Hashtable<String,LinkedList<Float>>(); 

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

	public void create(String title)
	{ this.map.put(title, new LinkedList<Float>()); }

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

	public void add(String title,float value)
	{ this.map.get(title).add(value); }

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

	public LinkedList<Float> get(String title)
	{ return this.map.get(title); }

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

	public void get(String title, int x)
	{ this.map.get(title).get(x); }

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

	public Collection<LinkedList<Float>> iterator()
	{ return this.map.values(); }

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

	public float getAmplitude()
	{
		float max=1;
		for(LinkedList<Float> data : iterator())
		{
			for(float cell : data)
				max=(max<cell)?cell:max;

		}
		return max;
	}

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

	public void erase(String title)
	{ this.map.get(title).clear(); }

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

}

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

Stažení

Lorem

Operace mezi maticemi

		int n=10;
		int[][] matice = new int[n][n];

		for(int i=0; i<n; i++)
			for(int j=0; j<n; j++)
				matice[j][i]=1;

		Matrix<NumberCore> C = Factory.createMatrix(matice);
		Matrix<NumberCore> A = Factory.createMatrix(matice);
		Matrix<NumberCore> B = Factory.createMatrix(matice);
		B.neutral();

			C=B.plus(A);

		for(int i=1; i<=n; i++)
		{
			for(int j=1; j<=n; j++)
			{
				System.out.print("  "+C.getElement(j, i));
			}
			System.out.println();
		}

	}

Výstup

Dokumentace & Licence

Počítání matic v lineárním čase

Nutná rozhraní

Entry

public interface Entry<E> extends DeepClonable<E>
{
	///////////////////////////////////////////////////////////////

	E times(E entry);
	E plus(E entry);
	E minus(E entry);
	void zero();
	void neutral();

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

}

DeepClone

public interface DeepClonable<E> extends Cloneable,java.io.Serializable
{
	///////////////////////////////////////////////////////////////

	public E duplicate();

	///////////////////////////////////////////////////////////////
}

Kód

Kernel

Factory

public class Factory
{
	///////////////////////////////////////////////////////////////

	public static Matrix<NumberCore> createMatrix(int[][] array)
	{
		NumberCore[][] result = new NumberCore[array.length][array[0].length];

		for(int y=0; y< array.length; y++)
			for(int x=0; x< array[y].length; x++)
				result[y][x]=new NumberCore(array[y][x]);

		return new Matrix<NumberCore>(result);
	}

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

}

HashTable

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

class Pair<K,V>
{
    K key;
    V value;

    Pair(K k, V v){

        key = k;
        value = v;
    }

    public int hashCode()
    {
        return key.hashCode() + 3 * value.hashCode();
    }

	public boolean equals(Object other)
    {
        if (! (other instanceof Pair<?,?>)) return false;
        Pair<?,?> o = (Pair<?,?>) other;
        return key.equals(o.key) && value.equals(o.value);
    }
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/** Trida DSAHashTable reprezentuje rozptylovaci tabulku se zřetězením (první varianta v učebnici). */
public class HashTable<K,V> implements Iterable<Pair<K,V>>
{

    private transient volatile int count = -1 ;
    private transient volatile int capacity = -1 ;
    private transient volatile int troubleshoot = -1 ;
    private transient volatile java.util.Set < Pair < K,V > > [ ] table ;

    /**Vytvori prazdnou instanci DSAHashTable, delka vnitrniho pole je nastavena na size. */

    @SuppressWarnings("unchecked")
	HashTable ( int capacity )
    {
		this.count = 0;
		this.capacity = capacity ;
		this.troubleshoot = capacity;

		this.table    = (java.util.Set<Pair<K, V> >[]) new java.util.Set<?>[capacity];
    	this.initCells ( this.table );
    }

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

    /** Ulozi dvojici (key, value) do rozptylovaci tabulky.
     * Pokud uz v tabulce je jina dvojice se stejnym klicem,
     * je smazana.
     * Klic ani hodnota nesmi byt null.
     * Pokud by pocet dvojic v tabulce po vykonani put mel vzrust nad
     *  dvojnasobek delky vnitrniho pole, vnitrni pole zdvojnasobi.
     */
	void put ( K key , V value )
    {

		if ( value == null || key == null )
    	    return ;    	    	

		Pair<K,V> pair = new Pair<K,V> ( key , value ) ;

			remove(key);

    		int index = this.getIndexOf ( pair.key ) ;
    		table [ index ].add ( pair ) ;

    		count++;

        	if ( ! this.isBigEnough ( ) )
        		resize ( capacity << 1 ) ;
    }

	/////////////////////////////////////////////////////////////////////////////
    /** Vrati hodnotu asociovanou s danym klicem nebo null, pokud dany klic v tabulce neni. */

	synchronized V get ( K key )
    {
		Pair<K,V> pair = this.getPair(key);
		if(pair==null) return null;
		return pair.value;
	}
/////////////////////////////////////////////////////////////////////////////

	private synchronized Pair<K,V> getPair ( K key )
    {
    	for ( Pair < K,V > e : this.table [ this.getIndexOf ( key ) ] )
    		if ( e . key . equals ( key ) )
    			return e;
    	return null ;
	}

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

	private synchronized void initCells ( java.util.Set<Pair<K, V>>[] table )
	{

    		for ( int i = 0 ; i<table.length ; i ++ )
        			table [ i ] = new GenericSet<Pair<K,V>>();	

	}

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

    /** Smaze dvojici s danym klicem. Pokud v tabulce dany klic neni, nedela nic. */
	synchronized void remove ( K key )
    {
		int index = this.getIndexOf(key);
		Pair<K,V> pair= this.getPair(key);
		if(pair!=null)
		{
				this.table[index].remove(pair);
				this.count--;
				return;
		}

    }

/////////////////////////////////////////////////////////////////////////////
    /** Vrati vnitrni pole. */
	java.util.Set<Pair<K,V>>[] getArray()
    {
		//OK
		return this.table ;
    }

/////////////////////////////////////////////////////////////////////////////
    /** Pro dany klic vrati index v poli. */
    int getIndexOf ( K key )
    {
    	//OK
		return key.hashCode ( ) % troubleshoot ;
    }

/////////////////////////////////////////////////////////////////////////////
    /** Pokud je pocet prvku mensi nebo roven dvojnasobku delky vnitrniho pole, vrati true, jinak vrati false. */
    private boolean isBigEnough()
    {
    	//OK
    	return this.count <= this.capacity << 1 ;
    }

/////////////////////////////////////////////////////////////////////////////
    /** Zmeni delku vnitrniho pole a zkopiruje do nej vsechny dvojice. */
    @SuppressWarnings("unchecked")
	synchronized void resize ( int size )
    {
    	//OK
    	java.util.Set < Pair < K,V > > [ ] temp = (java.util.Set<Pair<K, V> >[]) new java.util.Set<?>[size];
		this.initCells ( temp ) ;
		this.troubleshoot = size;
		for ( Pair<K, V> p : this )
		{
			int index = this.getIndexOf ( p.key ) ;
			temp [ index ].add ( p ) ;
		}
		this.capacity = size;
		this.table = temp;
	}

	/////////////////////////////////////////////////////////////////////////////
    /** Vrati iterator pres vsechny dvojice v tabulce. */
    public java.util.Iterator < Pair < K,V > >  iterator ( )
    {
    	java.util.Set< Pair < K,V >> c = new GenericSet< Pair < K,V >>();
    		for ( int i = 0 ; i < this.capacity ; i ++ )
        			for( Pair < K,V > p : table [ i ] )
        				c.add ( p ) ;	

    	return c.iterator();

    }

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

    private class GenericSet<G> extends java.util.HashSet<G>
    {
		private static final long serialVersionUID = -1093311608282332682L;
    }

    public int getSize()
    {
    	return this.count;
    }
}

NumberCore

public class NumberCore implements Entry<NumberCore>
{

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

	private java.math.BigInteger value;

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

	public NumberCore(int value)
	{ this.value = new java.math.BigInteger(String.valueOf(value)); }

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

	private NumberCore(java.math.BigInteger value)
	{ this.value = value; }

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

	public synchronized NumberCore minus(NumberCore entry)
	{ return new NumberCore(this.value.min(entry.value)); }

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

	public synchronized NumberCore plus(NumberCore entry)
	{ return new NumberCore(this.value.add(entry.value)); }

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

	public synchronized NumberCore times(NumberCore entry)
	{ return new NumberCore(this.value.multiply(entry.value)); }

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

	public String toString()
	{ return this.value.toString(); }

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

	public NumberCore duplicate()
	{ return new NumberCore(this.value); }

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

	public void neutral()
	{ this.value=java.math.BigInteger.ONE; }

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

	public void zero()
	{ this.value=java.math.BigInteger.ZERO; }

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

}

Matrix

public class Matrix<E extends Entry<E>> implements Entry<Matrix<E>>
{
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////

	private int size;
	private HashTable<Integer,HashTable<Integer,E>> data;

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

	public Matrix ( E[][] array )
    { 

    		if( array==null ) return;

			size = array.length;
			this.data = new HashTable<Integer,HashTable<Integer,E>>(size);

			for(int i=1; i<=size ; i++)
			{
				this.data.put(i, new HashTable<Integer,E>(size));
				for(int j=1; j<=size; j++)
				{
					this.data.get(i).put(j, array[j-1][i-1]);
				}
			}

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

    }

	private Matrix ( HashTable<Integer, HashTable<Integer, E>> array )
    { 

    		if( array==null ) return;

			size = array.getSize();
			this.data=array;

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

    }

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

	public synchronized E getElement( int x , int y )
	{

		return this.data.get(y).get(x);

	}

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

	public int getSize()
	{
		return this.size;
	}

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

	public synchronized Matrix<E> minus(Matrix<E> other)
	{
	HashTable<Integer,HashTable<Integer,E>> array = new HashTable<Integer,HashTable<Integer,E>>(size);

		for(int i=1; i<=size ; i++)
		{
			array.put(i, new HashTable<Integer,E>(size));
			for(int j=1; j<=size; j++)
			{
				array.get(i).put(j, this.getElement(i,j).minus(other.getElement(i, j)));
			}
		}

		return new Matrix<E>(array);
	}

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

	public synchronized Matrix<E> plus(Matrix<E> other)
	{
		HashTable<Integer,HashTable<Integer,E>> array = new HashTable<Integer,HashTable<Integer,E>>(size);

		for(int i=1; i<=size ; i++)
		{
			array.put(i, new HashTable<Integer,E>(size));
			for(int j=1; j<=size; j++)
			{
				array.get(i).put(j, this.getElement(i,j).plus(other.getElement(i, j)));
			}
		}

		return new Matrix<E>(array);

	}

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

	public synchronized Matrix<E> times(Matrix<E> other)
	{
	HashTable<Integer,HashTable<Integer,E>> array = new HashTable<Integer,HashTable<Integer,E>>(size);

		for(int i = 1; i <= size; i++)
		{
			array.put(i, new HashTable<Integer,E>(size));
		    for(int j = 1; j <= size; j++) {

		    	E el = this.getElement(j, i).duplicate();
		    	el.zero();

		        for(int s = 1; s<=other.size; s++)
		        {
		        	el=el.plus((this.getElement(s, i).times(other.getElement(j, s))));
		        }
		        array.get(i).put(j,el);

		        }
		    }

		return new Matrix<E>(array);
	}

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

	public Matrix<E> duplicate()
	{
		return new Matrix<E>(this.data);
	}

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

	public void neutral()
	{

		for(int i=1; i<=size ; i++)
			for(int j=1; j<=size; j++)
			{
				if(i==j)
					this.getElement(i, j).neutral();
				else
					this.getElement(i, j).zero();
			}

	}

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

	public void zero()
	{
		for(int i=1; i<=size ; i++)
			for(int j=1; j<=size; j++)
					this.getElement(i, j).zero();
	}

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

}

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

Například:

public class Test
{
	public static void main(String[] args)
	{

		Message message = new Message(123);

		System.out.println("message: "+message);

		RSA<Pair,Message> rsa = new RSA<Pair,Message>();
		Pair publicKey = new Pair(3233,17);
		Pair privateKey = new Pair(3233,2753);

		System.out.println("\nCrypting with public key");
		message=rsa.encrypt(publicKey, message);
		System.out.println("crypted: "+message);

		System.out.println("\nEncrypting with private key");
		message=rsa.decrypt(privateKey, message);
		System.out.println("result: "+message);

		System.out.println("\nCrypting with public key");
		message=rsa.encrypt(publicKey, message);
		System.out.println("crypted: "+message);

		System.out.println("\nEncrypting with brute force");
		message=rsa.brute(publicKey, message);
		System.out.println("result: "+message);
	}
}

Dokumentace & Licence

Potřebná rozhraní

public interface Crypt <K,M>
{
	M encrypt ( K key , M message ) ;
	M decrypt ( K key , M message ) ;
	M brute   ( K key , M message ) ;
}

Potřebné objekty

public class Pair
{
	private int modulo;
	private int key;

	Pair(int modulo, int key)
	{
		this.modulo=modulo;
		this.key=key;
	}

	public int getModulo()
	{
		return modulo;
	}

	public int getKey()
	{
		return key;
	}

}

public class Message
{
	private int value=0;
	Message(int value)
	{
	this.value=value;
	}

	int getValue()
	{
		return this.value;
	}
	void setValue(int value)
	{
		this.value=value;
	}

	public String toString()
	{
		return String.valueOf(this.value);
	}

}

Kód

Implementace

public class RSA<K extends Pair,M extends Message> implements Crypt<K,M>
{

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

	public M decrypt(K key, M msg)
	{
		return this.decrypt(key.getModulo(), key.getKey(), msg);
	}

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

	public M encrypt(K key, M msg)
	{
		msg.setValue(this.exponent(msg.getValue(), key.getKey(),key.getModulo()));
		return msg;
	}

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

	private M decrypt(int modulo, int key, M msg)
	{
		msg.setValue(this.exponent(msg.getValue(),key,modulo));
		return msg;
	}

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

	private int exponent(int number, int exponent,int modulo)
	{
		    long x=1;
		    long y=number;
		    while(exponent > 0)
		    {
		        if(exponent%2 == 1)
		            x=(x*y)%modulo;
		        y = (y*y)%modulo;
		        exponent /= 2;
		    }
		    return (int) x%modulo;

	}

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

	public M brute(K key, M message)
	{
		int n = key.getModulo();
		int p = this.root(n);
		return this.decrypt(
				key.getModulo(),
				this.inversion(key.getKey(),(p-1)*(n/p-1)),
				message);
	}

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

	private int inversion(int number, int modulo)
	{
		int i = modulo, v = 0, d = 1;
		while (number>0)
			 {
			  int t = i/number, x = number;
			  number = i % x;
			  i = x;
			  x = d;
			  d = v - t*x;
			  v = x;
			 }
			 v %= modulo;
			 if (v<0) v = (v+modulo)%modulo;
			 return v;

	}

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

	private int root ( int n )
	{

		boolean search = true ;
		int p=0;

		while(search)
		{
			float a = n/++p;
			int b = (int)a;
			if(p==n || ((a==b) && this.isPrime(b) && (p*a)==n))
				search=false;
		}

		return p;

	}

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

	private boolean isPrime(int num)
	{
		 int i;
		 for (i=2; i < num ;i++ )
			 if((num%i)==0) return false;
		 return (i == num);
	}

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

}

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

Lorem ipsum

Dokumentace & Licence

Licence

Lorem ipsum

Dokumentace

Rozhrani Entry reprezentuje objekt se kterym lze delat matematicke operace scitani/nasobeni/odcitani.

interface Entry < E >
{
  E times ( E entry ) ;
  E plus ( E entry ) ;
  E minus ( E entry ) ;
}

Rozhrani Matrix reprezentuje ctvercovou matici, jejiz rozmer je mocnina dvojky.

interface Matrix < E > extends Entry < Matrix < E > >
{
    // Vrati rozmer matice.
    int getSize();
    // Vrati prvek na indexu n, m (1 <= n <= getSize(), 1 <= m <= getSize()).
    E getElement(int n, int m);
    // Vrati levou horni podmatici.
    Matrix<E> getTopLeftSubmatrix();
    // Vrati pravou horni podmatici.
    public Matrix<E> getTopRightSubmatrix();
    // Vrati levou dolni podmatici.
    public Matrix<E> getBottomLeftSubmatrix();
    // Vrati pravou dolni podmatici.
    public Matrix<E> getBottomRightSubmatrix();
    // Vrati soucet matic this a other
    public Matrix<E> plus(Matrix<E> other);
    // Vrati rozdil matic this a other
    public Matrix<E> minus(Matrix<E> other);
    // Vrati soucin matic this a other
    public Matrix<E> times(Matrix<E> other);
}

Kód

class GenericMatrix < E extends Entry < E > > implements Matrix < E >
{

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

  private Matrix < E > top_left = null;
  private Matrix < E > top_right = null;
  private Matrix < E > bottom_left = null;
  private Matrix < E > bottom_right = null;

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

  private int size;
  private int center;
  private E value;

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

  public GenericMatrix ( E [][] contents )
  {

    if( contents==null ) return;
    size = contents.length;
    center = size/2;

    if( contents.length==1 )
    {
      value = contents[0][0];
      top_left     = this;
      top_right    = this;
      bottom_left  = this;
      bottom_right = this;
      return;
     }

     E[][] A11 = (E[][]) new Object[center][center];

     for(int i=0; i<center ; i++)
       for(int j=0; j<center ; j++)
         A11[i][j]=contents[i][j];

     E[][] A12 = (E[][]) new Object[center][center];

     for(int i=0; i<center ; i++)
       for(int j=center; j<size ; j++)
         A12[i][j-center]=contents[i][j];

     E[][] A21 = (E[][]) new Object[center][center];

     for(int i=center; i<size ; i++)
       for(int j=0; j<center ; j++)
         A21[i-center][j]=contents[i][j];

     E[][] A22 = (E[][]) new Object[center][center];

     for(int i=center; i<size ; i++)
       for(int j=center; j<size ; j++)
         A22[i-center][j-center]=contents[i][j];

     top_left     =  new GenericMatrix<E> ( A11 );
     top_right    =  new GenericMatrix<E> ( A12 );
     bottom_left  =  new GenericMatrix<E> ( A21 );
     bottom_right =  new GenericMatrix<E> ( A22 );

    }

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

  public E getElement( int y , int x )
  {

    if( size==1 ) return value;

    if(y>center)
    {
      if( x>center )
        return bottom_right.getElement( y-center , x-center );
        return bottom_left.getElement( y-center , x);
    }
    else
    {
      if( x>center )
        return top_right.getElement( y , x-center );
	return top_left.getElement( y , x );
    }

  }

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

  public int getSize()
  {
    return this.size;
  }

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

  public Matrix<E> minus(Matrix<E> other)
  {

    E[][] array = (E[][]) new Object[other.getSize()][other.getSize()];

    for(int i=0; i<size ; i++)
      for(int j=0; j<size; j++)
        array[i][j] = this.getElement(i+1,j+1).minus(other.getElement(i+1, j+1));

    return new GenericMatrix<E>(array);

  }

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

  public Matrix<E> plus(Matrix<E> other)
  {

    E[][] array = (E[][]) new Object[other.getSize()][other.getSize()];

    for(int i=0; i<size ; i++)
      for(int j=0; j<size; j++)
        array[i][j] = this.getElement(i+1,j+1).plus(other.getElement(i+1, j+1));

    return new GenericMatrix<E>(array);

  }

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

  public Matrix<E> times(Matrix<E> other)
  {

    E [][] result = (E[][]) new Object[other.getSize()][other.getSize()];	

    if(this.getSize() == 1)
    {
      result[0][0] = this.getElement(0,0).times(other.getElement(0,0));
      return new GenericMatrix<E>(result);
    }

    Matrix<E> A11 = this.getTopLeftSubmatrix();
    Matrix<E> A12 = this.getTopRightSubmatrix();
    Matrix<E> A21 = this.getBottomLeftSubmatrix();
    Matrix<E> A22 = this.getBottomRightSubmatrix();

    Matrix<E> B11 = other.getTopLeftSubmatrix();
    Matrix<E> B12 = other.getTopRightSubmatrix();
    Matrix<E> B21 = other.getBottomLeftSubmatrix();
    Matrix<E> B22 = other.getBottomRightSubmatrix();

    Matrix<E> P1 = (A11.plus(A22)).times(B11.plus(B22));
    Matrix<E> P2 = (A21.plus(A22)).times(B11);
    Matrix<E> P3 = A11.times(B12.minus(B22));
    Matrix<E> P4 = A22.times(B21.minus(B11));
    Matrix<E> P5 = (A11.plus(A12)).times(B22);
    Matrix<E> P6 = (A21.minus(A11)).times(B11.plus(B12));
    Matrix<E> P7 = (A12.minus(A22)).times(B21.plus(B22));

    Matrix<E> C11 = P7.plus((P1.plus(P4)).minus(P5));
    Matrix<E> C12 = P3.plus(P5);
    Matrix<E> C21 = P2.plus(P4);
    Matrix<E> C22 = ((P1.plus(P3)).minus(P2)).plus(P6);

    GenericMatrix<E> res = new GenericMatrix<E>(result);
    res.putTree(C11,C12,C21,C22);
    return res;

  }

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

  private void putTree(Matrix<E> C11, Matrix<E> C12, Matrix<E> C21, Matrix<E> C22)
  {
    this.top_left=C11;
    this.top_right=C12;
    this.bottom_left=C21;
    this.bottom_right=C22;

  }

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

  public Matrix<E> getBottomLeftSubmatrix()
  {
    return bottom_left;
  }

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

  public Matrix<E> getBottomRightSubmatrix()
  {
    return bottom_right;
  }

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

  public Matrix<E> getTopLeftSubmatrix()
  {
    return top_left;
  }

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

  public Matrix<E> getTopRightSubmatrix()
  {
    return top_right;
  }

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

}

Download

Použití například

Set<String> set = new GenericSet<String>() ;

for ( String T : set )
  System.out.println ( T ) ;

Dokumentace & Licence

Kód

class GenericSet<P> implements java.util.Set<P>,Iterable<P>
{

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

  private Node head ;
  private int count ;

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

  public GenericSet()
  {
    clear();
    this.count = 0;
  }

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

  private int size()
  {
    return this.count;
  }

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

  public boolean add(P o)
  {
    Node temp = new Node(o);
    Node current = head;
    while(current.getNext() != null)
      current = current.getNext();

    current.setNext(temp);
    this.count++;
    return true;
  }

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

  public boolean remove ( Object o )
  {
    Node current = head;
    while(current.getNext() != null && current.getNext().getData()!=o)
      current = current.getNext();
    current.setNext(current.getNext().getNext());
    this.count--;
    return true;
  }

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

  public boolean addAll(java.util.Collection<? extends P> c) { return false; }

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

  public void clear()
  {
    head = new Node(null);
  }

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

  public boolean contains(Object o)
  {
    for(P n : this) if(n.equals(o)) return true;    
    return false;
  }

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

  public boolean containsAll(java.util.Collection<?> c) { return false; }

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

  public boolean isEmpty() { return this.size()==0; }

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

  public java.util.Iterator<P> iterator() { return new GenericIterator(); }

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

  public boolean removeAll(java.util.Collection<?> c) { return false; }

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

  public boolean retainAll(java.util.Collection<?> c) { return false; }

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

  public Object[] toArray() { return null; }

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

  public <T> T[] toArray(T[] a) { return null; }

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

  private class GenericIterator implements java.util.Iterator<P>
  {
    Node cur = head;
    public boolean hasNext() { return cur.next!=null; }
    public P next() { return (cur=cur.next).getData(); }
    public void remove() { }
  }

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

  private class Node
  {
    Node next;
    P data;
    public Node(P _data) { next = null; data = _data; }
    public P getData() { return data; }
    public Node getNext() { return next; }
    public void setNext(Node _next) { next = _next; }
  }

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

}

Download