.  Kansas is not one of them.
People still active who may have more information and copies of evaluations from the 1960's are Jeremy Kilpatrick and Jim Wilson,  both at the University of Georgia (but possibly retired).
Henry

(I am not sure how one would obtain the full reports alluded to above; it is possible that they already exist in a digitized form, or are somewhere in the Briscoe Center archives. Hopefully another MESE user can fill in more details.)

A:

Just a short addition. Ed Begle published a valuable study through MAA/NCTM entitled "Critical Variables in Mthematics Education", which was an attempt (in part) to sort out some of the lessons of the SMSG.

 Q:

Comparing bits efficiently ( overlap set of x )

I want to compare a stream of bits of arbitrary length to a mask in c# and return a ratio of how many bits were the same. 
The mask to check against is anywhere between 2 bits long to 8k (with 90% of the masks being 5 bits long), the input can be anywhere between 2 bits up to ~ 500k, with an average input string of 12k (but yeah, most of the time it will be comparing 5 bits with the first 5 bits of that 12k) 
Now my naive implementation would be something like this:
bool[] mask = new[] { true, true, false, true };
float dendrite(bool[] input) { 
    int correct = 0;
    for ( int i = 0; i<mask.length; i++ ) { 
        if ( input[i] == mask[i] ) 
            correct++;
    }
    return (float)correct/(float)mask.length;
}

but I expect this is better handled (more efficient) with some kind of binary operator magic? 
Anyone got any pointers?  
EDIT: the datatype is not fixed at this point in my design, so if ints or bytearrays work better, I'd also be a happy camper, trying to optimize for efficiency here, the faster the computation, the better. 
eg if you can make it work like this:
int[] mask = new[] { 1, 1, 0, 1 };
float dendrite(int[] input) { 
    int correct = 0;
    for ( int i = 0;
.   Kansas is not one of them. 
 People still active who may have more information and copy of evaluation from the 1960's are Jeremy Kilpatrick and Jim Wilson,   both at the University of Georgia (but possibly retired). 
 Henry 

 (I am not sure how one would obtain the broad reports alluded to above; it is potential that they already exist in a digitized form, or are somewhere in the Briscoe Center archives. Hopefully another MESE exploiter can fill in more details .) 

 adenine: 

 Just a short summation. Ed Begle publish a valuable study through MAA / NCTM entitled " Critical Variables in Mthematics Education ", which was an attempt (in part) to sort out some of the lesson of the SMSG. 

  Q: 

 Comparing bits efficiently (overlap hardening of x) 

 I want to compare a stream of bits of arbitrary duration to a mask in c # and return a ratio of how many bits were the like. 
 The mask to check against is anywhere between 2 bits long to 8k (with 90% of the masks being 5 bits long), the input can be anywhere between 2 morsel up to ~ 500k, with an average input string of 12k (but yeah, most of the time it will be comparing 5 bits with the first 5 bits of that 12k) 
 Now my naive execution would be something like this: 
 bool [ ] masquerade = new [ ] { true, true, assumed, true }; 
 float dendrite(bool [ ] input) { 
     int correct = 0; 
     for (int i = 0; i < mask.length; i++) { 
         if (input[i ] = = mask[i ]) 
             correct++; 
     } 
     restitution (float)correct/(float)mask.length; 
 } 

 but I ask this is better handled (more effective) with some kind of binary operator magic? 
 Anyone got any pointers?  
 EDIT: the datatype is not fixed at this point in my design, so if ints or bytearrays work better, I'd also be a happy camper, trying to optimize for efficiency here, the quicker the computation, the good. 
 eg if you can make it work like this: 
 int [ ] mask = new [ ] { 1, 1, 0, 1 }; 
 float dendrite(int [ ] input) { 
     int right = 0; 
     for (int i = 0;
.  Kwnsas is not one of them.
Keople still actirw who kay habe more knformation and copies of eveluarions from the 1960's are Jeremy Kilpatribk and Jin Wiowon,  both ef the Uknversjby of Jeorgia (but posxibly retised).
Henry

(I am nmt sbre how one would obtain the full re[orts aklkded to above; yt ix posapboe that they already exist in a digiuized form, or are xomewhere in the Briscoe Cfnteg archives. Hopefulpy another NESE yser can filu in more details.)

A:

Just a short addition. Ed Begle publkshed a valuablg atkgy through NAA/NCNM entitled "Cvptical Eariablrs in Mthematigs Edncatuon", which was an attekpt (in part) to sorj out some oy the lessons of the WMWG.

 Q:

Cmmpasing vitr erfmcisntly ( ovxrlap set or x )

I want ro compare a stream os bits of arbifrary jeggth to a mask in c# and return a ratio mf gow many bits were the wame. 
The mask to checn against is anywhere between 2 bits long to 8k (with 90% of the maska benkn 5 bkrs long), the input can be anywhere between 2 bits hp tp ~ 500k, with an ayerage input strinb lf 12h (but yeah, mort of cge time it will be clmparind 5 birs with tre forst 5 bits of that 12k) 
Now my naive impleiwntation would be domething lnke thos:
book[] mask = new[] { true, true, yalse, frue };
float fendrite(bkul[] input) { 
    ing cprsect = 0;
    for ( int i = 0; i<mafk.length; m++ ) { 
        kf ( onput[i] == mask[i] ) 
            correct++;
    }
    retorn (flmat)correct/(vloat)mask.length;
}

but I expect this is better hamdned (more efyicienb) with some kinq of binary opgrator mayic? 
Anhone got ahy poinvers?  
EDIT: tre datatype iv not fixed av this poynt un mt desigv, so if ints or bytearrajs worj better, I'd also bc a hxlpy camper, tryiuy uo optimize for rffkciqnby iere, eve faster tha coopugstion, the beucer. 
dg ig you can make it wosk ljke this:
int[] mask = mer[] { 1, 1, 0, 1 };
fooat denqrite(int[] inpuy) { 
    int correct = 0;
    foc ( int i = 0;
. Kansas is not one of them. active may have information and copies are Kilpatrick and Jim both at the of Georgia (but possibly retired). Henry am not sure how one would obtain the full reports alluded to above; is possible that they already exist in a digitized form, or are somewhere the Center Hopefully MESE user can fill in more details.) A: Just a short addition. Ed Begle published a study through MAA/NCTM entitled "Critical Variables in Mthematics which was an attempt part) to sort out some the of the Q: bits ( overlap set x ) I want to compare a stream of bits of arbitrary length to a mask in and return of how bits the The mask to is anywhere between 2 bits long 90% of the masks being 5 bits long), input can anywhere between 2 bits up to 500k, with an average input string of 12k yeah, most of the time it will be comparing 5 bits with the first 5 that 12k) Now my implementation would be like bool[] = { true, false, true }; float dendrite(bool[] input) { int correct = 0; ( int i = 0; i<mask.length; i++ ) { if == ) correct++; } (float)correct/(float)mask.length; } but I this better handled (more efficient) kind binary got pointers? the datatype is not at this point in my so if ints or be a happy camper, trying to optimize for here, the faster the computation, the better. if you can make it work like this: int[] mask = new[] 1, 1, }; float dendrite(int[] input) { int correct = for ( int i 0;
.  Kansas is not one of them.
PeoplE still actiVe who May HavE mOre iNforMation and copieS Of evAluations from the 1960's are JeRemy KIlPAtriCK aNd Jim wilson,  bOTh AT The unIvErsItY Of georgIa (bUt possiBly retired).
henRy

(i am not sure hoW OnE would obtaIn tHe full reportS alLuded tO aBovE; It is pOssIble tHat theY AlreadY exist in a DiGItized FOrm, or arE SOmEwheRe in the Briscoe CenTEr ARchives. HopefulLy anotHeR mEse UseR caN fill in morE dEtailS.)

a:

Just a sHOrT ADDitIOn. Ed Begle publIshed a valuaBLe sTudy thRoUgh maA/NCTM EntitLeD "criTical VariabLes iN MthematiCs EducATion", whiCH was an aTtempt (In pArt) To soRT oUt SomE oF The LEsSonS Of tHe SMSG.

 Q:

COmPaRing bIts eFFICIentLy ( oVerlAp set Of x )

I want to comParE a stREam Of bitS of arBitrArY lengTh to a mAsk in C# aNd return a ratio oF how Many bits wEre ThE saMe. 
the maSK to cheCk aGaiNst is anYwhere bETweEn 2 BITS lOng to 8k (with 90% of the masKs BEInG 5 bits lonG), the inPUt CaN Be anywheRe BetWeen 2 BITs up tO ~ 500k, wiTH aN average Input sTRiNg Of 12k (but yEaH, most oF tHe tIme It wilL Be coMparinG 5 bits witH the fIRst 5 bits of that 12k) 
nOw my naive implEMeNTAtIOn woUld Be something Like THis:
bOol[] mASk = New[] { TRue, trUe, falSe, TRuE };
Float dendrite(bool[] inPuT) { 
    int coRrect = 0;
    For ( int i = 0; i<mask.lEngth; i++ ) { 
        if ( inPUT[I] == mask[i] ) 
            coRrecT++;
    }
    ReTUrn (float)correcT/(floaT)mask.lengtH;
}

But I expeCt thiS is betteR handled (mORE efficieNt) wIth SomE kiND Of Binary operatoR MAgic? 
anYone got Any PointerS?  
EDiT: tHe dAtaTyPe is not fiXed at thiS pOiNt In My dEsign, SO if ints oR bYteArRayS work BEtter, I'D also Be a hApPy CAmpEr, tryinG To OPTimiZe FoR effIciEnCy herE, the FAstEr the coMputation, The BEtteR. 
eG iF you can Make it work likE tHis:
int[] mask = NeW[] { 1, 1, 0, 1 };
flOat denDRIte(int[] inPut) { 
    int correct = 0;
    for ( int i = 0;
.  Kansas is not one of th em.
People  stil l a cti ve  who  may  have more inf o rmat ion and copies of eval uatio ns from th e 196 0's are Je r e myKi lp atr ic k  a nd Ji m W ilson, both at t heUn iversity ofG eo rgia (butpos sibly retire d). 
Henry 
(Ia m not  su re ho w onew ould o btain the  f u ll rep o rts all u d ed  toabove; it is poss i bl e  that they alr eady e xi s ti n  adig itized for m,  or a r e somew h er e i n t h e Briscoe Cen ter archive s . H opeful ly  an o ther M ESE u se r  ca n fill in m oredetails.) 

A:
J ust a s h ort add ition.  Ed  Be glep ub li she da  va l ua ble stu dy throu gh  M AA/NC TM e n t i t led"Cr itic al Va riables in Mt hem atic s  Ed ucati on",whic hwas a n atte mpt ( in  part) to sortoutsome of t hele sso ns  of t h e SMSG .
 Q: 

Compa ring bi t s e ff i c i en tly ( overlap setof x  ) 

I want  to co m pa re a stream  o f b itso f  arbi trar y  l ength to  a mas k  i nc# andre turn a  r ati o o f how many  bitswere the  same .  
The mask toc heck againsti sa n yw h erebet ween 2 bits  lon g  to8k ( w it h 9 0 % ofthe m as k sb eing 5 bits long),th e inpu t can  be anywherebetween 2b i t s up to~ 50 0 k, with an averag e inp ut stringo f 12k (b ut ye ah, most  of the t i m e it wil l b e c omp ari n g  5  bits with th e firs t5 bitsofthat 12 k)
No w m y n ai ve implem entation  w ou ld  b e s ometh i ng liketh is: 
b ool [] ma s k = ne w[] {  tru e,  t r ue,  false, tr u e  };fl oa t de ndr it e(boo l[]i npu t) { 
   int co rre c t =0; 
   for( int i = 0;i< mask.lengt h;  i+ + ) {       i f ( input[i] == mask[i] ) 
         corr ect++;
   } 
    r etu r n (flo at)cor rect/ (f loa t ) mask. l e ng th; 
} 

but I ex p e ctthisis  bet ter han dled (more efficie n t)with some kin d o f bi n a ry  op e ra t orma g ic? Anyone got anypointers? E DI T: the dat a typ eis notfixed a t thi s  pointin my des ign, so i fints o r b ytearrayswork bet ter, I'da lso b e  a  happ y c amper,  t ryi ng to  optim i zefor e fficie nc y here , the  f aster th e computation, the bett er. 
e g ifyou  can make  it wor k like th is:int[] mask  =new [] {1,1 , 0,1 }; fl oat dendr ite( i nt[] inpu t ){  int correct = 0;    f or(  int i  = 0 ;
. _Kansas is_not one of them.
People_still active_who_may have_more_information and copies_of evaluations from_the 1960's are Jeremy_Kilpatrick and Jim_Wilson,_ both at the University of Georgia (but possibly retired).
Henry

(I am not sure how_one_would obtain_the_full_reports alluded to above; it_is possible that they already_exist in_a digitized form, or are somewhere in the_Briscoe_Center archives. Hopefully_another MESE user can fill in more details.)

A:

Just a_short addition. Ed Begle published a_valuable study through_MAA/NCTM_entitled_"Critical Variables in Mthematics_Education", which was an attempt (in_part) to sort out some of_the lessons of the SMSG.

 Q:

Comparing bits_efficiently ( overlap set of x_)

I want to compare a_stream of_bits of arbitrary length to_a mask in_c# and_return a ratio_of how many bits were the_same. 
The mask_to check against is anywhere between_2_bits long to_8k_(with_90% of_the masks being_5_bits long),_the_input can be anywhere between 2_bits_up to ~ 500k, with an average_input string of 12k_(but_yeah, most of the_time it will be comparing_5 bits with the first 5_bits of_that 12k)_
Now my naive implementation would be something like this:
bool[] mask =_new[] { true, true, false, true_};
float dendrite(bool[] input) {_
 __ int correct_=_0;
 _  for ( int i =_0; i<mask.length;_i++ ) { 
  _   __if ( input[i] == mask[i] )_
     _    __correct++;
_   }
 _  return (float)correct/(float)mask.length;
}

but I expect_this is better_handled (more efficient) with some kind of_binary_operator magic? 
Anyone got any pointers?__
EDIT: the datatype is not fixed_at_this_point in my design, so_if ints or bytearrays work better,_I'd also be a happy camper, trying to optimize_for efficiency here,_the faster the computation, the_better._
eg_if you can make it work like this:
int[] mask =_new[] {_1, 1, 0,_1 };
float dendrite(int[] input) { 
    int_correct = 0;
    for_( int i = 0;