GENETIC SEQUENCE BINARY FACTOR GROUPING ROUTINES

THE GENETIC SEQUENCE BINARY FACTOR GROUPING ROUTINES

The relation between the time of creation and the time of the life of the creation is nothing
but the borderline between the human truth about the creation
and the nature of the creation ...

The Genetic sequence binary factor grouping is a set of routines that computes V3 CEL scan data producing catalogue(s) of genetic sequence data , for the purpose of genetic analysis , generating large catalogues of genetic sequence families of curves .
(above partial display of groups of curves extracted from lung cancer datasets - lung normal )

Above :
(1) permutations count - single permutation group ,
(2) 4 cell line scans (19 scans) , single permutation group
(3) scan file values merit factor curve , single permutation group permutations chart , single permutation chart

Genes were referenced by scan measured values number serie merits ( M.J.E. Golay (1902-1989) from The Merit Factor Problem by Jedwab at http://www.math.sfu.ca/~jed/Research/merit.html ) .

Chart from CL2002042639AACEL_merits_x32x16x8x4x2x1_b16d_41.ods column A contains number scale , sorted column B contains numbers merits as computed from CL2002042639AA.CEL .
Merit factor values were computed with b16d_41.cpp from CL2002042639AA.CEL .

Binary factor grouping merits : (example bellow computed by principia routine binary_factor_number_merit_scale_routine.cpp) and permutation chart from CL2001032255AA.CEL

* Upper charts computed by binary_factor_number_merit_scale_routine_1.cpp

Binary factor grouping merits computed with binary_factor_number_merit_scale_routine_b1.cpp (upper charts top to bottom) :
(1) text file example (computer log)
(2) wav file (voice recording)
(3) single probe scan .CEL file
(4) merit values chart
(5) scan CEL file mean column values chart

* All following results computed with b16d_41.cpp
Gene annotations were queried by accession numbers by http://genecards.weizmann.ac.il/cgi-bin/geneannot/GA_search.pl
NCBI gi numbers were queried by gene annotations by http://www.ncbi.nlm.nih.gov/nuccore?term=SMAD4 using an automated PHP script url_get.txt .

Factor grouping permutation chart derived by a31_t.cpp and chart values linear crossection used for number range(s) selection .

()Title : Lung adenocarcinoma ADENO_1 chart in adeno1_res_20110224.ods

Ref: PMCID: PMC2538683 , NIHMSID: NIHMS52941:
Characterizing the cancer genome in lung adenocarcinoma Nature 450,893-898 (06 December 2007)

()Title : Lung adenocarcinoma ADENO_7 chart in adeno7_res_20110224.ods

Ref: PMCID: PMC2953495
Expression of Conjoined Genes: Another Mechanism for Gene Regulation in Eukaryotes Published online 2010 October 12. - 10.1371/journal.pone.0013284

Ref: PMCID: PMC2953495
Targeted Proteomic Analysis of 14-3-3, a p53 Effector Commonly Silenced in Cancer Published on March 18, 2005, doi: 10.1074/mcp.M500021-MCP200

Ref: PMID: 12750859
DNA sequence variation and molecular genotyping of natural killer leukocyte immunoglobulin-like receptor, LILRA3 Immunogenetics. 2003 Jun;55(3):165-71. Epub 2003 May 16.

And this is a novel gene found on 14.12.2011 in the described region :
LOC100653070 leukocyte immunoglobulin-like receptor subfamily A member 3-like [ Homo sapiens ]

Leukocyte immunoglobulin-like receptor, subfamily A (with TM domain), member 6 [Homo sapiens]

gi|341914911| 906 bp mRNA
BASE COUNT 167 a 302 c 249 g 188 t
ORIGIN

1 caggtggcat ttgatggctt cattctgtgt aaggaaggag aagatgaaca cccacaatgc

61 ctgaactccc attcccatgc ccgtgggtca tcccgggcca tcttctccgt gggccccgtg

121 agcccaagtc gcaggtggtc gtacaggtgc tatggttatg actcgcgcgc tccctatgtg

181 tggtctctac ccagtgatct cctggggctc ctggtcccag gtgtttctaa gaagccatca

241 ctctcagtgc agccgggtcc tgtcgtggcc cctggggaga agctgacctt ccagtgtggc

301 tctgatgccg gctacgacag atttgttctg tacaaggagt ggggacgtga cttcctccag

361 cgccctggcc ggcagcccca ggctgggctc tcccaggcca acttcaccct gggccctgtg

421 agccgctcct acgggggcca gtacacatgc tccggtgcat acaacctctc ctccgagtgg

481 tcggccccca gcgaccccct ggacatcctg atcacaggac agatccgtgc cagacccttc

541 ctctccgtgc ggccgggccc cacagtggcc tcaggagaga acgtgaccct gctgtgtcag

601 tcacagggag ggatgcacac tttccttttg accaaggagg gggcagctga ttccccgctg

661 cgtctaaaat caaagcgcca atctcataag taccaggctg aattccccat gagtcctgtg

721 acctcggccc acgcggggac ctacaggtgc tacggctcac tcagctccaa cccctacctg

781 ctgactcacc ccagtgaccc cctggagctc gtggtctcag gtgagggccc tgaccctgtc

841 ctctctgagc tcaaaggctc agctcaggcc ctgcccccag cagagctctg ggacaataat

901 gaatga

Where the following GTGCAGCCGGGTCCTGTCGTGGCCCCTGGGGAGAAGCTGACCTTCCAGTGTGGCTCTGATGCCGGCTACG sequence results in :

ref|XM_003403848.1| Gene info linked to XM_003403848.1
Genome view with mapviewer linked to XM_003403848.1 PREDICTED:
Homo sapiens leukocyte immunoglobulin-like receptor subfamily A member 3-like (LOC100653070), partial mRNA Length=906

GENE ID: 100653070 LOC100653070 leukocyte immunoglobulin-like receptor subfamily A member 3-like [Homo sapiens]
And :
ref|NM_001080978.2 Gene info linked to NM_001080978.2
Genome view with mapviewer linked to NM_001080978.2 Homo sapiens leukocyte immunoglobulin-like receptor, subfamily B (with TM and ITIM domains), member 2 (LILRB2), transcript variant 2, mRNA Length=2937

GENE ID: 10288 LILRB2 | leukocyte immunoglobulin-like receptor, subfamily B (with TM and ITIM domains), member 2 [Homo sapiens]

Where the bold marked sequence results in:
ref|NR_034098.1| Gene info linked to NR_034098.1
Genome view with mapviewer linked to NR_034098.1
Homo sapiens echinoderm microtubule associated protein like 2 (EML2), transcript variant 4, non-coding RNA Length=1995

GENE ID: 24139 EML2 | echinoderm microtubule associated protein like 2 [Homo sapiens]
And :
ref|NM_014971.1| Gene info linked to NM_014971.1
Genome view with mapviewer linked to NM_014971.1
Homo sapiens EFR3 homolog B (S. cerevisiae) (EFR3B), mRNA Length=7500

GENE ID: 22979 EFR3B | EFR3 homolog B (S. cerevisiae) [Homo sapiens]

()Title : Lung adenocarcinoma ADENO_1 chart in adeno1_res_20110224.ods
()Title : Lung adenocarcinoma ADENO_2 chart in adeno2_res_20110224.ods
()Title : Lung adenocarcinoma ADENO_3 chart in adeno3_res_20110224.ods
()Title : Lung adenocarcinoma ADENO_4 chart in adeno4_res_20110224.ods
()Title : Lung adenocarcinoma ADENO_5 chart in adeno5_res_20110224.ods
()Title : Lung adenocarcinoma ADENO_6 chart in adeno6_res_20110224.ods
()Title : Lung adenocarcinoma ADENO_7 chart in adeno7_res_20110224.ods
()Title : Lung adenocarcinoma ADENO_8 chart in adeno8_res_20110224.ods
()Title : Lung adenocarcinoma ADENO_9 chart in adeno9_res_20110225.ods
()Title : Lung adenocarcinoma ADENO_10 chart in adeno10_res_20110225.ods
()Title : Lung adenocarcinoma ADENO_1-10 chart in adeno_1-10_20110516.ods .
()Title : Prostate tumor Prostate Tumor Sample CEL files T01-T30 and T31-T60 chart in pc_20110517.ods .
()Title : Haining Lab : Human Naive and Memory T cell Subsets chart 90 probes in tmap_1-90_20110329.ods .
()Title : Gene expression-based chemical genomics identifies rapamycin as a modulator of MCL-1 and glucocorticoid resistance in leukemia 29 probes results chart in armstrong_part_20110721_1.ods .
()Title : Gene Expression-Based Classification and Outcome Prediction of Central Nervous System Embryonal Tumors PT_SCANS_1 chart in pt1_20110305.ods .

Blast (www.ncbi.nih.gov) searches produce long genomic regions and numerous unmapped sequences .
Analysis of fasta coded genomic regions may get easier by searches based on single sequence permutations .
Determining typical sequences in a long genimic region results in numerous SNP s .
num_c_perm_2_fasta.cpp is locating long permuting sequences in a fasta coded genomic region .
Two runs (eg: num_c_perm_2_fasta LOC100653050.txt c > a.txt and num_c_perm_2_fasta LOC100653050.txt d > b.txt) would output
permutation index arrays and fasta enumerated groups at the top of the output list .
The permutation index array appearing on the end of the output list requires inserting in a document calc utility and producing
a four column line chart . (Bellow) Line chart describing permutation groups , red and blue line out of sorted columns A and B , yellow line frequency count .

The permutation index array appearing at the beggining of the output list may be searched for composite index sequences .
Their line numbers would reference corresponding fasta sequences in the line enumerated fasta array .
Although having same index sequence numbers they will reference permutated fasta sequences .

17 CCTGGGGCTC
18 CTGGTCCCAGGT
19 GTTTCTAAGAAG
20 CCATCACTCTCA
21 GTGCAGCCGGGT

Further analysis would require Blast (www.ncbi.nih.gov) searches having these fasta sequences as input .

Above mRNA data was published by the Cancer Program Datasets title at www.broadinstitute.org .
Subsequent computations were motivated by the article (published by www.ncbi.nih.gov) :

On the complexity measures of genetic sequences.

Gusev VD, Nemytikova LA, Chuzhanova NA.

Institute of Mathematics, Siberian Branch of Russian Academy of Science, Novosibirsk, Russia. gusev@math.nsc.ru

MOTIVATION: It is well known that the regulatory regions of genomes are highly repetitive. They are rich in direct, symmetric and complemented repeats, and there is no doubt about the functional significance of these repeats. Among known measures of complexity, the Ziv-Lempel complexity measure reflects most adequately repeats occurring in the text. But this measure does not take into account isomorphic repeats. By isomorphic repeats we mean fragments that are identical (or symmetric) modulo some permutation of the alphabet letters(.). RESULTS: In this paper, two complexity measures of symbolic sequences are proposed that generalize the Ziv-Lempel complexity measure by taking into account any isomorphic repeats in the text (rather than just direct repeats as in Ziv-Lempel). The first of them, the complexity vector, is designed for small alphabets such as the alphabet of nucleotides. The second is based on a search for the longest isomorphic fragment in the history of sequence synthesis and can be used for alphabets of arbitrary cardinality(..). These measures have been used for recognition of structural regularities in DNA sequences. Some interesting structures related to the regulatory region of the human growth hormone are reported.

(.)marked by this author

Routine sources are included in genetic_sequence_binary_factor_grouping.zip ( at 20.12.2010 ) in the following execution order : genetic_sequence_binary_factor_grouping.txt

These routines use a permuted number index order based on a merit factor attributed number scale .
The merit factor attributed number scale is computed using scan numbers as 4x4bit binary factor indexes in an 16bit integer array .
The exponents of array sub group counts and corresponding factor sums in relation to actual number serie factor bounds produce the merit factor number attributes .
All computed data and corresponding sequences depend on multiplier values .
Multiplier values determine and abstract ranges and contents of the permutation groups .

(!) mar79_5.cpp ( 28.06.2011 ) is the practical implementation of compression .

To Borce Dzinleski

These routines were written by Dzinleski Jasenko jasenko@unet.com.mk who is the author of C/C++ based routines for encryption/decryption, large numbers operations, the 123SQL database engine and the simplified mariaBasic interpreter which are undergoing projects . This project is self-financing and any contributions are welcomed .

This site resulted in years long support from Borce and Dusica Dzinleski and is devoted to them and especially to my daughter Maria Dzinleska and the faith from Nada Popstefanova .The author is currently seeking for a developers job and this is his cv.

References(1)
GINN AND COMPANY
A Xerox Company
Waltham Massachussets - Toronto - London

TOPICS IN ALGEBRA

I.N.HERSTEIN

Lemma 2.22 Every permutation is the product of its cycles .

References(2)
THE MERIT FACTOR PROBLEM

PETER BORWEIN, RON FERGUSON, AND JOSHUA KNAUER

Abstract

The merit factor problem is of considerable practical interest
to communications engineers and theoretical interest to number theorists.
For binary sequences, although it is generally believed that the merit factor
is bounded, it still has not been completely established that the number
of even length Barker sequences, each with merit factor N, is bounded.
In this paper, we present an overview of the problem and results of quite
extensive searches we have conducted in lengths up to slightly beyond 200.

The merit factor, F, of the sequence relates energy in the sidelobes to energy in the main lobe, F = N2 / 2E

References(3)
Discrete Applied Mathematics 155 (2007) 831 ? 839
Binary templates for comma-free DNA codes from Oliver D. King , Philippe Gaborit :

Abstract

Arita and Kobayashi proposed a method for constructing comma-free DNA codes using binary templates, and showed that the
separation d of any such binary template of length n satisfies d>=n/2. Kobayashi, Kondo and Arita later produced an infinite family
of binary templates with d>=11n/30. Here we demonstrate the existence of an infinite family of binary templates with d>=n/2 -
(18n loge n)1/2.We also give an explicit construction for an infinite family of binary templates with d>=n/2 - 19n1/2 loge n.

© 2006 Elsevier B.V. All rights reserved.

References(4)
In DNA Sequence Design Using Template © Omsha,Ltd.2002 , By Masanori Arita and Satoshi Kobayashi , published by SpringerLink (15 Febrruary 2002) , and - This paper has been selected to receive the New Generation Computing Award for Distingushed Papers - the authors state :

Abstract

Sequence design is a crucial problem in information-based
biotechnology such as DNA-based computation . We introduce a simple strategy
named template method that sistematically generate a set of sequences
of length l such that any of its member will have approximatively 1/3 mismatches
with other sequences , their complements , and the overlaps of their
concatenations .

References(5)
Proc. of The Fifth Int. Workshop on Frontiers in Evolutionary Algorithms (FEA 2003) under JCIS 2003 Cary, NC, USA, September 26-30, 2003

Reliable Cost Predictions for Finding Optimal Solutions to
LABS Problem: Evolutionary and Alternative Algorithms

Franc Brglez1, Xiao Yu Li1, Matthias F. Stallmann1 and Burkhard Militzer2
1Computer Science Department, NC State University, Raleigh, NC 27695, USA
2Lawrence Livermore National Laboratory, Livermore, CA 94550, USA

ABSTRACT

The low-autocorrelation binary sequence (LABS) problem
represents a major challenge to all search algorithms, with
the evolutionary algorithms claiming the best results so far.
However, the termination criteria for these types of stochastic
algorithms are not well-defined and no claims have been
made about optimality. Our approach to find the optima of
the LABS problem is based on (1) experiments with problem
sizes for which optimal solutions are known, (2) an asymptotic
analysis of statistics generated by such experiments, (3)
reliable predictions of the cost required to find optimal solutions
for larger problem sizes. The proposed methodology
provides a well-defined termination criterion for evolutionary
and alternative search algorithms alike.
Keywords: fundamental combinatorial algorithms, performance
predictions and evaluations, low-autocorrelation binary
sequence, evolutionary algorithms

IMPLEMENTATION


RIFF(WAV) COMPRESSION (principia example) This is a binary compression implementation on PDA recording device output file (16 bit, 8000 Hz, 128 kbps Wav). This functional example performs looseless wav compression on PDA recording file up to 350 sec. 08.07.2008 VRM 1.0.0 Download File mar70.zip	BYTE ORDER COMPRESSION mdiff and boc routines byte order compression utilization via (re) occuring 2-byte order pairs indexing . This routine processes each data byte and next data byte pair (s) through this C/C++ code ((((b8e&<data byte>)>>1)^((b8e&<next data byte>)>>1))<<1)\|((b8o&<data byte>)^(b8o&<next data byte>)) where b8e is an 8-bit even bit mask and b8o is an 8-bit odd bit mask . Thus 2-byte (s) order (sequence) is truncated into a single byte field . Two byte resultant field (s) consisting of byte 1, byte 2 and byte 2, byte 3 for a single 16-bit dictionary entry . Thus compressed data results in ( (re) occuring entries) index number order . Index entries are bit truncated when written to the compressed data output file . Compression dictionary produced while compressing typical ASCII data file eg source code or HTML code is relatively small and average compression gains in such files are good . 12.09.2008 VRM 1.1.0 Download File e1173.zip
6-bit BINARY COMPRESSION This is a fast compression routine based on a 4-byte data word translation via 6-bit bit parity table . 6 bit table entries were computed by ommitting last two bits (having decimal values 1 and 2) in a single byte (0 to 255) giving 64 index entries combination (s) per data byte . Also all truncation entries from a 4-byte data word have only 256 combination (s) . The 4 6-bit (truncated) dictionary entries are (re) indexed and writen to a compressed data output file in a truncated index number order having (binary) length (s) from 7 to 18 bits compared to the original data 32 bit (word) length . Useful for compressing large document data files (binary and text data documents) . Yet compression gain in ASCII data files is obvious due to short binary length of index number entries . 30.03.2010 VRM 3.5.1 Download File mar6_351_1.zip	BINARY COMPRESSION 79 This a binary compression based on 2-byte data word right (low) bit truncation dependent on max of dictionary (re) occurences for each data buffer . Thus such (truncated) dictionary entries represent most of input data buffer . Dictionary entries are written to the compressed data file in a left truncating manner with the leftmost significant bit ommited , having 7 to 16 bits in length . This method performs fast and efficient data storage . This routine performs principia used in the bellow listed methods . 14.08.2010 VRM 3.1.3 Download File mar79_313_1.zip 18.08.2010 VRM 4.0.1 Download File mar79_401_1.zip 20.08.2010 VRM 4.1.1 Download File mar79_411_1.zip 06.02.2011 VRM 5.0.1 Download File mar79_501_2.zip 16.02.2011 VRM 5.1.0 Download File mar79_510_2.zip 12.06.2011 VRM 5.3.0 Download File mar79_530_1.zip 29.06.2011 VRM 5.3.1 Download File mar79_531_1.zip 15.06.2011 VRM 5.4.0 Download File mar79_540_1.zip 25.06.2011 VRM 5.4.1 Download File mar79_541_1.zip 15.07.2011 VRM 5.4.3 Download File mar79_543_1.zip 15.07.2011 VRM 5.3.3 Download File mar79_533_1.zip mls_13 is a file packager usefull in conjunction with mar79_510_1 To create a filesystems subtree archive : mls_13 -c (source) drive:\path...\ To restore an mls_A11.mar archive : mls_13 -r (target) drive:\path...\ 29.11.2011 VRM 1.4.0 Download File mls_14.zip
BINARY TEXT COMPRESSION This is a fast and efficient compression example that executes fast input data indexing and dictionary occurrence search based on binary 4x4-bit long data samples . Indexed sequences are checked vs variable data length buffer . Thus this compression method gains speed concerning strict 4x4(16) - bit long dictionary patterns . This routine is subject of further development . 04.09.2007 VRM 1.3.3 Download File mar9.zip	BINARY COMPRESSION ROUTINE Binary compression methods are widely used in communications, data storage and numeric analysis. Exploring genetic complexity numeric sequences employ such methods. Some of them are presented on this site together with a command-line Win32 implementation (s) that demonstrates the capability of compression of large ASCII data files and binary files and also slightly modified in numeric data sequence analysis. This binary compression method is based on numeric sequence generated by the following binary formula as presented by the C/C++ syntax: #define op_7(x,y)(((x+y)^y)\|(((x&y)!=0)?(x&y)/y:0)) . This numeric sequence represents all numbers from 0-255(8-bit) for 0-127(7-bit) arguments in an x-y matrix manner . When always x=y and x:0-127 it results in all 8-bit odd numbers . When applied on a 2-byte data sequence it results in 14 or less bits long index . Combined together with one 1-bit substract indicator it will allow compression . Using these arguments as dictionary entries coded by hi/lo/length indicators whose reocurring indexes are stored instead of the input data allows gain of an average 30% compression in large ASCII text files . This numeric sequence formula was generated by another routine written for the purpose of exploring numeric sequences generation .This is an compression Win32 command-line tool based on binary compression . This example states the speed and efficiency of this static large ASCII files compression method . 04.09.2007 VRM 1.3.3 Download File mar.zip
BINARY COMPRESSION 77 This is a binary compression based on 2-byte long data binary shifting concatenation (bit density increase) into dictionary entries that are left truncated (common in ASCII data text files) . Compression gain depends on data redundancy in an inverse meaning . The larger the enthropy compression will increase . 04.06.2008 VRM 1.1.0 Download File mar77.zip	BINARY FACTOR GROUPING COMPRESSION ROUTINE This compression example uses binary pattern indexing by 2-byte sequence bit truncation from 16-12 bits in order to gain max of dictionary occurrence . This compression method is a compression gain vs unoptimized compression speed compromise . This example states the correctness of the genetic text complexity display routine since its dictionary covers most of the numeric sequences occurrence . Yet this compression example is subject of further development . 21.09.2007 VRM 1.4.0 Download File mar73.zip
ASCII TEXT FILE FAST SORT/INDEXING Routine This is a fast sorting/indexing example that builds a file position sorting tree as a result of n-depth text file line byte sorting . The sorted sequence tree may expand to further depth levels , this routine uses default depth 6. It exibits fast sorting of a text file up to the size 100K lines/rows . E.g.: C:\msort3 -f "War and Peace NT.txt" 30.10.2007 VRM 1.3.1 Download File msort3.zip	MCALC Simple Calc routine This is a simple CALC screen routine . The -d2 or -d4 or -d6 command line switch stands for number of decimal places . Keyboard input exit char is q and reset char is c . 09.10.2009 VRM 1.0.1 Download File mcalc.zip
MDUMP ASCII Text File Sequence Redundance Dump This is a ASCII text file dump method that finds text data sequences inside a ASCII text file . Usefull for creating text file data sentence definition (s) . 18.09.2009 VRM 2.0.1 Download File mdump3.zip	MDADD STRING DATE ADD This is a string date add routine that computes add of start date with increment in days, months and (or) years . Comand line switches requires the start date string, increment string input together with a date formating string eg mdadd 20081008 00010000 YYYYMMDD (for adding 1 year) . 16.11.2008 VRM 1.1.1 Download File mdadd.zip
MDDIFF STRING DATE DIFFERENCE This is a string date difference routine that computes difference between two date strings in days, months and years . Comand line switches require two date (s) string input together with a date formating string eg mddiff 19591117 20081008 YYYYMMDD . 08.10.2008 VRM 1.1.0 Download File mddiff.zip	MDIFF FILE COMPARE This is a file compare routine based on a bit parity comparisson of 2-byte sequences . Hashing was built on sequenced use of this C/C++ code ((((b8e&<data byte>)>>1)^((b8e&<next data byte>)>>1))<<1)\|((b8o&<data byte>)^(b8o&<next data byte>)) where b8e is an 8-bit even bit mask and b8o is an 8-bit odd bit mask , examined via byte sequence group (s) count (file 1 vs file 2) compare . Command line requires file 1 name and file 2 name resulting in fast comparrison result message . The -d (detail) switch displays all difference (lines) . Useful for file compare and change tracking in document and source code files . 26.05.2010 VRM 3.0.1 Download File mdiff_301_1.zip
BIT PARITY BYTE ORDER FILE CHECKSUM This is a file fingerprint routine that outputs cheksum number (s) file . Hashing was built on sequenced use of this C/C++ code ((((b8e&<data byte>)>>1)^((b8e&<next data byte>)>>1))<<1)\|((b8o&<data byte>)^(b8o&<next data byte>)) where b8e is an 8-bit even bit mask and b8o is an 8-bit odd bit mask . Sequenced number treshold count was computed with comarisson of original byte (bit parity) result vs generated result . Number point (s) were computed inside a 1024 byte file buffer and stored (XOR op) inside a 512 number sequence consequently . The output fingerprint file numbers state data order and integrity eg when compared vs same file (copy from restore or data transfer) cheksum (s). Command line requires input filename and cheksum output filename . Usefull for building cheksum list (s) of important data archive (s) . 25.03.2009 VRM 1.3.0 Download File bp_boc3.zip Bit parity tools at Brothersoft http://www.brothersoft.com/bit-parity-tools-169821.html 16.07.2011 VRM 5.0.3 Download msearch_141 , mdiff_301 , boc , mar79_543_1 and mls_13 in bp_tools_503_1.zip

THE RANDOM KEYS DISTRIBUTION ENCRYPTION ROUTINE

This is a strong encryption method based on a 4 number keys random number distribution . The 4 (5 - digit) number keys provide strong encryption protection due to message hashing that is provided on random number (s) generation where the inputed keys are used as random seeds . Each user choosen key is randomized and message hash is produced with a different randomizing method . Execution requires usage of the following command line switches:

eg r71 -a 11111 -b 22222 -c 33333 -d 44444 -e < filename to encrypt>
and to decrypt eg r71 -a 11111 -b 22222 -c 33333 -d 44444 -f < filename to decrypt>

where the numbers following the -a -b -c and -d switches are user chosen encryption 5 digit number keys.

1.1(min)... minmv=999; for(l=0;l<rsi;++l) { if(n=0\|\|l==0){n=rs[l][1];continue;} if(n==rs[l][1]\|\|n+1==rs[l][1]\|\|n-1==rs[l][1]){n=rs[l][1];}else{ if(minmv>rs[l][2]){minmv=rs[l][2];minl=l;} n=0; } } if(df){printf(" %d",rs[minl][0]%outm);} htable[hti_dmin][0]=rs[minl][0]%outm;++hti_dmin; ...	1.2(max)... maxmv=0; for(l=0;l<rsi;++l) { if(n=0\|\|l==0){n=rs[l][1];continue;} if(n==rs[l][1]\|\|n+1==rs[l][1]\|\|n-1==rs[l][1]){n=rs[l][1];}else{ if(maxmv<rs[l][2]){maxmv=rs[l][2];maxl=l;} n=0; } } if(df){printf(" %d",rs[maxl][0]%outm);} htable[hti_dmax][1]=rs[maxl][0]%outm;++hti_dmax; ...
2.1(min)... minmv=999; for(l=0;l<rsi;++l) { if(n=0\|\|l==0){n=rs[l][1];continue;} if(n==rs[l][1]\|\|n+1==rs[l][1]\|\|n-1==rs[l][1]) { n=rs[l][1]; if(minmv>rs[l][2]){minmv=rs[l][2];minl=l;} }else{n=0;} } if(df){printf(" %d",rs[minl][0]%outm);} htable[hti_rmin][3]=rs[minl][0]%outm;++hti_rmin; ...	2.2(max)... maxmv=0; for(l=0;l<rsi;++l) { if(n=0\|\|l==0){n=rs[l][1];continue;} if(n==rs[l][1]\|\|n+1==rs[l][1]\|\|n-1==rs[l][1]) { n=rs[l][1]; if(maxmv<rs[l][2]){maxmv=rs[l][2];maxl=l;} }else{n=0;} } if(df){printf(" %d",rs[maxl][0]%outm);} htable[hti_rmax][3]=rs[maxl][0]%outm;++hti_rmax; ...

(1) Each of the entered key numbers resultant distribution series (3-133)*(3-7) according to these criteria are written in a 4 column table
(2) Each table is hashed according the bellow listed binary criteria
(3) The 4 resulting tables are then re-hashed using the same binary criteria.

One out of the 4 functions running inside this encryption was used in the Game of life using 100x100 cells that outputs the generations data in a graphics BMP file format .
Download a game of life VRM 1.3.1 at 17.07.2007 and it states the diversity of random number distributions produced .

Try looping this encryption in the following way:

Step 1.C:\r7 -a <key1 number> -b <key2 number> -c <key3 number> -d <key4 number> -e "filename.txt"
Step 2.C:\r7 -a <key5 number> -b <key6 number> -c <key7 number> -d <key8 number> -e "previous_output.mar"
...
...
Step n.

and repeat it in the same manner n times until the desired security level is gained .

18.12.2007 VRM 1.3.3 Download File r7.zip

MARIAHASH THE ENCRYPTION ROUTINE

This is a fast encryption routine using proprietary hashing method. Cypher strength depends on a large hashing number and password length . password text must be entered in a password.txt file and should have between 50 and 100 char(s) .This routine was written by the authors wish to try to improve message privacy while sent across the networks .

09.06.2007 VRM 1.3.0 Download File 79923.zip

THE 123SQL DATABASE ENGINE

This is an undergoing project aimed to construct a small portable SQL database engine for PDA's, and this is a functional browsing engine that contains data and sample browsing statements . Data may be imported together with table/column creation . Typically the source data may be spreadsheet column TAB delimited export data . Database/table/column creation may be viewed in the included code following the -c switch . Table names and column names and field byte sizes should be specified, but column/field lengths my also vary in size row by row . The engine performs SQL keyword/syntax checking using the syntax/keywords list files included . Object names check and object attributes read is performed in the system database files named 123SQL_db_1.mar and 123SQL_db_2.mar . Database structure allows multiple object browsing . The sorting/searching routines require low machine resources thus meeting most modern PDA specifications and their sources were also published under different names .
This project was founded on the authors' unique relational database engine structure design . The 123SQL engine requires the following command line syntax:

E.g.: C:\910791 -d "Sample"
for attaching and browsing the included database, where Sample is the database name included . When

E.g.: C:\910791 -c "import_data_file.txt"
the engine will create a database table and table columns as specified in the included create.txt syntax and import the data from the file name specified after the -c switch . Number of column definitions and TAB delimited fields must match, if specified column length is greater than data length space justification will occur . Supported SQL like data browsing syntax is :

{select}

{*|column_name|column_name_1,...column_name_n}

{from}

{table_name|table_name_1,...table_name_n}

[where

|[column_name=string_litteral|column_name>string_litteral|column_name<string_litteral]

|[column_name>string_litteral and column_name<string_litteral]

|[column_name[>|<]string_litteral and column_name=string_litteral]

|[column_name=string_litteral or column_name=string_litteral or column_name=string_litteral]

|[column_name>string_litteral and column_name<string_litteral and column_name=string_litteral]

]

123SQL 15.04.2008 VRM 1.5.0 Download file 123SQL.zip

The MariaBasic Interpreter

The Maria Basic Interpreter is a command-line programming tool - interpreter aimed to help PDA users code formula/calculations, string and file procedures that execute on their handhelds. The included source code may easily (re) compile for various OS/CPU architectures , since it was written in ISO/ANSI C and requres moderate machine resources . Interpreter design allows fast execution of basic syntax like procedures with calculations and file/string operations. Its simplified syntax allows basic programming skills and may be used for learning , but may expand to execution of rather complex routines . This interpreter allows basic like (simplified) syntax commands like nesting, statement loops, and conditional execution. The ZIP archive ready for download includes a few txt files which are sample basic syntax supported nesting and file/string function example (s) . Source procedures may execute with a command line stating:

E.g.: C:\mariaBasic -e "mb_305_sorting_1.txt".
The mb_305_arraylikecount_1.txt and mb_305_sorting_1.txt and dec2bin.txt example sources show the code structure necessary to supply for program execution .Supported routine code syntax is :

MariaBASIC 3.1.0.5 Coding Structure:

1. Coding convention (s)

1.1.Declarations:

<varname> is a <string literal> + <type declaration> = <initial value>

where
<string litteral> = {[_]|[a-z]|[A-Z]|[0-9]}
<type declaration> = {[%]|[&]|[#]|[$]}

where % stands for integer data type
where & stands for long integer data type
where # stands for double data type
where $ stands for char data type with <=256 bytes

<initial value> =
{
[<string constant> is a single quoted literal having [a-z]|[A-Z]|[0-9]]
|
[<num constant> is a number literal having [0-9]|[.]]
}

logical expression operators are [and]|[or]|[xor]
conditional expression operators are [>]|[<]|[=]|[>=]|[<=]|[<>]

1.2.Program body: Declaration(s) | Statement(s) | Logical expression(s) | Simple Block Statement(s) | Nested Statement(s) | End statement

1.2.1.Statement:

varname[%|&|#]=[[varname[%|&|#]|[<num constant>]][^,*,/,+,-][[varname[%|&|#]|[<num constant>]]
varname$=varname$+varname$
varname[%|&]=len$(varname$)
varname[%|&|#]=val$(varname$)
varname$=trim$(varname$)
varname$=left$(varname$,<num constant>)
varname$=right$( varname$,<num constant>)
varname$=mid$( varname$,<num constant>,<num constant>)
varname$=format$(varname+{[%|&|#]},<string constant>)
varname[%|&|#]=round$(varname#)
open varname$ for [input]|[output] as #<num constant>
input #<num constant>, varname$
print #<num constant>, [<string constant>| varname[%|&|#|$][,]][;]
close #<num constant>
print [<string constant>| varname[%|&|#|$][,]][;]

1.2.2.Logical expression:

varname[%|&]=(varname[%|&|#|$][=,<>,>,<,>=,<=]varname[%|&|#|$]
[and]|[or]|[xor]
[ varname[%|&|#|$][=,<>,>,<,>=,<=]varname[%|&|#|$])

1.2.3.Simple Block Statement:

{if (<conditional expression>) then}
<statement(s)>
{end if}
{while (<conditional expression>)}
<statement(s)>
{wend}
{for varname[%|&]=[[<num constant>]| varname[%|&]] to [<num constant>| varname[%|&]]}
<statement(s)>
{next varname[%|&]}

1.2.4.Nested Statement:

{if (<conditional expression>) then}
<statement(s)>
<simple block statement(s)>
{end if}
{while (<conditional expression>)}
<statement(s)>
<simple block statement(s)>
{wend}
{for varname[%|&]=[[<num constant>]| varname[%|&]] to [<num constant>| varname[%|&]]}
<statement(s)>
<simple block statement(s)>
{next varname[%|&]}

1.2.5.Comment(s):
rem <string constant>

1.3. End Statement:
{end}

MariaBasic at Brothersoft.com

MariaBasic, when (re)compiled on PDA's native compiler enables a simple but efficient programming PDA tool.

MariaBASIC for Pocket PC V3.0 (XScale ARM) 29.11.2011 VRM 3.2.1.1 Download file mariaBasic3211_ARM.zip

MariaBASIC 29.11.2011 VRM 3.2.1.1 Download file mariaBasic3211.zip

MariaBASIC (samples) 29.11.2011 VRM 3.2.1.1 Download file mariaBasic3211_samples.zip

rem
rem MariaBASIC
rem DayofWeek Function
rem 3.1.0.7
rem

rem ---------------------
rem start day of year 2011 , Saturday (day 6)
Sd%=5
rem ---------------------

Sdate$='26.04.2011'

Sm002$='0000000000000000000000000000000 '
Sm012$='0000000000000000000000000000000 '
Sml01%=31
Sm022$='0000000000000000000000000000000 '
Sml02%=28
Sm032$='0000000000000000000000000000000 '
Sml03%=31
Sm042$='0000000000000000000000000000000 '
Sml04%=30
Sm052$='0000000000000000000000000000000 '
Sml05%=31
Sm062$='0000000000000000000000000000000 '
Sml06%=30
Sm072$='0000000000000000000000000000000 '
Sml07%=31
Sm082$='0000000000000000000000000000000 '
Sml08%=31
Sm092$='0000000000000000000000000000000 '
Sml09%=30
Sm102$='0000000000000000000000000000000 '
Sml10%=31
Sm112$='0000000000000000000000000000000 '
Sml11%=30
Sm122$='0000000000000000000000000000000 '
Sml12%=31

St0$=''
St1$=''
St2$=''
St3$=''
St5$=' '

V1%=0
V2%=0
V3%=0
Vl%=0
Vm%=1

while (Vm%<=12)

rem ---------------------

if (Vm%=1) then
Vl%=Sml01%+0
rem print 'January'
end if
if (Vm%=2) then
Vl%=Sml02%+0
rem print 'February'
end if
if (Vm%=3) then
Vl%=Sml03%+0
rem print 'March'
end if
if (Vm%=4) then
Vl%=Sml04%+0
rem print 'April'
end if
if (Vm%=5) then
Vl%=Sml05%+0
rem print 'May'
end if
if (Vm%=6) then
Vl%=Sml06%+0
rem print 'June'
end if
if (Vm%=7) then
Vl%=Sml07%+0
rem print 'July'
end if
if (Vm%=8) then
Vl%=Sml08%+0
rem print 'August'
end if
if (Vm%=9) then
Vl%=Sml09%+0
rem print 'September'
end if
if (Vm%=10) then
Vl%=Sml10%+0
rem print 'October'
end if
if (Vm%=11) then
Vl%=Sml11%+0
rem print 'November'
end if
if (Vm%=12) then
Vl%=Sml12%+0
rem print 'December'
end if

rem ---------------------
rem print Vl%

for V1%=1 to Vl%

Sd%=Sd%+1
St1$=format$(Sd%,'0')
V3%=Vl%-1
St2$=mid$(Sm002$,2,V3%)

if (V1%>1) then

V2%=V1%-1
St1$=mid$(Sm002$,1,V2%)
St3$=format$(Sd%,'0')
St1$=St1$+St3$
V2%=V1%+1
V3%=Vl%-V2%
rem print V2%,' ',V3%
St2$=mid$(Sm002$,V2%,V3%)

end if

St1$=St1$+St2$
Sm002$=''
Sm002$=Sm002$+St1$+St5$
rem print Sm002$

if (Sd%=7) then
Sd%=0
end if

next V1%

rem ---------------------

if (Vm%=1) then
Sm012$=''
Sm012$=Sm012$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm022$
end if
if (Vm%=2) then
Sm022$=''
Sm022$=Sm022$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm032$
end if
if (Vm%=3) then
Sm032$=''
Sm032$=Sm032$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm042$
end if
if (Vm%=4) then
Sm042$=''
Sm042$=Sm042$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm052$
end if
if (Vm%=5) then
Sm052$=''
Sm052$=Sm052$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm062$
end if
if (Vm%=6) then
Sm062$=''
Sm062$=Sm062$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm072$
end if
if (Vm%=7) then
Sm072$=''
Sm072$=Sm072$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm082$
end if
if (Vm%=8) then
Sm082$=''
Sm082$=Sm082$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm092$
end if
if (Vm%=9) then
Sm092$=''
Sm092$=Sm092$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm102$
end if
if (Vm%=10) then
Sm102$=''
Sm102$=Sm102$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm112$
end if
if (Vm%=11) then
Sm112$=''
Sm112$=Sm112$+Sm002$
Sm002$=''
Sm002$=Sm002$+Sm122$
end if
if (Vm%=12) then
Sm122$=''
Sm122$=Sm122$+Sm002$
Sm002$=''
end if

rem ---------------------

Vm%=Vm%+1
wend

rem ---------------------

Sdd$=''
Sdd$=mid$(Sdate$,1,2)
Smm$=''
Smm$=mid$(Sdate$,4,2)
V1%=val$(Smm$)
V2%=val$(Sdd$)

rem ---------------------

if (V1%=1) then
Sm002$=''
Sm002$=Sm002$+Sm012$
end if
if (V1%=2) then
Sm002$=''
Sm002$=Sm002$+Sm022$
end if
if (V1%=3) then
Sm002$=''
Sm002$=Sm002$+Sm032$
end if
if (V1%=4) then
Sm002$=''
Sm002$=Sm002$+Sm042$
end if
if (V1%=5) then
Sm002$=''
Sm002$=Sm002$+Sm052$
end if
if (V1%=6) then
Sm002$=''
Sm002$=Sm002$+Sm062$
end if
if (V1%=7) then
Sm002$=''
Sm002$=Sm002$+Sm072$
end if
if (V1%=8) then
Sm002$=''
Sm002$=Sm002$+Sm082$
end if
if (V1%=9) then
Sm002$=''
Sm002$=Sm002$+Sm092$
end if
if (V1%=10) then
Sm002$=''
Sm002$=Sm002$+Sm102$
end if
if (V1%=11) then
Sm002$=''
Sm002$=Sm002$+Sm112$
end if
if (V1%=12) then
Sm002$=''
Sm002$=Sm002$+Sm122$
end if

rem ---------------------

St$=''
St$=mid$(Sm002$,V2%,1)
V1%=val$(St$)

rem ---------------------

if (V1%=1) then
print Sdate$,' ','Monday
' end if
if (V1%=2) then
print Sdate$,' ','Tuesday'
end if
if (V1%=3) then
print Sdate$,' ','Wednesday'
end if
if (V1%=4) then
print Sdate$,' ','Thursday'
end if
if (V1%=5) then
print Sdate$,' ','Friday'
end if
if (V1%=6) then
print Sdate$,' ','Saturday'
end if
if (V1%=7) then
print Sdate$,' ','Sunday'
end if

rem ---------------------

end

MariaBASIC Number Permutation Cycle Function (ASCII Text Rhymes) output having all 1(s),2(s),...9(s) as input and its C/C++ code (!) num_c_perm.cpp .

rem --------------------
rem MariaBASIC
rem Number Permutation Cycle Function (ASCII Text Rhymes)
rem 3.2.0.3
rem --------------------

Vars1$='1234567890 '
Vars2$=''
Vars3$=''
Vars4$=''
Vars5$=''

rem 1. run Vars6$='1111111111 '

rem run 1. resulting file
011120
058139
012370
038036
013938
028263

rem 2. run arg=011+058+012+0
Vars6$='0110580120 '

rem run 2. resulting file
001106
005786
001231
003785
001387
002812

Vars7$=''
Vars8$=''
Vars9$='n.txt'
Vars10$=''

Vari1%=0
Vari2%=10
Vari3%=0
Vari4%=0
Vari5%=0

Vard1#=0
Vard2#=0
Vard3#=0
Vard4#=0
Vard5#=0
Vard6#=0

rem --------------------
for Vari1%=1 to 9
   Vari3%=Vari2%-Vari1%
   Vars3$=mid$(Vars1$,Vari3%,1)
   Vars4$=mid$(Vars1$,Vari1%,1)
   Vars2$=Vars2$+Vars3$+Vars4$
next Vari1%

print Vars2$

rem --------------------

open Vars9$ for output as #1

VariL%=9
while (VariL%>3)
   Vars5$=''
   for Vari1%=1 to VariL%
      Vari3%=Vari2%-VariL%
      Vars3$=mid$(Vars2$,Vari3%,1)
      Vars4$=mid$(Vars2$,Vari1%,1)
      Vars5$=Vars5$+Vars3$+Vars4$
   next Vari1%

   if (Vari5%=1) then
      print Vars5$
   end if

   Vars7$=mid$(Vars5$,1,5)

rem --------------------
   Vard5#=val$(Vars7$)
   Vard6#=val$(Vars6$)
rem --------------------

   if (Vari5%=1) then
      print Vard6#,Vard5#
   end if

   Vard1#=Vard6#/Vard5#

   Vars8$=format$(Vard1#,'000000.00')

   print Vars8$

   Vars10$=mid$(Vars8$,1,3)
   print #1,Vars10$;
   Vars10$=mid$(Vars8$,4,3)
   print #1,Vars10$

   VariL%=VariL%-1
wend

end

The Eleven Comedies , an english translation of Aristophanes et al Comedies (from Project Gutenberg eBook)
Part 1 , chart 1 ,

and chart 2 from Part 2 generated by num_c_perm_2.cpp .

War and Peace , an english translation of Tolstoy (from Project Gutenberg eBook) permutation chart generated by num_c_perm_2.cpp .

The Notebooks of Leonardo Da Vinci , an english translation of Leonardo Da Vinci (from Project Gutenberg eBook) permutation chart generated by num_c_perm_2.cpp .

THE FAST (ASCII and Unicode) TEXT FILES SEARCH ROUTINE

This is a fast text search routine that allows single (or quoted composite) string search throughout an ASCII or Unicode text (text containing) file(s) . Unicode search will also allow strings containing mixtures of different Unicode table(s).
E.g.:
1. (ASCII search) msearch3 <ASCII_input_filname.txt> <search_string>
2. (Unicode search) msearch3 <Unicode_input_filname.txt>
(search string in Unicode file uarg.txt and search results in Unicode file ures.txt)

03.07.2008 VRM 1.1.1 Download File msearch3.zip

THE FAST ASCII TEXT FILES SEARCH ROUTINE

This is a fast text search routine that allows multi string (up to 10 search strings containing one or more words within) search throughout an ASCII text file . So, each search string (quoted) may have one or more words. The -s switch allows any match, while the -e switch allows only exact match.
E.g.: C:\msearch -s(-e) "package install"+"media"+"component" -f "FreeBSD Handbook.htm"
E.g.: C:\msearch -s(-e) "network devices installation" -f "FreeBSD Handbook.htm"
E.g.:C:\msearch -s(-e) "trodes in his hands" -f "book_sd.txt"
E.g.:C:\msearch -s(-e) "Bezukhov and Natasha"+"Buonaparte Napoleon"+"Pierre" -f "War_and_Peace_NT.txt"
The program output will display all results along with their line number file positions, the unique and composite sentence search phrase matches together with their total occurrence count.

15.04.2008 VRM 1.3.3 Download File msearch.zip

09.04.2010 VRM 1.4.1 Download File msearch_141_1.zip

THE ASCII TEXT FILES SENTENCE CONTEXT SEARCH ROUTINE

This is a text file complex search routine that allows text search build on the context - sentence words concerning a given subject . This search allows automated search criteria build depending on sentence words contents and user choice . Sentence words files and their sentence links are built during the indexing phase for a given text file . After indexing, the routine will display all sentences for a chosen sentence subject (as enlisted in the words file) and allow detailed context search and all sentences display concerning the chosen context .
For the indexing type:E.g.: C:\dp_13_201_1 -f "War_and_Peace_NT.txt"
For the context search type:E.g.: C:\msearch_141_d_1 -s(e) "Bagration" -f "War_and_Peace_NT.txt"
The -s switch enables any match search when d was chosen, and -e switch enables only exact word match. The included files contain the examples book already indexed. Typically the search word is a name, or a subject that is being often described and attributed in the book text . So after viewing/choosing the desired sentence/search combination all text lines containing the chosen words will be displayed . Thus viewing book contents by desired subject details requires smaller amount of time .

15.04.2008 VRM 1.3.0 Download File r113.zip

28.04.2010 VRM 2.0.1 Download File text_file_context_search_201_1.zip

THE FONT IMAGE RECOGNITION ROUTINE

This routine creates a vector shape sequence file (using -i switch) out of an 100x100 pixels 24 bit colour depth black and white image representing a character true type image (font) or character freehand drawing . Then using the -c switch the two index files derived from two different images are compared and graphics match result is displayed .
For the indexing type:
E.g.: C:\cr13 -i "Drawing1.bmp" "Drawing1_Index.txt"
For the comparison of two different index files type:
E.g.: C:\cr13 -c "Drawing1_Index.txt" "Drawing2_Index.txt"
At present the routine builds shape vectors on black/white bitmaps, it does not support different resolution nor colors/color depth.
But how does it work?

(1) indexing, creates vector txt file (that might be the meta character file) out of the bmp image file in the following manner:
- inverts the b/w file matrix (the way human eye sees it),
- searches for quadrants (10x10 pixels sized) with 40/60% b/w ratio, thus finding character image edges (up to 8 pairs in the same row),
- creates vectors out of each quadrant,
- shifts quadrants by (only) few pixels UP since bmp edges do not always REALLY represent character ID curves, repeating vector creation ...
and
(2) comparison of two vector files:
- shifts back all X-axis values subtracting them by absolute minX value,
- computes curve angles out of each quadrant values,
- computes resultant angles out of quadrant pairs building most real character curves,
- compares the two vector files angle pairs,
- computes match statistics .

This development is aimed for PDA users using easier ways for text input.
To Maria Dzinleska

27.04.2007 VRM 1.0.1 Download File cr13.zip

THE ROUTINE THAT GENERATES THE PRIME NUMBERS KEY PAIR OUT OF THEIR PRODUCT

These routines were written during and for the www.rsa.com prime key numbers context that requires finding the exact prime numbers key pair out of a very large (256,512...1024... bits long) product number. The routines were written in java and use the BIGINTEGER java class in order to compute the prime key pair .The starting point routine finds a prime numbers key pair with product_number_bit_length/2 bit length that give sufficient accuracy (near as far as possible) to the product number, the more the preciseness the more the computing time to spend . So the loop that computes the suggested starting prime number pair is limited with the corresponding number of equal product-target significant digits . The remaining procedures consequently perform a very long (all 1's and trailing ZEROS) 111 ... *10^N substraction (s) from the suggested key pair measuring the distance (difference) from the target product number by subsequent multiplication checks . At the point of diverging found and at a certain preciseness (number of equal significant digits) a new key pair may be generated through the first routine . Than the process has to be repeated while gaining more and more equal product-target significant digits .

23.07.2006 Download File Welcome.zip

How do these computations compute a very similar or near prime key pair out of a large product key?

Exmining the bellow listed mariBasic code and its (partial) output shows a few number products appearing at large division loop distances and having a 0000 period between decimal remainder values . Testing those (listed) numbers might prove that most of them are prime numbers . Testing large (200 decimal or more) product keys in this way would take indefinite time . So, the WelcomeQ routine uses a substraction operation on a proposed prime key pair . The routine that generates prime key pairs that have a given decimal target product number match is based on a binary field seed number modification basing only on target match numbers as match search loop starting point . The substractor (having the (decimal) value of e.g. 1111111111000000000000000) shifts the 1111111111 period to the right by approoving that this way truncated prime key pair product matches more and more decimals to the target product number . Actually there are sets of prime kepairs obtaining a certain decimal match .Usually it is necessay to switch between different pairs in order to increase the decimal match of the product . And that is the main iteration of this method sometimes requiring examining and rejecting large number of prime key pairs in order to gain one or more decimal match more . Gaining a 100 decimals precisenes on a common PC computer thus would not be hard to achieve . These computations generate prime keys having computable decimal match gain or complete product number match compared to a given huge product number .

Brief order and explanation of execution steps:

(1) generate 5 or more (depending on computing resources) decimal match places vs known target number prime key pairs (number of generated pairs also depends on computing resources)

(2) start subtracting by a given number of decimal 1 .... 1x10^X and multiplying each of primes in a key pair observing gain or loss in decimal match at product number vs target number . Observe match gain vs number of 1 ... 1 and X in 10^X in the subtraction factor . Thus prime distribution at that number point becomes visible .

(3) choose a prime probe as a base for generating new sets (depending on computing resources) of prime key pairs gaining usually somewhat less decimal match places at product number vs target number .

(4) iterate through the previos steps seeking a point at the prime distribution which indicates the existence of the absolute match key pair .

var1%=0
var2%=1234567
var3%=0
var5%=2
var6%=0
var7#=0
var8&=0
var9%=0
var10%=10000
var191%=0
var111#=0
var19%=10000
var11%=17317
var123%=91127
var13%=13009
var145%=98017
var15%=12251
var162%=98327
var17%=33757

var3%=var2%/2
while(var5%<var3%)

var7#=var10%*var2%/var5%
var8&=var2%/var5%
var8&=var7#-var8&*var10%

if var8&=0 then

print "=";
print var5%;
print "@";
print var7#;
print " ",var191%
var191%=0+0

end if

var191%=var191%+1
var5%=var5%+1
wend

end

=205759@6.000063e+04 1
=205760@6.000034e+04 1
=205761@6.000005e+04 1
=246909@5.000089e+04 41148
=246910@5.000069e+04 1
=246911@5.000049e+04 1
=246912@5.000028e+04 1
=246913@5.000008e+04 1
=308635@4.000087e+04 61722
=308636@4.000075e+04 1
=308637@4.000062e+04 1
=308638@4.000049e+04 1
=308639@4.000036e+04 1
=308640@4.000023e+04 1
=308641@4.000010e+04 1
=411509@3.000097e+04 102868
=411510@3.000090e+04 1
=411511@3.000083e+04 1
=411512@3.000075e+04 1
=411513@3.000068e+04 1
=411514@3.000061e+04 1
=411515@3.000053e+04 1
=411516@3.000046e+04 1
=411517@3.000039e+04 1
=411518@3.000032e+04 1
=411519@3.000024e+04 1
=411520@3.000017e+04 1
=411521@3.000010e+04 1
=411522@3.000002e+04 1

Dzinleski Jasenko - jasenko@unet.com.mk

Mailing Address:
+38922770296
Dositej Obradovik 15/8
1000 Skopje Republic of Macedonia

(1) All published data, executables and sources from this site described above apply to GNU General Public License and can be used, copied, sold, redistributed or used in any other way only by written permission of Jasenko Dzinleski . Copyright (C) from 2001 - 2011 and later by Jasenko Dzinleski
(2) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version , if not opposite to (1) .
(3) This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU General Public License for more details .
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc ., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA .