Changeset 1373


Ignore:
Timestamp:
Apr 30, 2010, 5:43:17 PM (12 years ago)
Author:
Sven Rech
Message:

some msieve modifications

Location:
trunk/CrypPlugins/QuadraticSieve/msieve
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/WrapperTester/Program.cs

    r633 r1373  
    3838            while (running)
    3939            {
    40                     Msieve.msieve.collectRelations(clone, update, core_sieve_fcn);                   
     40                    Msieve.msieve.collectRelations(clone, update, core_sieve_fcn);
    4141                    IntPtr yield = Msieve.msieve.getYield(clone);
     42                    yield = Msieve.msieve.deserializeYield(Msieve.msieve.serializeYield(yield));
    4243                    yieldqueue.Enqueue(yield);
    4344            }
     
    6061            };
    6162            callbacks.prepareSieving = prepareSieving;
     63            callbacks.getTrivialFactorlist = delegate(IntPtr list, IntPtr obj)
     64            {
     65                foreach (Object o in Msieve.msieve.getPrimeFactors(list))
     66                    Console.Out.WriteLine((String)o);
     67                foreach (Object o in Msieve.msieve.getCompositeFactors(list))
     68                    Console.Out.WriteLine((String)o);
     69
     70                list = Msieve.msieve.factor_mpqs(obj, (String)Msieve.msieve.getCompositeFactors(list)[0]);
     71                foreach (Object o in Msieve.msieve.getPrimeFactors(list))
     72                    Console.Out.WriteLine("Prim: " + (String)o);
     73                foreach (Object o in Msieve.msieve.getCompositeFactors(list))
     74                    Console.Out.WriteLine("Composite: " + (String)o);
     75            };
    6276           
    6377            Msieve.msieve.initMsieve(callbacks);
    6478
    6579            //ArrayList factors = Msieve.msieve.factorize("8490874917243147254909119 * 6760598565031862090687387", null);
    66             ArrayList factors = Msieve.msieve.factorize("(2^300-1)/2", null);
     80            Msieve.msieve.start("(2^300-1)/2", null);
    6781            //ArrayList factors = Msieve.msieve.factorize("(2^200 - 1) / 2", null);           
    68             foreach (String str in factors)
    69                 Console.WriteLine(str);
    7082            Console.ReadLine();
    7183        }
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.cpp

    r1372 r1373  
    2323                uint32 *fb_offsets, uint32 num_factors,
    2424                uint32 poly_index, uint32 large_prime1, uint32 large_prime2);
    25 
    2625
    2726//Copy a sieve configuration that can be used in a different thread:
     
    9695        public delegate void showProgressDelegate(IntPtr conf, int num_relations, int max_relations);
    9796        public delegate void prepareSievingDelegate(IntPtr conf, int update, IntPtr core_sieve_fcn);
    98         public delegate void factorListChangedDelegate(IntPtr list);
     97        public delegate void getTrivialFactorlistDelegate(IntPtr list, IntPtr obj);
    9998
    10099        public ref struct callback_struct
     
    103102                showProgressDelegate^ showProgress;
    104103                prepareSievingDelegate^ prepareSieving;
    105                 factorListChangedDelegate^ factorListChanged;
     104                getTrivialFactorlistDelegate^ getTrivialFactorlist;
    106105        };
    107106
     
    149148                }
    150149
    151                 //factorize the number:
    152                 static ArrayList^ factorize(String^ number, String^ savefile)
    153                 {
    154                         ArrayList^ factor_list = gcnew ArrayList;
     150                //start the factorization process:
     151                static void start(String^ number, String^ savefile)
     152                {
    155153                        char* num = stringToCharA(number);     
    156154                        char* save = stringToCharA(savefile);
    157                         msieve_factor* factors = factor(num, save);
    158 
    159                         while (factors != 0)
    160                         {
    161                                 char* f = getNextFactor(&factors);
    162                                 String^ fa = gcnew String(f);
    163                                 free(f);
    164                                 factor_list->Add(fa);
    165                         }
    166 
    167                         free(num);
    168                         return factor_list;
     155                        factor(num, save);
    169156                }
    170157
     
    308295                {
    309296                        relationYield* y = (relationYield*)yield.ToPointer();
    310                         array<unsigned char>^ out = gcnew array<unsigned char>((y->yield_count)*257 + 4);
     297                        array<unsigned char>^ out = gcnew array<unsigned char>((y->yield_count)*949 + 4);
    311298                        copyIntToArray(out, 0, y->yield_count);
    312299
    313300                        for (int c = 0; c < y->yield_count; c++)
    314301                        {
    315                                 out[4 + c*257] = (char)(y->yield_array[c].type);
     302                                out[4 + c*949] = (char)(y->yield_array[c].type);
    316303                                if (y->yield_array[c].type == 1)        //poly
    317304                                {
    318305                                        for (int i = 0; i < 256; i++)
    319                                                 out[4 + c*257 + 1 + i] = y->yield_array[c].polybuf[i];
     306                                                out[4 + c*949 + 1 + i] = y->yield_array[c].polybuf[i];
    320307                                }
    321308                                else                                                            //relation
    322309                                {
    323                                         copyIntToArray(out, 4+c*257 + 1, y->yield_array[c].rel.sieve_offset);
    324                                         copyIntToArray(out, 4+c*257 + 1 + 4, y->yield_array[c].rel.num_factors);
    325                                         copyIntToArray(out, 4+c*257 + 1 + 8, y->yield_array[c].rel.poly_index);
    326                                         copyIntToArray(out, 4+c*257 + 1 + 12, y->yield_array[c].rel.large_prime1);
    327                                         copyIntToArray(out, 4+c*257 + 1 + 16, y->yield_array[c].rel.large_prime2);
     310                                        copyIntToArray(out, 4+c*949 + 1, y->yield_array[c].rel.sieve_offset);
     311                                        copyIntToArray(out, 4+c*949 + 1 + 4, y->yield_array[c].rel.num_factors);
     312                                        copyIntToArray(out, 4+c*949 + 1 + 8, y->yield_array[c].rel.poly_index);
     313                                        copyIntToArray(out, 4+c*949 + 1 + 12, y->yield_array[c].rel.large_prime1);
     314                                        copyIntToArray(out, 4+c*949 + 1 + 16, y->yield_array[c].rel.large_prime2);
    328315                                        for (int i = 0; i < 232; i++)
    329                                                 copyIntToArray(out, 4+c*257 + 1 + 20 + i*4, y->yield_array[c].rel.fb_offsets[i]);
     316                                                copyIntToArray(out, 4+c*949 + 1 + 20 + i*4, y->yield_array[c].rel.fb_offsets[i]);
    330317                                }
    331318                        }
     
    342329                        for (int c = 0; c < y->yield_count; c++)
    343330                        {
    344                                 y->yield_array[c].type = yield[4+c*257];
     331                                y->yield_array[c].type = yield[4+c*949];
    345332                                if (y->yield_array[c].type == 1)        //poly
    346333                                {
    347334                                        for (int i = 0; i < 256; i++)
    348                                                 y->yield_array[c].polybuf[i] = yield[4 + c*257 + 1 + i];
     335                                                y->yield_array[c].polybuf[i] = yield[4 + c*949 + 1 + i];
    349336                                }
    350337                                else                                                            //relation
    351338                                {
    352                                         y->yield_array[c].rel.sieve_offset = getIntFromArray(yield, 4+c*257 + 1);
    353                                         y->yield_array[c].rel.num_factors = getIntFromArray(yield, 4+c*257 + 1 + 4);
    354                                         y->yield_array[c].rel.poly_index = getIntFromArray(yield, 4+c*257 + 1 + 8);
    355                                         y->yield_array[c].rel.large_prime1 = getIntFromArray(yield, 4+c*257 + 1 + 12);
    356                                         y->yield_array[c].rel.large_prime2 = getIntFromArray(yield, 4+c*257 + 1 + 16);
     339                                        y->yield_array[c].rel.sieve_offset = getIntFromArray(yield, 4+c*949 + 1);
     340                                        y->yield_array[c].rel.num_factors = getIntFromArray(yield, 4+c*949 + 1 + 4);
     341                                        y->yield_array[c].rel.poly_index = getIntFromArray(yield, 4+c*949 + 1 + 8);
     342                                        y->yield_array[c].rel.large_prime1 = getIntFromArray(yield, 4+c*949 + 1 + 12);
     343                                        y->yield_array[c].rel.large_prime2 = getIntFromArray(yield, 4+c*949 + 1 + 16);
     344                                        y->yield_array[c].rel.fb_offsets = (uint32*)malloc(sizeof(uint32) * 232);
    357345                                        for (int i = 0; i < 232; i++)
    358                                                 y->yield_array[c].rel.fb_offsets[i] = getIntFromArray(yield, 4+c*257 + 1 + 20 + i*4);
     346                                                y->yield_array[c].rel.fb_offsets[i] = getIntFromArray(yield, 4+c*949 + 1 + 20 + i*4);
    359347                                }
    360348                        }
    361349                       
    362350                        return IntPtr((void*)y);
     351                }
     352
     353                static IntPtr factor_mpqs(IntPtr obj, String^ n)
     354                {
     355                        mp_t N;
     356                        evaluate_expression(stringToCharA(n), &N);
     357                        factor_list_t* factor_list = new factor_list_t;
     358                        factor_list_init(factor_list);
     359                        ::factor_mpqs((msieve_obj*)obj.ToPointer(), &N, factor_list);
     360                        return IntPtr(factor_list);
    363361                }
    364362        };
     
    381379}
    382380
    383 extern "C" void factor_list_changed(factor_list_t * factor_list)
     381extern "C" void get_trivial_factorlist(factor_list_t * factor_list, msieve_obj *obj)
    384382{
    385         Msieve::msieve::callbacks->factorListChanged(IntPtr(factor_list));
    386 }
     383        Msieve::msieve::callbacks->getTrivialFactorlist(IntPtr(factor_list), IntPtr(obj));
     384}
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.h

    r1372 r1373  
    11#pragma once
    2 
    3 //#include <common.h>
    42
    53void showProgress(void* conf, int num_relations, int max_relations);
    64void prepare_sieving(void* conf, int update, void* core_sieve_fcn);
    75void throwException(char* message);
    8 //void factor_list_changed(factor_list_t * factor_list);
    96
    107struct relation
  • trunk/CrypPlugins/QuadraticSieve/msieve/common/driver.c

    r1372 r1373  
    134134
    135135        /* Beyond this point we use the heavy artillery. */
    136         return factor_mpqs(obj, n, factor_list);
     136        //return factor_mpqs(obj, n, factor_list);
     137        get_trivial_factorlist(factor_list, obj);
    137138}
    138139
     
    528529        if (!mp_is_zero(new_factor) && !mp_is_one(new_factor))
    529530                factor_list_add_core(obj, list, new_factor);
    530 
    531 
    532         factor_list_changed(list);
     531       
    533532        return factor_list_max_composite(list);
    534533}
Note: See TracChangeset for help on using the changeset viewer.