SpiderX wrote:Hi Kilian,

Are you using bits to implement your algorithm ? or just storing information in integers or long ?

For example:
1111 1111 1111 1111


you can store it directly as
long a = 1111 1111 1111 1111;

or the more efficient way:

int a = 0xFFFF

in this way calculation and manipulations could be must more efficient as less memory is required.

Operations maybe less straightforward in this manner, but it should be possible to implement functions to manipulate the bits as if it is an array of integers.


Cheers

private Map<Integer,Integer[]>  data = new HashMap<Integer,Integer[]>(); // BarDataSet
private Map<String,Long> set1 = new HashMap<String,Long>(10000000); // BarDNA
private HashSet<String> set2 = new HashSet<String>(400); 	// FractalDNA
private Map<String,Long> set3 = new HashMap<String,Long>(400); // Filtered BarDNA
private Multimap<String, Integer> set4 =  ArrayListMultimap.create();	// ZZLeg DNA

Eurusdd turned price moves into strings of 1's (up bar) and 0's (down bar). Then he extracted out "genes" of different length from that sequence of 1's and 0's. That might be every bar (bar 17 18 19 20), every other bar (14 16 18 20), every 3rd bar (11 14 17 20), etc.

		private static int genBarDna(int startOffset,int endOffset){
		//A[c + a * b]
		int seqCount = 0;
		for(int i = STRINGLMIN; i<= STRINGLMAX; i++)	
		{
			int count = 0;
			gui.println(DATEFORMAT.format(new Date()) + " | Start Sequence length " + i);
			for(int c = 0+startOffset; c < externalCount - endOffset; c++)
			{
				// if the last bar lays in the future terminate 
				for(int a = 1; c+a*i < externalCount- endOffset; a++)
				{
					String result = "";
					for(int b = 0; b < i; b++) // b 
					{
						Integer[] temp = dna.get(c+a*b);
						result += temp[0];
					}
					// done;
					if(set1.containsKey(result))
					{
						set1.put(result, set1.get(result)+1);
					}
					else
					{
						set1.put(result,1L);
					}
					count++;
				}
			}
			gui.println(DATEFORMAT.format(new Date()) + " | Sequencing completed ("+i+") " + iFormat(count) + " Sequences generated");
			seqCount += count;
		}
		return seqCount;
	}

* I understand the "every bar" gene, but I really wonder how applicable the "every Nth bar" genes are to current price action. I guess he's trying to pattern-match against higher-TF patterns (if your base TF is M1, then the "every Nth bar" gene sorta gives you a sample from a N-minute TF), but I wouldn't expect them to match very exactly with the bar-by-bar patterns.

* I questioned the use of bars. We don't care about N-minute periods, we care about price movements. gg53 proposed using fractals instead of (or in addition to) bars, which makes a lot more sense to me. He looks at the sequence of fractals that make up a Zig-Zag leg. He's also looking at Range bars or Renko bars, which also makes more sense to me than time-based bars.

* I wouldn't have expected this data-mining and pattern-matching to have much (any?) predictive power. But gg53 and crodzilla are generating some VERY impressive signals at turning points, with two independent implementations. They're often / usually within one bar of the actual ZZ turning point. You could generate some very profitable trades from those signals. That proof-of-concept has kept people interested.

Kilian19 wrote:
I thought about storing those 0 and 1 strings as integer number as well but the problem is that strings exist with multiple leading zero.

0011100
011100
11100

Those all can occur and we can't differentiate them by using simple integer values.

scheinwerfer wrote: At first I had the same fear of multiple zeroes, but I asked Squalou and he said it's not a problem. My testing results showed that it really is not a problem, int array can take multiple zeroes, even though they don't show up on the screen. Later there can be problems with leading zeroes, but one can work around it fairly easily. Ditch the strings, speed impovement will be enourmous!