o ©CiB=ã@s²+ddlmZedkredƒ‚esdevrddlmZnddlZzddlZ Wn e y2ddl Z Ynwdd „Z d d „Z d d „Z dd„ZGdd„deƒZGdd„deƒZe e¡ejZGdd„deƒZe e¡Gdd„deƒZe e¡Gdd„deƒZe e¡Gdd„deƒZe e¡Gdd„deƒZe e¡Gdd„deƒZe  e¡Gd d!„d!eƒZ!e "e!¡Gd"d#„d#eƒZ#e $e#¡Gd$d%„d%eƒZ%e &e%¡Gd&d'„d'eƒZ'e (e'¡Gd(d)„d)eƒZ)e *e)¡Gd*d+„d+eƒZ+e ,e+¡Gd,d-„d-eƒZ-e .e-¡Gd.d/„d/eƒZ/e 0e/¡Gd0d1„d1eƒZ1e 2e1¡Gd2d3„d3eƒZ3e 4e3¡Gd4d5„d5eƒZ5e 6e5¡Gd6d7„d7eƒZ7e 8e7¡Gd8d9„d9eƒZ9e :e9¡Gd:d;„d;eƒZ;e e=¡d>d?„Z?d@dA„Z@GdBdC„dCeƒZAe BeA¡dDdE„ZCdFdG„ZDdHdI„ZEdJdK„ZFdLdM„ZGGdNdO„dOeƒZHe IeH¡ejJZJGdPdQ„dQeƒZKe LeK¡dRdS„ZMdTdU„ZNdVdW„ZOdXdY„ZPdZd[„ZQd\d]„ZRd^d_„ZSd`da„ZTdNdcdd„ZUdedf„ZVdgdh„ZWdidj„ZXdkdl„ZYdmdn„ZZdodp„Z[dqdr„Z\dsdt„Z]dudv„Z^dwdx„Z_dydz„Z`d{d|„Zad}d~„Zbdd€„Zcdd‚„Zddƒd„„ZedOd…d†„Zfd‡dˆ„Zgd‰dŠ„Zhd‹dŒ„ZiddŽ„ZjdPd‘d’„Zkd“d”„Zld•d–„Zmd—d˜„Znd™dš„Zod›dœ„Zpddž„ZqdŸd „Zrd¡d¢„ZsdQd¤d¥„Ztd¦d§„Zud¨d©„Zvdªd«„Zwd¬d­„Zxd®d¯„Zyd°d±„Zzd²d³„Z{d´dµ„Z|d¶d·„Z}d¸d¹„Z~dºd»„Zd¼d½„Z€d¾d¿„ZdÀdÁ„Z‚dÂdÄZƒdÄdÅ„Z„dÆdÇ„Z…dÈdÉ„Z†dRdÊdË„Z‡dRdÌdÍ„ZˆdSdÎdÏ„Z‰dSdÐdÑ„ZŠdÒdÓ„Z‹GdÔdÕ„dÕeƒZŒe eŒ¡eJjŽZŽdÖdׄZdØdÙ„ZdÚdÛ„Z‘dÜdÝ„Z’dÞdß„Z“dàdá„Z”dâdã„Z•dädå„Z–dædç„Z—dTdèdé„Z˜dêdë„Z™ejšZš ej›Z› ejœZœ ejZ ejžZž ejŸZŸ ej Z ej¡Z¡ej¢Z¢ dìdí„Z£ej¤Z¤ ej¥Z¥ej¦Z¦Gdîdï„dïeƒZ§e ¨e§¡Gdðdñ„dñeƒZ©e ªe©¡Gdòdó„dóeƒZ«e ¬e«¡Gdôdõ„dõe«ƒZ­e ®e­¡Gdöd÷„d÷e©ƒZ¯e °e¯¡Gdødù„dùe¯ƒZ±e ²e±¡Gdúdû„dûe±ƒZ³e ´e³¡Gdüdý„dýe±ƒZµe ¶eµ¡Gdþdÿ„dÿeµƒZ·e ¸e·¡Gdd„deƒZ¹e ºe¹¡Gdd„deƒZ»e ¼e»¡Gdd„de¹ƒZ½e ¾e½¡Gdd„de½ƒZ¿e Àe¿¡Gdd „d e¹ƒZÁe ÂeÁ¡Gd d „d eƒZÃe ÄeáGd d „d eÁƒZÅe ÆeÅ¡dd„ZÇdQdd„ZÈdd„ZÉGdd„deƒZÊe ËeÊ¡Gdd„deʃZÌe ÍeÌ¡Gdd„deƒZÎe ÏeΡGdd„deƒZÐe ÑeСGdd„deƒZÒe ÓeÒ¡Gdd„deƒZÔe ÕeÔ¡Gd d!„d!eƒZÖe ×eÖ¡Gd"d#„d#eƒZØe ÙeØ¡Gd$d%„d%eʃZÚe ÛeÚ¡Gd&d'„d'eÚƒZÜe ÝeÜ¡d(d)„ZÞd*d+„ZßGd,d-„d-eÚƒZàe áeà¡Gd.d/„d/eƒZâe ãeâ¡Gd0d1„d1eƒZäe åeä¡Gd2d3„d3eƒZæe çeæ¡Gd4d5„d5eƒZèe éeè¡Gd6d7„d7eÚƒZêe ëeê¡Gd8d9„d9eêƒZìe íeì¡Gd:d;„d;eêƒZîe ïeî¡Gd<d=„d=eƒZðe ñeð¡Gd>d?„d?eðƒZòe óeò¡Gd@dA„dAeƒZôe õeô¡GdBdC„dCeôƒZöe ÷eö¡GdDdE„dEeöƒZøe ùeø¡GdFdG„dGeöƒZúe ûeú¡GdHdI„dIeöƒZüe ýeü¡GdJdK„dKeôƒZþe ÿeþ¡GdLdM„dMeöƒZe e¡GdNdO„dOeôƒZe e¡GdPdQ„dQeôƒZe e¡GdRdS„dSeôƒZe e¡GdTdU„dUe§ƒZe  e¡GdVdW„dWe©ƒZ e  e ¡GdXdY„dYe©ƒZ e  e ¡GdZd[„d[e ƒZe e¡Gd\d]„d]e¯ƒZe e¡Gd^d_„d_eƒZe e¡Gd`da„daeƒZe e¡Gdbdc„dceƒZe e¡ddde„Zdfdg„ZGdhdi„dieƒZe e¡Gdjdk„dkeƒZe e¡Gdldm„dme¯ƒZe e¡Gdndo„doe§ƒZ e !e ¡Gdpdq„dqeƒZ"e #e"¡Gdrds„dse©ƒZ$e %e$¡Gdtdu„due$ƒZ&e 'e&¡Gdvdw„dwe¯ƒZ(e )e(¡Gdxdy„dye(ƒZ*e +e*¡Gdzd{„d{e(ƒZ,e -e,¡Gd|d}„d}e(ƒZ.e /e.¡Gd~d„de(ƒZ0e 1e0¡Gd€d„de©ƒZ2e 3e2¡Gd‚dƒ„dƒe§ƒZ4e 5e4¡Gd„d…„d…e2ƒZ6e 7e6¡Gd†d‡„d‡e2ƒZ8e 9e8¡Gdˆd‰„d‰eƒZ:e ;e:¡GdŠd‹„d‹eƒZe ?e>¡GdŽd„de<ƒZ@e Ae@¡Gdd‘„d‘e:ƒZBe CeB¡Gd’d“„d“e<ƒZDe EeD¡Gd”d•„d•e:ƒZFe GeF¡Gd–d—„d—e<ƒZHe IeH¡d˜d™„ZJdšd›„ZKdœd„ZLGdždŸ„dŸeƒZMe NeM¡Gd d¡„d¡eƒZOe PeO¡Gd¢d£„d£eOƒZQe ReQ¡Gd¤d¥„d¥eOƒZSe TeS¡Gd¦d§„d§eSƒZUe VeU¡Gd¨d©„d©eSƒZWe XeW¡Gdªd«„d«eSƒZYe ZeY¡Gd¬d­„d­eSƒZ[e \e[¡Gd®d¯„d¯eSƒZ]e ^e]¡Gd°d±„d±eƒZ_e `e_¡d²d³„Zad´dµ„Zbd¶d·„Zcd¸d¹„ZdGdºd»„d»eOƒZee fee¡d¼d½„Zgd¾d¿„ZhdÀdÁ„ZiGdÂdÄdÃeƒZje kej¡GdÄdÅ„dÅeƒZle mel¡GdÆdÇ„dÇeƒZne oen¡GdÈdÉ„dÉe§ƒZpe qep¡GdÊdË„dËenƒZre ser¡GdÌdÍ„dÍe©erƒZte uet¡GdÎdÏ„dÏeƒZve wev¡GdÐdÑ„dÑeƒZxe yex¡dÒdÓ„ZzdÔdÕ„Z{dÖdׄZ|dØdÙ„Z}dÚdÛ„Z~dÜdÝ„ZGdÞdß„dßeƒZ€e e€¡dàdá„Z‚dâdã„ZƒdUdädå„Z„dUdædç„Z…dèdé„Z†dRdêdë„Z‡Gdìdí„díeʃZˆe ‰eˆ¡Gdîdï„dïe¯ƒZŠe ‹eŠ¡Gdðdñ„dñetƒZŒe eŒ¡Gdòdó„dóetƒZŽe eŽ¡Gdôdõ„dõetƒZe ‘e¡Gdöd÷„d÷eƒZ’e “e’¡Gdødù„dùeƒZ”e •e”¡Gdúdû„dûeƒZ–e —e–¡Gdüdý„dýeƒZ˜e ™e˜¡Gdþdÿ„dÿe§ƒZše ›eš¡Gdd„deƒZœe eœ¡dd„ZžGdd„deƒZŸe  eŸ¡Gdd„deƒZ¡e ¢e¡¡Gdd „d e©ƒZ£e ¤e£¡Gd d „d e£ƒZ¥e ¦e¥¡Gd d „d e£ƒZ§e ¨e§¡Gdd„de£ƒZ©e ªe©¡Gdd„de£ƒZ«e ¬e«¡dd„Z­dd„Z®Gdd„deƒZ¯e °e¯¡Gdd„deƒZ±e ²e±¡Gdd„deƒZ³e ´e³¡Gdd„de©ƒZµe ¶eµ¡Gdd„deµƒZ·e ¸e·¡Gd d!„d!etƒZ¹e ºe¹¡Gd"d#„d#e¹ƒZ»e ¼e»¡d$d%„Z½Gd&d'„d'eƒZ¾e ¿e¾¡Gd(d)„d)e©ƒZÀe ÁeÀ¡Gd*d+„d+eÀƒZÂe Ãe¡Gd,d-„d-eÀƒZÄe ÅeÄ¡Gd.d/„d/eÀƒZÆe ÇeÆ¡Gd0d1„d1eƒZÈe ÉeÈ¡Gd2d3„d3eOƒZÊe ËeÊ¡Gd4d5„d5eƒZÌe ÍeÌ¡Gd6d7„d7eƒZÎe ÏeΡGd8d9„d9eƒZÐe ÑeСGd:d;„d;eƒZÒe ÓeÒ¡Gd<d=„d=eÌe΃ZÔe ÕeÔ¡Gd>d?„d?e΃ZÖe ×eÖ¡Gd@dA„dAeÔƒZØe ÙeØ¡GdBdC„dCe©ƒZÚe ÛeÚ¡GdDdE„dEepƒZÜe ÝeÜ¡GdFdG„dGetƒZÞe ßeÞ¡dHdI„ZàGdJdK„dKeƒZáe âeá¡GdLdM„dMeÞƒZãe äeã¡GdNdO„dOe¯ƒZåe æeå¡GdPdQ„dQe©ƒZçe èeç¡GdRdS„dSeƒZée êeé¡GdTdU„dUeçƒZëe ìeë¡GdVdW„dWeëƒZíe îeí¡GdXdY„dYeëƒZïe ðeï¡GdZd[„d[eëƒZñe òeñ¡Gd\d]„d]eëƒZóe ôeó¡Gd^d_„d_eçƒZõe öeõ¡Gd`da„daetƒZ÷e øe÷¡Gdbdc„dceƒZùe úeù¡Gddde„dee÷ƒZûe üeû¡Gdfdg„dgeûƒZýe þeý¡Gdhdi„dieûƒZÿe eÿ¡Gdjdk„dkeûƒZe e¡Gdldm„dmeûƒZe e¡Gdndo„doe÷ƒZe e¡dUdpdq„ZdUdrds„ZdUdtdu„Z dvdw„Z dxdy„Z Gdzd{„d{eƒZ e  e ¡Gd|d}„d}e ƒZe e¡Gd~d„de ƒZe e¡Gd€d„deƒZe e¡Gd‚dƒ„dƒe ƒZe e¡Gd„d…„d…e ƒZe e¡Gd†d‡„d‡e ƒZe e¡Gdˆd‰„d‰eƒZe e¡GdŠd‹„d‹e ƒZe e¡GdŒd„de©ƒZe e¡GdŽd„de ƒZ e !e ¡Gdd‘„d‘eƒZ"e #e"¡Gd’d“„d“e ƒZ$e %e$¡Gd”d•„d•e"enƒZ&e 'e&¡Gd–d—„d—eƒZ(e )e(¡Gd˜d™„d™e ƒZ*e +e*¡Gdšd›„d›e©ƒZ,e -e,¡Gdœd„de©ƒZ.e /e.¡GdždŸ„dŸe©ƒZ0e 1e0¡Gd d¡„d¡e ƒZ2e 3e2¡Gd¢d£„d£e0ƒZ4e 5e4¡Gd¤d¥„d¥e2ƒZ6e 7e6¡Gd¦d§„d§e©ƒZ8e 9e8¡Gd¨d©„d©e8ƒZ:e ;e:¡Gdªd«„d«e8ƒZe ?e>¡Gd®d¯„d¯eƒZ@e Ae@¡Gd°d±„d±eƒZBe CeB¡Gd²d³„d³e@ƒZDe EeD¡dNd´dµ„ZFGd¶d·„d·eƒZGe HeG¡d¸d¹„ZIdºd»„ZJd¼d½„ZKd¾d¿„ZLGdÀdÁ„dÁeƒZMe NeM¡GdÂdÄdÃeƒZOe PeO¡GdÄdÅ„dÅeOƒZQe ReQ¡GdÆdÇ„dÇeOƒZSe TeS¡GdÈdÉ„dÉeOƒZUe VeU¡GdÊdË„dËeOƒZWe XeW¡GdÌdÍ„dÍeOƒZYe ZeY¡GdÎdÏ„dÏeOƒZ[e \e[¡GdÐdÑ„dÑeOƒZ]e ^e]¡GdÒdÓ„dÓeOƒZ_e `e_¡GdÔdÕ„dÕeOƒZae bea¡ejcZcejdZdejeZeejfZfejgZgdÖdׄZhdØdÙ„ZidÚdÛ„ZjdÜdÝ„ZkdÞdß„Zldàdá„Zmdâdã„Zndädå„Zodædç„Zpdèdé„Zqdêdë„Zrdìdí„Zsdîdï„Ztdðdñ„Zudòdó„ZvdTdôdõ„Zwdöd÷„ZxGdødù„dùeƒZye zey¡eJj{Z{eJj|Z|eJj}Z}eJj~Z~eJjZdúdû„Z€Gdüdý„dýeƒZe ‚e¡Gdþdÿ„dÿeƒZƒe „eƒ¡Gdd„deƒZ…e †e…¡Gdd„deƒZ‡e ˆe‡¡Gdd„deƒZ‰e Še‰¡Gdd„deƒZ‹e Œe‹¡Gdd „d eƒZe Že¡d d „Zd d „ZGdd„deƒZ‘e ’e‘¡Gdd„de<ƒZ“e ”e“¡Gdd„de:ƒZ•e –e•¡Gdd„deOƒZ—e ˜e—¡dd„Z™dd„ZšGdd„deƒZ›e œe›¡Gdd„deƒZe že¡Gdd„deƒZŸe  eŸ¡Gd d!„d!eƒZ¡e ¢e¡¡d"d#„Z£d$d%„Z¤Gd&d'„d'eƒZ¥e ¦e¥¡d(d)„Z§Gd*d+„d+eƒZ¨e ©e¨¡d,d-„ZªGd.d/„d/eƒZ«e ¬e«¡d0d1„Z­d2d3„Z®d4d5„Z¯d6d7„Z°d8d9„Z±d:d;„Z²d<d=„Z³d>d?„Z´d@dA„ZµdBdC„Z¶dDdE„Z·dFdG„Z¸dHdI„Z¹GdJdK„dKeƒZºe »eº¡dLdM„Z¼dS(Vé)Ú version_info)éérzPython 2.7 or later requiredÚ.é)Ú _swigfaissNcCsBz d|j ¡}Wn tjyd}Ynwd|jj|jj|fS)Nz proxy of Úz <%s.%s; %s >)ÚthisÚ__repr__Ú __builtin__Ú ExceptionÚ __class__Ú __module__Ú__name__)ÚselfÚstrthis©rúg/var/www/html/fyndo/python/python_agents/rag_suite/venv/lib/python3.10/site-packages/faiss/swigfaiss.pyÚ _swig_reprs ÿrcó‡fdd„}|S)Ncsj|dkr |j |¡dS|dkrˆ|||ƒdSt||ƒr/ttt|ƒ|ƒtƒr/ˆ|||ƒdStd|ƒ‚)NÚthisownr z(You cannot add instance attributes to %s)r ÚownÚhasattrÚ isinstanceÚgetattrÚtypeÚpropertyÚAttributeError)rÚnameÚvalue©ÚsetrrÚset_instance_attrs zE_swig_setattr_nondynamic_instance_variable..set_instance_attrr)r!r"rr rÚ*_swig_setattr_nondynamic_instance_variables  r#cr)Ncs6t||ƒrtt||ƒtƒsˆ|||ƒdStd|ƒ‚)Nz%You cannot add class attributes to %s)rrrrr)Úclsrrr rrÚset_class_attr,s z?_swig_setattr_nondynamic_class_variable..set_class_attrr)r!r%rr rÚ'_swig_setattr_nondynamic_class_variable+s r&cr)zlClass decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclasscsˆ|j|j|j ¡ƒS©N)rÚ __bases__Ú__dict__Úcopy)r$©Ú metaclassrrÚwrapper6óz$_swig_add_metaclass..wrapperr)r,r-rr+rÚ_swig_add_metaclass4s r/c@seZdZdZeejƒZdS)Ú_SwigNonDynamicMetazKMeta class to enforce nondynamic attributes (no new attributes) for a classN)rrÚ __qualname__Ú__doc__r&rÚ __setattr__rrrrr0;sr0c@sÀeZdZedd„dd„ddZdd„ZeZej Z dd „Z d,d d „Z d,d d„Z dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+S)-ÚSwigPyIteratorcCó |j ¡Sr'©r r©ÚxrrrÚAó zSwigPyIterator.cCó |j |¡Sr'r6©r8Úvrrrr9Aó úThe membership flag©ÚdoccOótdƒ‚©Nz*No constructor defined - class is abstract©r©rÚargsÚkwargsrrrÚ__init__CózSwigPyIterator.__init__cCó t |¡Sr')rÚSwigPyIterator_value©rrrrrHó zSwigPyIterator.valuercCó t ||¡Sr')rÚSwigPyIterator_incr©rÚnrrrÚincrKó zSwigPyIterator.incrcCrNr')rÚSwigPyIterator_decrrPrrrÚdecrNrSzSwigPyIterator.decrcCrNr')rÚSwigPyIterator_distance©rr8rrrÚdistanceQrSzSwigPyIterator.distancecCrNr')rÚSwigPyIterator_equalrWrrrÚequalTrSzSwigPyIterator.equalcCrJr')rÚSwigPyIterator_copyrLrrrr*WrMzSwigPyIterator.copycCrJr')rÚSwigPyIterator_nextrLrrrÚnextZrMzSwigPyIterator.nextcCrJr')rÚSwigPyIterator___next__rLrrrÚ__next__]rMzSwigPyIterator.__next__cCrJr')rÚSwigPyIterator_previousrLrrrÚprevious`rMzSwigPyIterator.previouscCrNr')rÚSwigPyIterator_advancerPrrrÚadvancecrSzSwigPyIterator.advancecCrNr')rÚSwigPyIterator___eq__rWrrrÚ__eq__frSzSwigPyIterator.__eq__cCrNr')rÚSwigPyIterator___ne__rWrrrÚ__ne__irSzSwigPyIterator.__ne__cCrNr')rÚSwigPyIterator___iadd__rPrrrÚ__iadd__lrSzSwigPyIterator.__iadd__cCrNr')rÚSwigPyIterator___isub__rPrrrÚ__isub__orSzSwigPyIterator.__isub__cCrNr')rÚSwigPyIterator___add__rPrrrÚ__add__rrSzSwigPyIterator.__add__cGótj|g|¢RŽSr')rÚSwigPyIterator___sub__©rrFrrrÚ__sub__uózSwigPyIterator.__sub__cCs|Sr'rrLrrrÚ__iter__wszSwigPyIterator.__iter__N©r)rrr1rrrHrr rÚdelete_SwigPyIteratorÚ__swig_destroy__rrRrUrXrZr*r]r_rarcrergrirkrmrqrsrrrrr4@s,   r4c@óleZdZedd„dd„ddZeZdd„Zdd „Zd d „Z d d „Z dd„Z dd„Z dd„Z dd„ZejZdS)Ú Float32VectorcCr5r'r6r7rrrr9r:zFloat32Vector.cCr;r'r6r<rrrr9r>r?r@cCót |t ¡¡dSr')rÚFloat32Vector_swiginitÚnew_Float32VectorrLrrrrH‚ózFloat32Vector.__init__cCrNr')rÚFloat32Vector_push_back©rÚarg2rrrÚ push_back…rSzFloat32Vector.push_backcCrJr')rÚFloat32Vector_clearrLrrrÚclearˆrMzFloat32Vector.clearcCrJr')rÚFloat32Vector_datarLrrrÚdata‹rMzFloat32Vector.datacCrJr')rÚFloat32Vector_sizerLrrrÚsizeŽrMzFloat32Vector.sizecCrNr')rÚFloat32Vector_atrPrrrÚat‘rSzFloat32Vector.atcCrNr')rÚFloat32Vector_resizerPrrrÚresize”rSzFloat32Vector.resizecCrNr')rÚFloat32Vector_swap©rÚotherrrrÚswap—rSzFloat32Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_Float32Vectorrvrrrrrx~ó rxc@rw)Ú Float64VectorcCr5r'r6r7rrrr9Ÿr:zFloat64Vector.cCr;r'r6r<rrrr9Ÿr>r?r@cCryr')rÚFloat64Vector_swiginitÚnew_Float64VectorrLrrrrH¢r|zFloat64Vector.__init__cCrNr')rÚFloat64Vector_push_backr~rrrr€¥rSzFloat64Vector.push_backcCrJr')rÚFloat64Vector_clearrLrrrr‚¨rMzFloat64Vector.clearcCrJr')rÚFloat64Vector_datarLrrrr„«rMzFloat64Vector.datacCrJr')rÚFloat64Vector_sizerLrrrr†®rMzFloat64Vector.sizecCrNr')rÚFloat64Vector_atrPrrrrˆ±rSzFloat64Vector.atcCrNr')rÚFloat64Vector_resizerPrrrrŠ´rSzFloat64Vector.resizecCrNr')rÚFloat64Vector_swaprŒrrrrŽ·rSzFloat64Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_Float64Vectorrvrrrrr‘žrr‘c@rw)Ú Int8VectorcCr5r'r6r7rrrr9¿r:zInt8Vector.cCr;r'r6r<rrrr9¿r>r?r@cCryr')rÚInt8Vector_swiginitÚnew_Int8VectorrLrrrrHÂr|zInt8Vector.__init__cCrNr')rÚInt8Vector_push_backr~rrrr€ÅrSzInt8Vector.push_backcCrJr')rÚInt8Vector_clearrLrrrr‚ÈrMzInt8Vector.clearcCrJr')rÚInt8Vector_datarLrrrr„ËrMzInt8Vector.datacCrJr')rÚInt8Vector_sizerLrrrr†ÎrMzInt8Vector.sizecCrNr')rÚ Int8Vector_atrPrrrrˆÑrSz Int8Vector.atcCrNr')rÚInt8Vector_resizerPrrrrŠÔrSzInt8Vector.resizecCrNr')rÚInt8Vector_swaprŒrrrrŽ×rSzInt8Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_Int8Vectorrvrrrrrœ¾rrœc@rw)Ú Int16VectorcCr5r'r6r7rrrr9ßr:zInt16Vector.cCr;r'r6r<rrrr9ßr>r?r@cCryr')rÚInt16Vector_swiginitÚnew_Int16VectorrLrrrrHâr|zInt16Vector.__init__cCrNr')rÚInt16Vector_push_backr~rrrr€årSzInt16Vector.push_backcCrJr')rÚInt16Vector_clearrLrrrr‚èrMzInt16Vector.clearcCrJr')rÚInt16Vector_datarLrrrr„ërMzInt16Vector.datacCrJr')rÚInt16Vector_sizerLrrrr†îrMzInt16Vector.sizecCrNr')rÚInt16Vector_atrPrrrrˆñrSzInt16Vector.atcCrNr')rÚInt16Vector_resizerPrrrrŠôrSzInt16Vector.resizecCrNr')rÚInt16Vector_swaprŒrrrrŽ÷rSzInt16Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_Int16Vectorrvrrrrr§Þrr§c@rw)Ú Int32VectorcCr5r'r6r7rrrr9ÿr:zInt32Vector.cCr;r'r6r<rrrr9ÿr>r?r@cCryr')rÚInt32Vector_swiginitÚnew_Int32VectorrLrrrrHr|zInt32Vector.__init__cCrNr')rÚInt32Vector_push_backr~rrrr€rSzInt32Vector.push_backcCrJr')rÚInt32Vector_clearrLrrrr‚rMzInt32Vector.clearcCrJr')rÚInt32Vector_datarLrrrr„ rMzInt32Vector.datacCrJr')rÚInt32Vector_sizerLrrrr†rMzInt32Vector.sizecCrNr')rÚInt32Vector_atrPrrrrˆrSzInt32Vector.atcCrNr')rÚInt32Vector_resizerPrrrrŠrSzInt32Vector.resizecCrNr')rÚInt32Vector_swaprŒrrrrŽrSzInt32Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_Int32Vectorrvrrrrr²þrr²c@rw)Ú Int64VectorcCr5r'r6r7rrrr9r:zInt64Vector.cCr;r'r6r<rrrr9r>r?r@cCryr')rÚInt64Vector_swiginitÚnew_Int64VectorrLrrrrH"r|zInt64Vector.__init__cCrNr')rÚInt64Vector_push_backr~rrrr€%rSzInt64Vector.push_backcCrJr')rÚInt64Vector_clearrLrrrr‚(rMzInt64Vector.clearcCrJr')rÚInt64Vector_datarLrrrr„+rMzInt64Vector.datacCrJr')rÚInt64Vector_sizerLrrrr†.rMzInt64Vector.sizecCrNr')rÚInt64Vector_atrPrrrrˆ1rSzInt64Vector.atcCrNr')rÚInt64Vector_resizerPrrrrŠ4rSzInt64Vector.resizecCrNr')rÚInt64Vector_swaprŒrrrrŽ7rSzInt64Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_Int64Vectorrvrrrrr½rr½c@rw)Ú UInt8VectorcCr5r'r6r7rrrr9?r:zUInt8Vector.cCr;r'r6r<rrrr9?r>r?r@cCryr')rÚUInt8Vector_swiginitÚnew_UInt8VectorrLrrrrHBr|zUInt8Vector.__init__cCrNr')rÚUInt8Vector_push_backr~rrrr€ErSzUInt8Vector.push_backcCrJr')rÚUInt8Vector_clearrLrrrr‚HrMzUInt8Vector.clearcCrJr')rÚUInt8Vector_datarLrrrr„KrMzUInt8Vector.datacCrJr')rÚUInt8Vector_sizerLrrrr†NrMzUInt8Vector.sizecCrNr')rÚUInt8Vector_atrPrrrrˆQrSzUInt8Vector.atcCrNr')rÚUInt8Vector_resizerPrrrrŠTrSzUInt8Vector.resizecCrNr')rÚUInt8Vector_swaprŒrrrrŽWrSzUInt8Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_UInt8VectorrvrrrrrÈ>rrÈc@rw)Ú UInt16VectorcCr5r'r6r7rrrr9_r:zUInt16Vector.cCr;r'r6r<rrrr9_r>r?r@cCryr')rÚUInt16Vector_swiginitÚnew_UInt16VectorrLrrrrHbr|zUInt16Vector.__init__cCrNr')rÚUInt16Vector_push_backr~rrrr€erSzUInt16Vector.push_backcCrJr')rÚUInt16Vector_clearrLrrrr‚hrMzUInt16Vector.clearcCrJr')rÚUInt16Vector_datarLrrrr„krMzUInt16Vector.datacCrJr')rÚUInt16Vector_sizerLrrrr†nrMzUInt16Vector.sizecCrNr')rÚUInt16Vector_atrPrrrrˆqrSzUInt16Vector.atcCrNr')rÚUInt16Vector_resizerPrrrrŠtrSzUInt16Vector.resizecCrNr')rÚUInt16Vector_swaprŒrrrrŽwrSzUInt16Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_UInt16VectorrvrrrrrÓ^rrÓc@rw)Ú UInt32VectorcCr5r'r6r7rrrr9r:zUInt32Vector.cCr;r'r6r<rrrr9r>r?r@cCryr')rÚUInt32Vector_swiginitÚnew_UInt32VectorrLrrrrH‚r|zUInt32Vector.__init__cCrNr')rÚUInt32Vector_push_backr~rrrr€…rSzUInt32Vector.push_backcCrJr')rÚUInt32Vector_clearrLrrrr‚ˆrMzUInt32Vector.clearcCrJr')rÚUInt32Vector_datarLrrrr„‹rMzUInt32Vector.datacCrJr')rÚUInt32Vector_sizerLrrrr†ŽrMzUInt32Vector.sizecCrNr')rÚUInt32Vector_atrPrrrrˆ‘rSzUInt32Vector.atcCrNr')rÚUInt32Vector_resizerPrrrrŠ”rSzUInt32Vector.resizecCrNr')rÚUInt32Vector_swaprŒrrrrŽ—rSzUInt32Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_UInt32VectorrvrrrrrÞ~rrÞc@rw)Ú UInt64VectorcCr5r'r6r7rrrr9Ÿr:zUInt64Vector.cCr;r'r6r<rrrr9Ÿr>r?r@cCryr')rÚUInt64Vector_swiginitÚnew_UInt64VectorrLrrrrH¢r|zUInt64Vector.__init__cCrNr')rÚUInt64Vector_push_backr~rrrr€¥rSzUInt64Vector.push_backcCrJr')rÚUInt64Vector_clearrLrrrr‚¨rMzUInt64Vector.clearcCrJr')rÚUInt64Vector_datarLrrrr„«rMzUInt64Vector.datacCrJr')rÚUInt64Vector_sizerLrrrr†®rMzUInt64Vector.sizecCrNr')rÚUInt64Vector_atrPrrrrˆ±rSzUInt64Vector.atcCrNr')rÚUInt64Vector_resizerPrrrrŠ´rSzUInt64Vector.resizecCrNr')rÚUInt64Vector_swaprŒrrrrŽ·rSzUInt64Vector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_UInt64Vectorrvrrrrréžrréc@rw)ÚFloat32VectorVectorcCr5r'r6r7rrrr9¿r:zFloat32VectorVector.cCr;r'r6r<rrrr9¿r>r?r@cCryr')rÚFloat32VectorVector_swiginitÚnew_Float32VectorVectorrLrrrrHÂr|zFloat32VectorVector.__init__cCrNr')rÚFloat32VectorVector_push_backr~rrrr€ÅrSzFloat32VectorVector.push_backcCrJr')rÚFloat32VectorVector_clearrLrrrr‚ÈrMzFloat32VectorVector.clearcCrJr')rÚFloat32VectorVector_datarLrrrr„ËrMzFloat32VectorVector.datacCrJr')rÚFloat32VectorVector_sizerLrrrr†ÎrMzFloat32VectorVector.sizecCrNr')rÚFloat32VectorVector_atrPrrrrˆÑrSzFloat32VectorVector.atcCrNr')rÚFloat32VectorVector_resizerPrrrrŠÔrSzFloat32VectorVector.resizecCrNr')rÚFloat32VectorVector_swaprŒrrrrŽ×rSzFloat32VectorVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_Float32VectorVectorrvrrrrrô¾rrôc@rw)ÚUInt8VectorVectorcCr5r'r6r7rrrr9ßr:zUInt8VectorVector.cCr;r'r6r<rrrr9ßr>r?r@cCryr')rÚUInt8VectorVector_swiginitÚnew_UInt8VectorVectorrLrrrrHâr|zUInt8VectorVector.__init__cCrNr')rÚUInt8VectorVector_push_backr~rrrr€årSzUInt8VectorVector.push_backcCrJr')rÚUInt8VectorVector_clearrLrrrr‚èrMzUInt8VectorVector.clearcCrJr')rÚUInt8VectorVector_datarLrrrr„ërMzUInt8VectorVector.datacCrJr')rÚUInt8VectorVector_sizerLrrrr†îrMzUInt8VectorVector.sizecCrNr')rÚUInt8VectorVector_atrPrrrrˆñrSzUInt8VectorVector.atcCrNr')rÚUInt8VectorVector_resizerPrrrrŠôrSzUInt8VectorVector.resizecCrNr')rÚUInt8VectorVector_swaprŒrrrrŽ÷rSzUInt8VectorVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_UInt8VectorVectorrvrrrrrÿÞrrÿc@rw)ÚInt32VectorVectorcCr5r'r6r7rrrr9ÿr:zInt32VectorVector.cCr;r'r6r<rrrr9ÿr>r?r@cCryr')rÚInt32VectorVector_swiginitÚnew_Int32VectorVectorrLrrrrHr|zInt32VectorVector.__init__cCrNr')rÚInt32VectorVector_push_backr~rrrr€rSzInt32VectorVector.push_backcCrJr')rÚInt32VectorVector_clearrLrrrr‚rMzInt32VectorVector.clearcCrJr')rÚInt32VectorVector_datarLrrrr„ rMzInt32VectorVector.datacCrJr')rÚInt32VectorVector_sizerLrrrr†rMzInt32VectorVector.sizecCrNr')rÚInt32VectorVector_atrPrrrrˆrSzInt32VectorVector.atcCrNr')rÚInt32VectorVector_resizerPrrrrŠrSzInt32VectorVector.resizecCrNr')rÚInt32VectorVector_swaprŒrrrrŽrSzInt32VectorVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_Int32VectorVectorrvrrrrr þrr c@rw)ÚInt64VectorVectorcCr5r'r6r7rrrr9r:zInt64VectorVector.cCr;r'r6r<rrrr9r>r?r@cCryr')rÚInt64VectorVector_swiginitÚnew_Int64VectorVectorrLrrrrH"r|zInt64VectorVector.__init__cCrNr')rÚInt64VectorVector_push_backr~rrrr€%rSzInt64VectorVector.push_backcCrJr')rÚInt64VectorVector_clearrLrrrr‚(rMzInt64VectorVector.clearcCrJr')rÚInt64VectorVector_datarLrrrr„+rMzInt64VectorVector.datacCrJr')rÚInt64VectorVector_sizerLrrrr†.rMzInt64VectorVector.sizecCrNr')rÚInt64VectorVector_atrPrrrrˆ1rSzInt64VectorVector.atcCrNr')rÚInt64VectorVector_resizerPrrrrŠ4rSzInt64VectorVector.resizecCrNr')rÚInt64VectorVector_swaprŒrrrrŽ7rSzInt64VectorVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_Int64VectorVectorrvrrrrrrrc@rw)ÚVectorTransformVectorcCr5r'r6r7rrrr9?r:zVectorTransformVector.cCr;r'r6r<rrrr9?r>r?r@cCryr')rÚVectorTransformVector_swiginitÚnew_VectorTransformVectorrLrrrrHBr|zVectorTransformVector.__init__cCrNr')rÚVectorTransformVector_push_backr~rrrr€ErSzVectorTransformVector.push_backcCrJr')rÚVectorTransformVector_clearrLrrrr‚HrMzVectorTransformVector.clearcCrJr')rÚVectorTransformVector_datarLrrrr„KrMzVectorTransformVector.datacCrJr')rÚVectorTransformVector_sizerLrrrr†NrMzVectorTransformVector.sizecCrNr')rÚVectorTransformVector_atrPrrrrˆQrSzVectorTransformVector.atcCrNr')rÚVectorTransformVector_resizerPrrrrŠTrSzVectorTransformVector.resizecCrNr')rÚVectorTransformVector_swaprŒrrrrŽWrSzVectorTransformVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_VectorTransformVectorrvrrrrr >rr c@rw)ÚOperatingPointVectorcCr5r'r6r7rrrr9_r:zOperatingPointVector.cCr;r'r6r<rrrr9_r>r?r@cCryr')rÚOperatingPointVector_swiginitÚnew_OperatingPointVectorrLrrrrHbr|zOperatingPointVector.__init__cCrNr')rÚOperatingPointVector_push_backr~rrrr€erSzOperatingPointVector.push_backcCrJr')rÚOperatingPointVector_clearrLrrrr‚hrMzOperatingPointVector.clearcCrJr')rÚOperatingPointVector_datarLrrrr„krMzOperatingPointVector.datacCrJr')rÚOperatingPointVector_sizerLrrrr†nrMzOperatingPointVector.sizecCrNr')rÚOperatingPointVector_atrPrrrrˆqrSzOperatingPointVector.atcCrNr')rÚOperatingPointVector_resizerPrrrrŠtrSzOperatingPointVector.resizecCrNr')rÚOperatingPointVector_swaprŒrrrrŽwrSzOperatingPointVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_OperatingPointVectorrvrrrrr+^rr+c@rw)ÚInvertedListsPtrVectorcCr5r'r6r7rrrr9r:zInvertedListsPtrVector.cCr;r'r6r<rrrr9r>r?r@cCryr')rÚInvertedListsPtrVector_swiginitÚnew_InvertedListsPtrVectorrLrrrrH‚r|zInvertedListsPtrVector.__init__cCrNr')rÚ InvertedListsPtrVector_push_backr~rrrr€…rSz InvertedListsPtrVector.push_backcCrJr')rÚInvertedListsPtrVector_clearrLrrrr‚ˆrMzInvertedListsPtrVector.clearcCrJr')rÚInvertedListsPtrVector_datarLrrrr„‹rMzInvertedListsPtrVector.datacCrJr')rÚInvertedListsPtrVector_sizerLrrrr†ŽrMzInvertedListsPtrVector.sizecCrNr')rÚInvertedListsPtrVector_atrPrrrrˆ‘rSzInvertedListsPtrVector.atcCrNr')rÚInvertedListsPtrVector_resizerPrrrrŠ”rSzInvertedListsPtrVector.resizecCrNr')rÚInvertedListsPtrVector_swaprŒrrrrŽ—rSzInvertedListsPtrVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_InvertedListsPtrVectorrvrrrrr6~rr6c@rw)Ú RepeatVectorcCr5r'r6r7rrrr9Ÿr:zRepeatVector.cCr;r'r6r<rrrr9Ÿr>r?r@cCryr')rÚRepeatVector_swiginitÚnew_RepeatVectorrLrrrrH¢r|zRepeatVector.__init__cCrNr')rÚRepeatVector_push_backr~rrrr€¥rSzRepeatVector.push_backcCrJr')rÚRepeatVector_clearrLrrrr‚¨rMzRepeatVector.clearcCrJr')rÚRepeatVector_datarLrrrr„«rMzRepeatVector.datacCrJr')rÚRepeatVector_sizerLrrrr†®rMzRepeatVector.sizecCrNr')rÚRepeatVector_atrPrrrrˆ±rSzRepeatVector.atcCrNr')rÚRepeatVector_resizerPrrrrŠ´rSzRepeatVector.resizecCrNr')rÚRepeatVector_swaprŒrrrrŽ·rSzRepeatVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_RepeatVectorrvrrrrrAžrrAc@rw)ÚClusteringIterationStatsVectorcCr5r'r6r7rrrr9¿r:z'ClusteringIterationStatsVector.cCr;r'r6r<rrrr9¿r>r?r@cCryr')rÚ'ClusteringIterationStatsVector_swiginitÚ"new_ClusteringIterationStatsVectorrLrrrrHÂr|z'ClusteringIterationStatsVector.__init__cCrNr')rÚ(ClusteringIterationStatsVector_push_backr~rrrr€ÅrSz(ClusteringIterationStatsVector.push_backcCrJr')rÚ$ClusteringIterationStatsVector_clearrLrrrr‚ÈrMz$ClusteringIterationStatsVector.clearcCrJr')rÚ#ClusteringIterationStatsVector_datarLrrrr„ËrMz#ClusteringIterationStatsVector.datacCrJr')rÚ#ClusteringIterationStatsVector_sizerLrrrr†ÎrMz#ClusteringIterationStatsVector.sizecCrNr')rÚ!ClusteringIterationStatsVector_atrPrrrrˆÑrSz!ClusteringIterationStatsVector.atcCrNr')rÚ%ClusteringIterationStatsVector_resizerPrrrrŠÔrSz%ClusteringIterationStatsVector.resizecCrNr')rÚ#ClusteringIterationStatsVector_swaprŒrrrrŽ×rSz#ClusteringIterationStatsVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚ%delete_ClusteringIterationStatsVectorrvrrrrrL¾rrLc@rw)ÚParameterRangeVectorcCr5r'r6r7rrrr9ßr:zParameterRangeVector.cCr;r'r6r<rrrr9ßr>r?r@cCryr')rÚParameterRangeVector_swiginitÚnew_ParameterRangeVectorrLrrrrHâr|zParameterRangeVector.__init__cCrNr')rÚParameterRangeVector_push_backr~rrrr€årSzParameterRangeVector.push_backcCrJr')rÚParameterRangeVector_clearrLrrrr‚èrMzParameterRangeVector.clearcCrJr')rÚParameterRangeVector_datarLrrrr„ërMzParameterRangeVector.datacCrJr')rÚParameterRangeVector_sizerLrrrr†îrMzParameterRangeVector.sizecCrNr')rÚParameterRangeVector_atrPrrrrˆñrSzParameterRangeVector.atcCrNr')rÚParameterRangeVector_resizerPrrrrŠôrSzParameterRangeVector.resizecCrNr')rÚParameterRangeVector_swaprŒrrrrŽ÷rSzParameterRangeVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_ParameterRangeVectorrvrrrrrWÞrrWc@rw)ÚOnDiskOneListVectorcCr5r'r6r7rrrr9ÿr:zOnDiskOneListVector.cCr;r'r6r<rrrr9ÿr>r?r@cCryr')rÚOnDiskOneListVector_swiginitÚnew_OnDiskOneListVectorrLrrrrHr|zOnDiskOneListVector.__init__cCrNr')rÚOnDiskOneListVector_push_backr~rrrr€rSzOnDiskOneListVector.push_backcCrJr')rÚOnDiskOneListVector_clearrLrrrr‚rMzOnDiskOneListVector.clearcCrJr')rÚOnDiskOneListVector_datarLrrrr„ rMzOnDiskOneListVector.datacCrJr')rÚOnDiskOneListVector_sizerLrrrr†rMzOnDiskOneListVector.sizecCrNr')rÚOnDiskOneListVector_atrPrrrrˆrSzOnDiskOneListVector.atcCrNr')rÚOnDiskOneListVector_resizerPrrrrŠrSzOnDiskOneListVector.resizecCrNr')rÚOnDiskOneListVector_swaprŒrrrrŽrSzOnDiskOneListVector.swapN)rrr1rrrr rHr€r‚r„r†rˆrŠrŽrÚdelete_OnDiskOneListVectorrvrrrrrbþrrbcCót |||||¡S)z³ low level SIMD histogramming functions 8-bin histogram of (x - min) >> shift values outside the range are ignored. the data table should be aligned on 32 bytes )rÚsimd_histogram_8©r„rQÚminÚshiftÚhistrrrrnórncCrm)z same for 16-bin histogram)rÚsimd_histogram_16rorrrrt'órtc@óXeZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ dd„Zdd „ZejZd S) ÚPartitionStatscCr5r'r6r7rrrr9+r:zPartitionStats.cCr;r'r6r<rrrr9+r>r?r@cCryr')rÚPartitionStats_swiginitÚnew_PartitionStatsrLrrrrH0r|zPartitionStats.__init__cCrJr')rÚPartitionStats_resetrLrrrÚreset3rMzPartitionStats.resetN)rrr1rrrr rÚ!PartitionStats_bissect_cycles_getÚ!PartitionStats_bissect_cycles_setÚbissect_cyclesÚ"PartitionStats_compress_cycles_getÚ"PartitionStats_compress_cycles_setÚcompress_cyclesrHr{Údelete_PartitionStatsrvrrrrrw*ó rwcCrNr')rÚ bitvec_print)ÚbÚdrrrr„;rSr„cCót ||||¡Sr')rÚ fvecs2bitvecs)r8r…r†rQrrrrˆ>órˆcCr‡r')rÚ bitvecs2fvecs)r…r8r†rQrrrrŠAr‰rŠcCót |||¡Sr')rÚ fvec2bitvec)r8r…r†rrrrŒDórŒcCót ||||||¡S)z0 Shuffle the bits from b(i, j) := a(i, order[j]))rÚbitvec_shuffle)rQÚdaÚdbÚorderÚar…rrrrGórc@ófeZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejejƒZdd„Zdd „ZejZd S) ÚBitstringWritercCr5r'r6r7rrrr9Kr:zBitstringWriter.cCr;r'r6r<rrrr9Kr>r?r@cCót |t ||¡¡dSr')rÚBitstringWriter_swiginitÚnew_BitstringWriter©rÚcodeÚ code_sizerrrrHQózBitstringWriter.__init__cCr‹r')rÚBitstringWriter_write)rr8ÚnbitrrrÚwriteTrzBitstringWriter.writeN)rrr1rrrr rÚBitstringWriter_code_getÚBitstringWriter_code_setr›ÚBitstringWriter_code_size_getÚBitstringWriter_code_size_setrœÚBitstringWriter_i_getÚBitstringWriter_i_setÚirHr Údelete_BitstringWriterrvrrrrr–Jó r–c@r•) ÚBitstringReadercCr5r'r6r7rrrr9]r:zBitstringReader.cCr;r'r6r<rrrr9]r>r?r@cCr—r')rÚBitstringReader_swiginitÚnew_BitstringReaderršrrrrHcrzBitstringReader.__init__cCrNr')rÚBitstringReader_read)rrŸrrrÚreadfrSzBitstringReader.readN)rrr1rrrr rÚBitstringReader_code_getÚBitstringReader_code_setr›ÚBitstringReader_code_size_getÚBitstringReader_code_size_setrœÚBitstringReader_i_getÚBitstringReader_i_setr§rHr®Údelete_BitstringReaderrvrrrrrª\r©rªcCrŽ)ax Compute a set of Hamming distances between na and nb binary vectors :type a: uint8_t :param a: size na * nbytespercode :type b: uint8_t :param b: size nb * nbytespercode :type nbytespercode: int :param nbytespercode: should be multiple of 8 :type dis: int :param dis: output distances, size na * nb )rÚhammings)r“r…ÚnaÚnbÚ nbytespercodeÚdisrrrr¶nó r¶cGó tj|ŽS)a» Return the k smallest Hamming distances for a set of binary query vectors, using a max heap. :type a: uint8_t :param a: queries, size ha->nh * ncodes :type b: uint8_t :param b: database, size nb * ncodes :type nb: int :param nb: number of database vectors :type ncodes: int :param ncodes: size of the binary codes (bytes) :type ordered: int :param ordered: if != 0: order the results by decreasing distance (may be bottleneck for k/n > 0.01) :type approx_topk_mode: int, optional :param approx_topk_mode: allows to use approximate top-k facilities to speedup heap )rÚhammings_knn_hc©rFrrrr½}s r½cCrŽr')rÚ hammings_knn)Úhar“r…r¸ÚncodesÚorderedrrrr¿’r|r¿c Cót ||||||||¡S)a÷ Return the k smallest Hamming distances for a set of binary query vectors, using counting max. :type a: uint8_t :param a: queries, size na * ncodes :type b: uint8_t :param b: database, size nb * ncodes :type na: int :param na: number of query vectors :type nb: int :param nb: number of database vectors :type k: int :param k: number of vectors/distances to return :type ncodes: int :param ncodes: size of the binary codes (bytes) :type distances: int :param distances: output distances from each query vector to its k nearest neighbors :type labels: int :param labels: output ids of the k nearest neighbors to each query vector )rÚhammings_knn_mc)r“r…r·r¸ÚkrÁÚ distancesÚlabelsrrrrÄ•srÄc Cót |||||||¡S)zD same as hammings_knn except we are doing a range search with radius)rÚhamming_range_search)r“r…r·r¸ÚradiusrÁÚresultrrrrÉ­órÉc CrÈr')rÚhamming_count_thres)Úbs1Úbs2Ún1Ún2ÚhtrÁÚnptrrrrrͱr.rÍc CrÃr')rÚmatch_hamming_thres)rÎrÏrÐrÑrÒrÁÚidxrºrrrrÔ´rrÔcCrmr')rÚcrosshamming_count_thres)ÚdbsrQrÒrÁrÓrrrrÖ·rrrÖTcCrŽ)z_ generalized Hamming distances (= count number of code bytes that are the same) )rÚgeneralized_hammings_knn_hc)rÀr“r…r¸rœrÂrrrrغórØcCrJr')rÚ popcount32r7rrrrÚÁrMrÚcCrJr')rÚ popcount64r7rrrrÛÄrMrÛcCót ¡Sr')rÚ get_num_gpusrrrrrÝÇrIrÝcCrÜr')rÚgpu_profiler_startrrrrrÞÊrIrÞcCrÜr')rÚgpu_profiler_stoprrrrrßÍrIrßcCrÜr')rÚgpu_sync_all_devicesrrrrràÐrIràcCrÜ)z get compile options)rÚget_compile_optionsrrrrráÓórácCrÜ)z& ms elapsed since some arbitrary epoch)rÚ getmillisecsrrrrrã×rârãcCrÜ)z get current RSS usage in kB)rÚget_mem_usage_kbrrrrräÛrâräcCrÜr')rÚ get_cyclesrrrrråßrIråcCrm)zú compute c := a + bf * b for a, b and c tables :type n: int :param n: size of the tables :type a: float :param a: size n :type b: float :param b: size n :type c: float :param c: restult table, size n )rÚ fvec_madd©rQr“Úbfr…Úcrrrræâó ræcCrm)z‡ same as fvec_madd, also return index of the min of the result table :rtype: int :return: index of the min of table c )rÚfvec_madd_and_argminrçrrrrëñrsrëcCrmr')rÚ reflection)Úur8rQr†ÚnurrrrìùrrrìcCr‹)zƒ compute the Q of the QR decomposition for m > n :type a: float :param a: size n * m: input matrix and output Q )rÚ matrix_qr)ÚmrQr“rrrrïüórïcCr‹)zF distances are supposed to be sorted. Sorts indices with same distance)rÚranklist_handle_ties)rÅrÕrºrrrròóròcCr‡)z‰ count the number of common elements between v1 and v2 algorithm = sorting + bissection to avoid double-counting duplicates )rÚranklist_intersection_size)Úk1Úv1Úk2Úv2rrrrôórôc CrÃ)aå merge a result table into another one :type I0: int :param I0:, D0 first result table, size (n, k) :type I1: int :param I1:, D1 second result table, size (n, k) :type keep_min: boolean, optional :param keep_min: if true, keep min values, otherwise keep max :type translation: int, optional :param translation: add this value to all I1's indexes :rtype: int :return: nb of values that were taken from the second table )rÚmerge_result_table_with)rQrÅÚI0ÚD0ÚI1ÚD1Úkeep_minÚ translationrrrrúsrúcGr¼)z~ *Overload 1:* a balanced assignment has a IF of 1 | *Overload 2:* same, takes a histogram as input )rÚimbalance_factorr¾rrrr s rcCr‡)z compute histogram on v)rÚ ivec_hist)rQr=Úvmaxrrrrrr,órcCr‡)zÉ Compute histogram of bits on a code array :type codes: uint8_t :param codes: size(n, nbits / 8) :type hist: int :param hist: size(nbits): nb of 1s in the array of codes )rÚ bincode_hist)rQÚnbitsÚcodesrrrrrr0ó rcCrN)z compute a checksum on a table.)rÚ ivec_checksum)rQr“rrrr ;ó r FéÒcCrŽ)a random subsamples a set of vectors if there are too many of them :type d: int :param d: dimension of the vectors :type n: int :param n: on input: nb of input vectors, output: nb of output vectors :type nmax: int :param nmax: max nb of vectors to keep :type x: float :param x: input array, size *n-by-d :type seed: int, optional :param seed: random seed to use for sampling :rtype: float :return: x or an array allocated with new [] with *n vectors )rÚfvecs_maybe_subsample)r†rQÚnmaxr8ÚverboseÚseedrrrr ?sr cCr‹)a> Convert binary vector to +1/-1 valued float vector. :type d: int :param d: dimension of the vector (multiple of 8) :type x_in: uint8_t :param x_in: input binary vector (uint8_t table of size d / 8) :type x_out: float :param x_out: output float vector (float table of size d) )rÚbinary_to_real©r†Úx_inÚx_outrrrrRó rcCr‹)ae Convert float vector to binary vector. Components > 0 are converted to 1, others to 0. :type d: int :param d: dimension of the vector (multiple of 8) :type x_in: float :param x_in: input float vector (float table of size d) :type x_out: uint8_t :param x_out: output binary vector (uint8_t table of size d / 8) )rÚreal_to_binaryrrrrr_ó rcCrN)z A reasonable hashing function)rÚ hash_bytes)ÚbytesrQrrrrmr rcCrÜ)z+ Whether OpenMP annotations were respected.)rÚ check_openmprrrrrqrârcCr‹)z( Squared L2 distance between two vectors)rÚ fvec_L2sqr©r8Úyr†rrrrurórcCr‹)z inner product)rÚfvec_inner_productrrrrryrórcCr‹)z L1 distance)rÚfvec_L1rrrrr}rórcCr‹)z infinity distance)rÚ fvec_Linfrrrrrróréÿÿÿÿc Cót |||||||||¡ S)aí Compute pairwise distances between sets of vectors :type d: int :param d: dimension of the vectors :type nq: int :param nq: nb of query vectors :type nb: int :param nb: nb of database vectors :type xq: float :param xq: query vectors (size nq * d) :type xb: float :param xb: database vectors (size nb * d) :type dis: float :param dis: output distances (size nq * nb) :param ldq,ldb:, ldd strides for the matrices )rÚpairwise_L2sqr) r†ÚnqÚxqr¸ÚxbrºÚldqÚldbÚlddrrrr"…sr"cCrmr')rÚfvec_inner_products_ny)Úipr8rr†Únyrrrr)™rrr)cCrmr')rÚ fvec_L2sqr_ny)rºr8rr†r+rrrr,œrrr,c CrÈr')rÚfvec_L2sqr_ny_transposed)rºr8rÚy_sqlenr†Úd_offsetr+rrrr-Ÿr.r-cCrmr')rÚfvec_L2sqr_ny_nearest)Údistances_tmp_bufferr8rr†r+rrrr0¢rrr0c CrÈr')rÚ"fvec_L2sqr_ny_nearest_y_transposed)r1r8rr.r†r/r+rrrr2¥r.r2cCrN)z squared norm of a vector)rÚfvec_norm_L2sqr)r8r†rrrr3¨r r3cCr‡)z» compute the L2 norms for a set of vectors :type norms: float :param norms: output norms, size nx :type x: float :param x: set of vectors, size nx * d )rÚ fvec_norms_L2©Únormsr8r†Únxrrrr4¬rr4cCr‡)z2 same as fvec_norms_L2, but computes squared norms)rÚfvec_norms_L2sqrr5rrrr8·rr8cCr‹r')rÚfvec_renorm_L2)r†r7r8rrrr9»rr9cCrmr')rÚinner_product_to_L2sqr)rºÚnr1Únr2rÐrÑrrrr:¾rrr:cGr¼)až *Overload 1:* compute c := a + b for vectors c and a can overlap, c and b can overlap :type a: float :param a: size d :type b: float :param b: size d :type c: float :param c: size d | *Overload 2:* compute c := a + b for a, c vectors and b a scalar c and a can overlap :type a: float :param a: size d :type c: float :param c: size d )rÚfvec_addr¾rrrr=Ás r=cCr‡)zÐ compute c := a - b for vectors c and a can overlap, c and b can overlap :type a: float :param a: size d :type b: float :param b: size d :type c: float :param c: size d )rÚfvec_sub)r†r“r…rérrrr>Ýó r>c CrÈr')rÚfvec_inner_products_by_idx)r*r8rÚidsr†r7r+rrrr@ìr.r@c CrÈr')rÚfvec_L2sqr_by_idx)rºr8rrAr†r7r+rrrrBïr.rBc CrÈ)a2 compute dis[j] = L2sqr(x[ix[j]], y[iy[j]]) forall j=0..n-1 :type x: float :param x: size (max(ix) + 1, d) :type y: float :param y: size (max(iy) + 1, d) :type ix: int :param ix: size n :type iy: int :param iy: size n :type dis: float :param dis: size n )rÚpairwise_indexed_L2sqr©r†rQr8ÚixrÚiyrºrrrrCòsrCc CrÈr')rÚpairwise_indexed_inner_productrDrrrrGr.rGcGr¼)a÷ *Overload 1:* Return the k nearest neighors of each of the nx vectors x among the ny vector y, w.r.t to max inner product. :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type res: :py:class:`float_minheap_array_t` :param res: result heap structure, which also provides k. Sorted on output | *Overload 2:* Return the k nearest neighors of each of the nx vectors x among the ny vector y, for the inner product metric. :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k | *Overload 3:* Return the k nearest neighors of each of the nx vectors x among the ny vector y, for the inner product metric. :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k )rÚknn_inner_productr¾rrrrHs +rHcGr¼)aO *Overload 1:* Return the k nearest neighors of each of the nx vectors x among the ny vector y, for the L2 distance :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type res: :py:class:`float_maxheap_array_t` :param res: result heap strcture, which also provides k. Sorted on output :type y_norm2: float, optional :param y_norm2: (optional) norms for the y vectors (nullptr or size ny) :type sel: :py:class:`IDSelector`, optional :param sel: search in this subset of vectors | *Overload 2:* Return the k nearest neighors of each of the nx vectors x among the ny vector y, for the L2 distance :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k :type y_norm2: float, optional :param y_norm2: (optional) norms for the y vectors (nullptr or size ny) :type sel: :py:class:`IDSelector`, optional :param sel: search in this subset of vectors | *Overload 3:* Return the k nearest neighors of each of the nx vectors x among the ny vector y, for the L2 distance :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k :type y_norm2: float, optional :param y_norm2: (optional) norms for the y vectors (nullptr or size ny) :param sel: search in this subset of vectors | *Overload 4:* Return the k nearest neighors of each of the nx vectors x among the ny vector y, for the L2 distance :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k :param y_norm2: (optional) norms for the y vectors (nullptr or size ny) :param sel: search in this subset of vectors )rÚ knn_L2sqrr¾rrrrI3s FrIc Cót |||||||||| ¡ S)a= Find the max inner product neighbors for nx queries in a set of ny vectors indexed by ids. May be useful for re-ranking a pre-selected vector list :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size (max(ids) + 1) * d :type ids: int :param ids: subset of database vectors to consider, size (nx, nsubset) :param res: result structure :type ld_ids: int, optional :param ld_ids: stride for the ids array. -1: use nsubset, 0: all queries process the same subset )rÚknn_inner_products_by_idx) r8rÚsubsetr†r7ÚnsubsetrÅÚvalsrAÚld_idsrrrrK{órKc CrJ)aC Find the nearest neighbors for nx queries in a set of ny vectors indexed by ids. May be useful for re-ranking a pre-selected vector list :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size (max(ids) + 1) * d :type subset: int :param subset: subset of database vectors to consider, size (nx, nsubset) :param res: rIDesult structure :type ld_subset: int, optional :param ld_subset: stride for the subset array. -1: use nsubset, 0: all queries process the same subset )rÚknn_L2sqr_by_idx) r8rrLr†r7rMrÅrNrAÚ ld_subsetrrrrQrPrQc CrÃ)a£ Return the k nearest neighors of each of the nx vectors x among the ny vector y, w.r.t to max inner product :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type radius: float :param radius: search radius around the x vectors :type result: :py:class:`RangeSearchResult` :param result: result structure )rÚrange_search_L2sqr©r8rr†r7r+rÊrËÚselrrrrSŸsrSc CrÃ)z< same as range_search_L2sqr for the inner product similarity)rÚrange_search_inner_productrTrrrrV¯órVc CrÈ)z specialized function for PQ2)rÚcompute_PQ_dis_tables_dsub2)r†ÚksubÚ centroidsr7r8Úis_inner_productÚ dis_tablesrrrrX³rÌrXc@sheZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z d d „Z d d „Zd d„Zddd„ZejZdS)ÚRandomGeneratorz< random generator that can be used in multithreaded contextscCr5r'r6r7rrrr9¹r:zRandomGenerator.cCr;r'r6r<rrrr9¹r>r?r@cCrJ)z random int64_t)rÚRandomGenerator_rand_int64rLrrrÚ rand_int64½ó zRandomGenerator.rand_int64cGrn)z• *Overload 1:* random positive integer | *Overload 2:* generate random integer between 0 and max-1 )rÚRandomGenerator_rand_intrprrrÚrand_intÁó zRandomGenerator.rand_intcCrJ)z between 0 and 1)rÚRandomGenerator_rand_floatrLrrrÚ rand_floatÍr`zRandomGenerator.rand_floatcCrJr')rÚRandomGenerator_rand_doublerLrrrÚ rand_doubleÑrMzRandomGenerator.rand_doubler cCót |t |¡¡dSr')rÚRandomGenerator_swiginitÚnew_RandomGenerator©rrrrrrHÔr.zRandomGenerator.__init__N)r )rrr1r2rrrr rÚRandomGenerator_mt_getÚRandomGenerator_mt_setÚmtr_rbrergrHÚdelete_RandomGeneratorrvrrrrr]¶s   r]cCr‹r')rÚ float_rand©r8rQrrrrrpÝrrpcCr‹r')rÚ float_randnrqrrrrràrrrcCr‹r')rÚ int64_randrqrrrrsãrrscCr‹r')rÚ byte_randrqrrrrtærrtcCr‡r')rÚint64_rand_max)r8rQÚmaxrrrrruér‰rucCr‹r')rÚ rand_perm)ÚpermrQrrrrrwìrrwcCr‡r')rÚrand_smooth_vectors)rQr†r8rrrrryïr‰rycCr‹)a) Indirect sort of a floating-point array :type n: int :param n: size of the array :type vals: float :param vals: array to sort, size n :type perm: int :param perm: output: permutation of [0..n-1], st. vals[perm[i + 1]] >= vals[perm[i]] )rÚ fvec_argsort©rQrNrxrrrrzòrrzcCr‹)z# Same as fvec_argsort, parallelized)rÚfvec_argsort_parallelr{rrrr|rór|cCrŽ)a Bucket sort of a list of values :type vals: int :param vals: values to sort, size nval, max value nbucket - 1 :type lims: int :param lims: output limits of buckets, size nbucket + 1 :type perm: int :param perm: output buckets, the elements of bucket i are in perm[lims[i]:lims[i + 1]] :type nt: int, optional :param nt: number of threads (0 = pure sequential code) )rÚ bucket_sort)ÚnvalrNÚnbucketÚlimsrxÚntrrrr}ór}cGr¼)a_ *Overload 1:* in-place bucket sort (with attention to memory=>int32) on input the values are in a nrow * col matrix we want to store the row numbers in the output. :type vals: int :param vals: positive values to sort, size nrow * ncol, max value nbucket - 1 :type lims: int :param lims: output limits of buckets, size nbucket + 1 :type nt: int, optional :param nt: number of threads (0 = pure sequential code) | *Overload 2:* same with int64 elements | *Overload 3:* same with int64 elements )rÚmatrix_bucket_sort_inplacer¾rrrrƒs rƒcCrJ)zŸ this function is used to distinguish between min and max indexes since we need to support similarity and dis-similarity metrics in a flexible way )rÚis_similarity_metric)Ú metric_typerrrr„Eó r„c@sJeZdZdZedd„dd„ddZeZeej ej ddZ ej Z dd „Zd S) ÚSearchParameterszÆ Parent class for the optional search paramenters. Sub-classes with additional search parameters should inherit this class. Ownership of the object fields is always to the caller. cCr5r'r6r7rrrr9\r:zSearchParameters.cCr;r'r6r<rrrr9\r>r?r@z> if non-null, only these IDs will be considered during search.cCryr')rÚSearchParameters_swiginitÚnew_SearchParametersrLrrrrHar|zSearchParameters.__init__N)rrr1r2rrrr rÚSearchParameters_sel_getÚSearchParameters_sel_setrUÚdelete_SearchParametersrvrHrrrrr‡Ts r‡c@sNeZdZdZedd„dd„ddZdd„ZeZee j e j d dZ ee j e jd dZee je jd dZee je jd dZee je jd dZee je jddZe jZdd„Zdd„Zdd„Z d:dd„Z!d:dd„Z"d;dd„Z#dd„Z$dd „Z%d!d"„Z&d#d$„Z'd%d&„Z(d:d'd(„Z)d)d*„Z*d+d,„Z+d-d.„Z,d/d0„Z-d1d2„Z.d3d4„Z/dcCr;r'r6r<rrrr9or>r?r@cOrBrCrDrErrrrHqrIzIndex.__init__ú vector dimensionú total nb of indexed vectorsú verbosity levelzX set if the Index does not require training, or if training is done already ú* type of metric this index uses for searchz argument of the metric typecCr‹)zÔ Perform training on a representative set of vectors :type n: int :param n: nb of training vectors :type x: float :param x: training vecors, size n * d )rÚ Index_train©rrQr8rrrÚtrainó z Index.traincCr‹)a= Add n vectors of dimension d to the index. Vectors are implicitly assigned labels ntotal .. ntotal + n - 1 This function slices the input vectors in chunks smaller than blocksize_add and calls add_core. :type x: float :param x: input matrix, size n * d )rÚ Index_addr“rrrÚaddŠó z Index.addcCr‡©a Same as add, but stores xids instead of sequential ids. The default implementation fails with an assertion, as it is not supported by all indexes. :type xids: int :param xids: if non-null, ids to store for the vectors (size n) )rÚIndex_add_with_ids©rrQr8ÚxidsrrrÚ add_with_ids–ó zIndex.add_with_idsNc CrÈ)aÌ query n vectors of dimension d to the index. return at most k vectors. If there are not enough results for a query, the result array is padded with -1s. :type x: float :param x: input vectors to search, size n * d :type labels: int :param labels: output labels of the NNs, size n*k :type distances: float :param distances: output pairwise distances, size n*k )rÚ Index_search©rrQr8rÅrÆrÇÚparamsrrrÚsearch¢óz Index.searchcCrŽ)aÜ query n vectors of dimension d to the index. return all vectors with distance < radius. Note that many indexes do not implement the range_search (only the k-NN search is mandatory). :type x: float :param x: input vectors to search, size n * d :type radius: float :param radius: search radius :type result: :py:class:`RangeSearchResult` :param result: result table )rÚIndex_range_search©rrQr8rÊrËr¡rrrÚ range_search²ózIndex.range_searchrcCrm)aQ return the indexes of the k vectors closest to the query x. This function is identical as search but only return labels of neighbors. :type x: float :param x: input vectors to search, size n * d :type labels: int :param labels: output labels of the NNs, size n*k )rÚ Index_assign©rrQr8rÇrÅrrrÚassignÃrcz Index.assigncCrJ)z( removes all elements from the database.)rÚ Index_resetrLrrrr{Ïr`z Index.resetcCrN)z| removes IDs from the index. Not supported by all indexes. Returns the number of elements removed. )rÚIndex_remove_ids©rrUrrrÚ remove_idsÓó zIndex.remove_idscCr‹)a7 Reconstruct a stored vector (or an approximation if lossy coding) this function may not be defined for some indexes :type key: int :param key: id of the vector to reconstruct :type recons: float :param recons: reconstucted vector (size d) )rÚIndex_reconstruct©rÚkeyÚreconsrrrÚ reconstructÚr˜zIndex.reconstructcCr‡)a Reconstruct several stored vectors (or an approximation if lossy coding) this function may not be defined for some indexes :type n: int :param n: number of vectors to reconstruct :type keys: int :param keys: ids of the vectors to reconstruct (size n) :type recons: float :param recons: reconstucted vector (size n * d) )rÚIndex_reconstruct_batch)rrQÚkeysr³rrrÚreconstruct_batchæó zIndex.reconstruct_batchcCr‡)zÍ Reconstruct vectors i0 to i0 + ni - 1 this function may not be defined for some indexes :type recons: float :param recons: reconstucted vector (size ni * d) )rÚIndex_reconstruct_n©rÚi0Únir³rrrÚ reconstruct_nôózIndex.reconstruct_nc CrÃ)ae Similar to search, but also reconstructs the stored vectors (or an approximation in the case of lossy coding) for the search results. If there are not enough results for a query, the resulting arrays is padded with -1s. :type recons: float :param recons: reconstructed vectors size (n, k, d) )rÚIndex_search_and_reconstruct©rrQr8rÅrÆrÇr³r¡rrrÚsearch_and_reconstructþó zIndex.search_and_reconstructcCr‡)aK Computes a residual vector after indexing encoding. The residual vector is the difference between a vector and the reconstruction that can be decoded from its representation in the index. The residual can be used for multiple-stage indexing methods, like IndexIVF's methods. :type x: float :param x: input vector, size d :type residual: float :param residual: output residual vector, size d :type key: int :param key: encoded index, as returned by search and assign )rÚIndex_compute_residual)rr8Úresidualr²rrrÚcompute_residual szIndex.compute_residualcCrm)aì Computes a residual vector after indexing encoding (batch form). Equivalent to calling compute_residual for each vector. The residual vector is the difference between a vector and the reconstruction that can be decoded from its representation in the index. The residual can be used for multiple-stage indexing methods, like IndexIVF's methods. :type n: int :param n: number of vectors :type xs: float :param xs: input vectors, size (n x d) :type residuals: float :param residuals: output residual vectors, size (n x d) :type keys: int :param keys: encoded index, as returned by search and assign )rÚIndex_compute_residual_n)rrQÚxsÚ residualsr¶rrrÚcompute_residual_nszIndex.compute_residual_ncCrJ)zÚ Get a DistanceComputer (defined in AuxIndexStructures) object for this kind of index. DistanceComputer is implemented for indexes that support random access of their vectors. )rÚIndex_get_distance_computerrLrrrÚget_distance_computer2s zIndex.get_distance_computercCrJ)z$ size of the produced codes in bytes)rÚIndex_sa_code_sizerLrrrÚ sa_code_size<r`zIndex.sa_code_sizecCr‡)a encode a set of vectors :type n: int :param n: number of vectors :type x: float :param x: input vectors, size n * d :type bytes: uint8_t :param bytes: output encoded vectors, size n * sa_code_size() )rÚIndex_sa_encode©rrQr8rrrrÚ sa_encode@ó zIndex.sa_encodecCr‡)a decode a set of vectors :type n: int :param n: number of vectors :type bytes: uint8_t :param bytes: input encoded vectors, size n * sa_code_size() :type x: float :param x: output vectors, size n * d )rÚIndex_sa_decode©rrQrr8rrrÚ sa_decodeMrÑzIndex.sa_decodercCr‹©zÇ moves the entries from another dataset to self. On output, other is empty. add_id is added to all moved ids (for sequential ids, this would be this->ntotal) )rÚIndex_merge_from©rÚ otherIndexÚadd_idrrrÚ merge_fromZózIndex.merge_fromcCrN©z¢ check that the two indexes are compatible (ie, they are trained in the same way and have the same parameters). Otherwise throw. )rÚ Index_check_compatible_for_merge©rrØrrrÚcheck_compatible_for_mergecó z Index.check_compatible_for_merger'rt©r)2rrr1r2rrrHrr rÚ Index_d_getÚ Index_d_setr†ÚIndex_ntotal_getÚIndex_ntotal_setÚntotalÚIndex_verbose_getÚIndex_verbose_setrÚIndex_is_trained_getÚIndex_is_trained_setÚ is_trainedÚIndex_metric_type_getÚIndex_metric_type_setr…ÚIndex_metric_arg_getÚIndex_metric_arg_setÚ metric_argÚ delete_Indexrvr”r—rr¢r¦rªr{r®r´r·r½rÁrÅrÉrËrÍrÐrÔrÚrßrrrrrgs@         rc@óPeZdZdZedd„dd„ddZdd„ZeZd d „Z d d „Z d d„Z e j ZdS)ÚDistanceComputerú» Copyright (c) Facebook, Inc. and its affiliates. This source code is licensed under the MIT license found in the LICENSE file in the root directory of this source tree. cCr5r'r6r7rrrr9vr:zDistanceComputer.cCr;r'r6r<rrrr9vr>r?r@cOrBrCrDrErrrrHxrIzDistanceComputer.__init__cCrN)zv called before computing distances. Pointer x should remain valid while operator () is called )rÚDistanceComputer_set_queryrWrrrÚ set_query|r¯zDistanceComputer.set_querycCrN)z. compute distance of vector i to current query)rÚDistanceComputer___call__©rr§rrrÚ__call__ƒr zDistanceComputer.__call__cCr‹)z, compute distance between two stored vectors)rÚDistanceComputer_symmetric_dis©rr§ÚjrrrÚ symmetric_dis‡rózDistanceComputer.symmetric_disN)rrr1r2rrrHrr rörùrýrÚdelete_DistanceComputerrvrrrrróns róc@s`eZdZedd„dd„ddZdd„ZeZeej ej ƒZ eej ej ƒZdd „Zd d „ZejZd S) ÚFlatCodesDistanceComputercCr5r'r6r7rrrr9r:z"FlatCodesDistanceComputer.cCr;r'r6r<rrrr9r>r?r@cOrBrCrDrErrrrH’rIz"FlatCodesDistanceComputer.__init__cCrNr')rÚ"FlatCodesDistanceComputer___call__rørrrrù˜rSz"FlatCodesDistanceComputer.__call__cCrN)z7 compute distance of current query to an encoded vector)rÚ*FlatCodesDistanceComputer_distance_to_code©rr›rrrÚdistance_to_code›r z*FlatCodesDistanceComputer.distance_to_codeN)rrr1rrrHrr rÚ#FlatCodesDistanceComputer_codes_getÚ#FlatCodesDistanceComputer_codes_setrÚ'FlatCodesDistanceComputer_code_size_getÚ'FlatCodesDistanceComputer_code_size_setrœrùrÚ delete_FlatCodesDistanceComputerrvrrrrrÿs rÿc@s²eZdZdZedd„dd„ddZdd„ZeZee j e j ƒZ ee j e jd dZd d „Zd d „Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zd"dd „Ze jZd!S)#ÚIndexFlatCodeszr Index that encodes all vectors as fixed-size codes (size code_size). Storage is in the codes vector cCr5r'r6r7rrrr9©r:zIndexFlatCodes.cCr;r'r6r<rrrr9©r>r?r@cOrBrCrDrErrrrH«rIzIndexFlatCodes.__init__z) encoded dataset, size ntotal * code_sizecCr‹)z default add uses sa_encode)rÚIndexFlatCodes_addr“rrrr—±rózIndexFlatCodes.addcCrJr')rÚIndexFlatCodes_resetrLrrrr{µrMzIndexFlatCodes.resetcCr‡)z) reconstruction using the codec interface)rÚIndexFlatCodes_reconstruct_nrºrrrr½¸rzIndexFlatCodes.reconstruct_ncCr‹r')rÚIndexFlatCodes_reconstructr±rrrr´¼rzIndexFlatCodes.reconstructcCrJr')rÚIndexFlatCodes_sa_code_sizerLrrrrÍ¿rMzIndexFlatCodes.sa_code_sizecCrN)z½ remove some ids. NB that because of the structure of the index, the semantics of this operation are different from the usual ones: the new ids are shifted )rÚIndexFlatCodes_remove_idsr­rrrr®ÂràzIndexFlatCodes.remove_idscCrJ)z= a FlatCodesDistanceComputer offers a distance_to_code method)rÚ,IndexFlatCodes_get_FlatCodesDistanceComputerrLrrrÚget_FlatCodesDistanceComputerÊr`z,IndexFlatCodes.get_FlatCodesDistanceComputercCrJr')rÚ$IndexFlatCodes_get_distance_computerrLrrrrËÎrMz$IndexFlatCodes.get_distance_computercCrJr')rÚIndexFlatCodes_get_CodePackerrLrrrÚget_CodePackerÑrMzIndexFlatCodes.get_CodePackercCrNr')rÚ)IndexFlatCodes_check_compatible_for_mergerÞrrrrßÔrSz)IndexFlatCodes.check_compatible_for_mergercCr‹r')rÚIndexFlatCodes_merge_fromr×rrrrÚ×rzIndexFlatCodes.merge_fromNrá)rrr1r2rrrHrr rÚIndexFlatCodes_code_size_getÚIndexFlatCodes_code_size_setrœÚIndexFlatCodes_codes_getÚIndexFlatCodes_codes_setrr—r{r½r´rÍr®rrËrrßrÚÚdelete_IndexFlatCodesrvrrrrr £s&  r c@s|eZdZdZedd„dd„ddZeZddd „Zdd d „Z d d „Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„ZejZdS)Ú IndexFlatzB Index that stores the full vectors and performs exhaustive searchcCr5r'r6r7rrrr9ár:zIndexFlat.cCr;r'r6r<rrrr9ár>r?r@Nc CrÈr')rÚIndexFlat_searchr rrrr¢är.zIndexFlat.searchcCrŽr')rÚIndexFlat_range_searchr¥rrrr¦çr|zIndexFlat.range_searchcCr‹r')rÚIndexFlat_reconstructr±rrrr´êrzIndexFlat.reconstructcCrŽ)a£ compute distance with a subset of vectors :type x: float :param x: query vectors, size n * d :type labels: int :param labels: indices of the vectors that should be compared for each query vector, size n * k :type distances: float :param distances: corresponding output distances, size n * k )rÚ!IndexFlat_compute_distance_subset)rrQr8rÅrÆrÇrrrÚcompute_distance_subsetír»z!IndexFlat.compute_distance_subsetcGrnr')rÚIndexFlat_get_xbrprrrÚget_xbürrzIndexFlat.get_xbcGót |tj|Ž¡dSr')rÚIndexFlat_swiginitÚ new_IndexFlatrprrrrHÿr.zIndexFlat.__init__cCrJr')rÚ'IndexFlat_get_FlatCodesDistanceComputerrLrrrrrMz'IndexFlat.get_FlatCodesDistanceComputercCr‡r')rÚIndexFlat_sa_encoderÏrrrrÐr‰zIndexFlat.sa_encodecCr‡r')rÚIndexFlat_sa_decoderÓrrrrÔr‰zIndexFlat.sa_decoder')rrr1r2rrrr r¢r¦r´r!r#rHrrÐrÔrÚdelete_IndexFlatrvrrrrrÞs   rc@ó4eZdZedd„dd„ddZeZdd„Zej Z dS) Ú IndexFlatIPcCr5r'r6r7rrrr9r:zIndexFlatIP.cCr;r'r6r<rrrr9r>r?r@cGr$r')rÚIndexFlatIP_swiginitÚnew_IndexFlatIPrprrrrHr.zIndexFlatIP.__init__N) rrr1rrrr rHrÚdelete_IndexFlatIPrvrrrrr,ó  r,c@r+) Ú IndexFlatL2cCr5r'r6r7rrrr9r:zIndexFlatL2.cCr;r'r6r<rrrr9r>r?r@cGr$r')rÚIndexFlatL2_swiginitÚnew_IndexFlatL2rprrrrHr.zIndexFlatL2.__init__N) rrr1rrrr rHrÚdelete_IndexFlatL2rvrrrrr1r0r1c@s€eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZdd d „Zd d „Zdd„Zdd„Zddd„ZejZdS)Ú IndexFlat1Dz$ optimized version for 1D "vectors".cCr5r'r6r7rrrr9(r:zIndexFlat1D.cCr;r'r6r<rrrr9(r>r?r@z) is the permutation updated continuously?z sorted database indicesTcCrhr')rÚIndexFlat1D_swiginitÚnew_IndexFlat1D)rÚcontinuous_updaterrrrH-r.zIndexFlat1D.__init__cCrJ)zg if not continuous_update, call this between the last add and the first search )rÚIndexFlat1D_update_permutationrLrrrÚupdate_permutation0r†zIndexFlat1D.update_permutationcCr‹r')rÚIndexFlat1D_addr“rrrr—7rzIndexFlat1D.addcCrJr')rÚIndexFlat1D_resetrLrrrr{:rMzIndexFlat1D.resetNc CrÈ)z+ Warn: the distances returned are L1 not L2)rÚIndexFlat1D_searchr rrrr¢=rÌzIndexFlat1D.search©Tr')rrr1r2rrrr rÚ!IndexFlat1D_continuous_update_getÚ!IndexFlat1D_continuous_update_setr8ÚIndexFlat1D_perm_getÚIndexFlat1D_perm_setrxrHr:r—r{r¢Údelete_IndexFlat1Drvrrrrr5%s   r5c@súeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejƒZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZ eej!ej"ddZ#eej$ej%ddZ&eej'ej(ddZ)dd„Z*ej+Z,dS)ÚClusteringParameterszn Class for the clustering parameters. Can be passed to the constructor of the Clustering object. cCr5r'r6r7rrrr9Kr:zClusteringParameters.cCr;r'r6r<rrrr9Kr>r?r@z clustering iterationsz. redo clustering this many times and keep bestz! do we want normalized centroids?z' round centroids coordinates to integerz% re-train index after each iteration?zZ use the centroids provided as input and do not change them during iterations z otherwise you get a warningz to limit size of datasetz% seed for the random number generatorz% how many vectors at a time to decodecCst |t ¡¡dS)z sets reasonable defaultsN)rÚClusteringParameters_swiginitÚnew_ClusteringParametersrLrrrrH\r”zClusteringParameters.__init__N)-rrr1r2rrrr rÚClusteringParameters_niter_getÚClusteringParameters_niter_setÚniterÚClusteringParameters_nredo_getÚClusteringParameters_nredo_setÚnredoÚ ClusteringParameters_verbose_getÚ ClusteringParameters_verbose_setrÚ"ClusteringParameters_spherical_getÚ"ClusteringParameters_spherical_setÚ sphericalÚ&ClusteringParameters_int_centroids_getÚ&ClusteringParameters_int_centroids_setÚ int_centroidsÚ%ClusteringParameters_update_index_getÚ%ClusteringParameters_update_index_setÚ update_indexÚ)ClusteringParameters_frozen_centroids_getÚ)ClusteringParameters_frozen_centroids_setÚfrozen_centroidsÚ0ClusteringParameters_min_points_per_centroid_getÚ0ClusteringParameters_min_points_per_centroid_setÚmin_points_per_centroidÚ0ClusteringParameters_max_points_per_centroid_getÚ0ClusteringParameters_max_points_per_centroid_setÚmax_points_per_centroidÚClusteringParameters_seed_getÚClusteringParameters_seed_setrÚ*ClusteringParameters_decode_block_size_getÚ*ClusteringParameters_decode_block_size_setÚdecode_block_sizerHÚdelete_ClusteringParametersrvrrrrrDEs" rDc@sŽeZdZedd„dd„ddZeZeejej ddZ eej ej ddZ eejejddZeejejd dZeejejd dZd d „ZejZd S)ÚClusteringIterationStatscCr5r'r6r7rrrr9er:z!ClusteringIterationStats.cCr;r'r6r<rrrr9er>r?r@z6 objective values (sum of distances reported by index)z seconds for iterationz seconds for just searchz imbalance factor of iterationz number of cluster splitscCryr')rÚ!ClusteringIterationStats_swiginitÚnew_ClusteringIterationStatsrLrrrrHmr|z!ClusteringIterationStats.__init__N)rrr1rrrr rÚ ClusteringIterationStats_obj_getÚ ClusteringIterationStats_obj_setÚobjÚ!ClusteringIterationStats_time_getÚ!ClusteringIterationStats_time_setÚtimeÚ(ClusteringIterationStats_time_search_getÚ(ClusteringIterationStats_time_search_setÚ time_searchÚ-ClusteringIterationStats_imbalance_factor_getÚ-ClusteringIterationStats_imbalance_factor_setrÚ#ClusteringIterationStats_nsplit_getÚ#ClusteringIterationStats_nsplit_setÚnsplitrHÚdelete_ClusteringIterationStatsrvrrrrrgds rgc@sœeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d „Zddd„Zddd„Zdd„ZejZd S)Ú ClusteringaÐ K-means clustering based on assignment - centroid update iterations The clustering is based on an Index object that assigns training points to the centroids. Therefore, at each iteration the centroids are added to the index. On output, the centoids table is set to the latest version of the centroids and they are also added to the index. If the centroids table it is not empty on input, it is also used for initialization. cCr5r'r6r7rrrr9‚r:zClustering.cCr;r'r6r<rrrr9‚r>r?r@ú dimension of the vectorsú nb of centroidszp centroids (k * d) if centroids are set on input to train, they will be used as initialization ú' stats at every iteration of clusteringcGr$r')rÚClustering_swiginitÚnew_ClusteringrprrrrHr.zClustering.__init__NcCrm)aH run k-means training :type x: float :param x: training vectors, size n * d :type index: :py:class:`Index` :param index: index used for assignment :type x_weights: float, optional :param x_weights: weight associated to each vector: NULL or size n )rÚClustering_train)rrQr8ÚindexÚ x_weightsrrrr”ó zClustering.traincCrŽ)aH run with encoded vectors win addition to train()'s parameters takes a codec as parameter to decode the input vectors. :type codec: :py:class:`Index` :param codec: codec used to decode the vectors (nullptr = vectors are in fact floats) * )rÚClustering_train_encoded)rr7rÚcodecr€ÚweightsrrrÚ train_encodeds zClustering.train_encodedcCrJ)z Post-process the centroids after each centroid update. includes optional L2 normalization and nearest integer rounding )rÚ!Clustering_post_process_centroidsrLrrrÚpost_process_centroidsªr†z!Clustering.post_process_centroidsr')rrr1r2rrrr rÚClustering_d_getÚClustering_d_setr†ÚClustering_k_getÚClustering_k_setrÅÚClustering_centroids_getÚClustering_centroids_setrZÚClustering_iteration_stats_getÚClustering_iteration_stats_setÚiteration_statsrHr”r†rˆÚdelete_Clusteringrvrrrrryts    ryc@ó@eZdZdZedd„dd„ddZeZdd„Zd d „Z e j Z d S) Ú Clustering1Dzw Exact 1D clustering algorithm Since it does not use an index, it does not overload the train() function cCr5r'r6r7rrrr9¼r:zClustering1D.cCr;r'r6r<rrrr9¼r>r?r@cGr$r')rÚClustering1D_swiginitÚnew_Clustering1DrprrrrH¿r.zClustering1D.__init__cCr‹r')rÚClustering1D_train_exactr“rrrÚ train_exactÂrzClustering1D.train_exactN) rrr1r2rrrr rHr˜rÚdelete_Clustering1Drvrrrrr”µs r”c@sXeZdZedd„dd„ddZeZeejej ddZ eej ej ddZ dd „ZejZd S) Ú"ProgressiveDimClusteringParameterscCr5r'r6r7rrrr9Êr:z+ProgressiveDimClusteringParameters.cCr;r'r6r<rrrr9Êr>r?r@z number of incremental stepsz apply PCA on inputcCryr')rÚ+ProgressiveDimClusteringParameters_swiginitÚ&new_ProgressiveDimClusteringParametersrLrrrrHÏr|z+ProgressiveDimClusteringParameters.__init__N)rrr1rrrr rÚcCr;r'r6r<rrrr9Ùr>r?r@cCrN)z ownership transferred to caller)rÚ#ProgressiveDimIndexFactory___call__)rÚdimrrrrùÜr z#ProgressiveDimIndexFactory.__call__cCryr')rÚ#ProgressiveDimIndexFactory_swiginitÚnew_ProgressiveDimIndexFactoryrLrrrrHár|z#ProgressiveDimIndexFactory.__init__N) rrr1r2rrrr rùrÚ!delete_ProgressiveDimIndexFactoryrvrHrrrrr¥Ös r¥c@sˆeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d „Zd d„ZejZdS)ÚProgressiveDimClusteringaÀ K-means clustering with progressive dimensions used The clustering first happens in dim 1, then with exponentially increasing dimension until d (I steps). This is typically applied after a PCA transformation (optional). Reference: "Improved Residual Vector Quantization for High-dimensional Approximate Nearest Neighbor Search" Shicong Liu, Hongtao Lu, Junru Shao, AAAI'15 https://arxiv.org/abs/1509.05195 cCr5r'r6r7rrrr9÷r:z!ProgressiveDimClustering.cCr;r'r6r<rrrr9÷r>r?r@rzr{z centroids (k * d)r|cGr$r')rÚ!ProgressiveDimClustering_swiginitÚnew_ProgressiveDimClusteringrprrrrHþr.z!ProgressiveDimClustering.__init__cCr‡r')rÚProgressiveDimClustering_train)rrQr8Úfactoryrrrr” r‰zProgressiveDimClustering.trainN)rrr1r2rrrr rÚProgressiveDimClustering_d_getÚProgressiveDimClustering_d_setr†ÚProgressiveDimClustering_k_getÚProgressiveDimClustering_k_setrÅÚ&ProgressiveDimClustering_centroids_getÚ&ProgressiveDimClustering_centroids_setrZÚ,ProgressiveDimClustering_iteration_stats_getÚ,ProgressiveDimClustering_iteration_stats_setr‘rHr”Údelete_ProgressiveDimClusteringrvrrrrr«çs r«cCrm)aƒ simplified interface :type d: int :param d: dimension of the data :type n: int :param n: nb of training vectors :type k: int :param k: nb of output centroids :type x: float :param x: training set (size n * d) :type centroids: float :param centroids: output centroids (size k * d) :rtype: float :return: final quantization error )rÚkmeans_clustering)r†rQrÅr8rZrrrr¹ ór¹c Cót |||||||||| | ¡ Sr')rÚpairwise_extra_distances) r†r#r$r¸r%rnrðrºr&r'r(rrrr¼ ór¼cCrm)zm get a DistanceComputer that refers to this type of distance and indexes a flat array of size nb )rÚget_extra_distance_computer)r†rnrðr¸r%rrrr¾ ór¾c@steZdZdZedd„dd„ddZdd„ZeZee j e j d dZ ee j e jd dZd d „Zd d„Zdd„Ze jZdS)Ú Quantizerú2 Product Quantizer. Implemented only for METRIC_L2cCr5r'r6r7rrrr9( r:zQuantizer.cCr;r'r6r<rrrr9( r>r?r@cOrBrCrDrErrrrH* rIzQuantizer.__init__z size of the input vectorsz bytes per indexed vectorcCr‹)zs Train the quantizer :type x: float :param x: training vectors, size n * d )rÚQuantizer_trainr“rrrr”0 rÛzQuantizer.traincCr‡)zÎ Quantize a set of vectors :type x: float :param x: input vectors, size n * d :type codes: uint8_t :param codes: output codes, size n * code_size )rÚQuantizer_compute_codes©rr8rrQrrrÚ compute_codes9 rzQuantizer.compute_codescCr‡)z¯ Decode a set of vectors :param codes: input codes, size n * code_size :type x: float :param x: output vectors, size n * d )rÚQuantizer_decode©rr›r8rQrrrÚdecodeD r¾zQuantizer.decodeN)rrr1r2rrrHrr rÚQuantizer_d_getÚQuantizer_d_setr†ÚQuantizer_code_size_getÚQuantizer_code_size_setrœr”rÅrÈÚdelete_QuantizerrvrrrrrÀ% s  rÀc@sÐeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZejZejZ ejZ ejZ ej Z! eej"ej#ƒZ$eej%ej&d dZ'eej(ej)d dZ*eej+ej,ddZ-eej.ej/ddZ0eej1ej2ddZ3dd„Z4dd„Z5dd„Z6dd„Z7dd„Z8dd„Z9dd„Z:dd „Z;d!d"„Zd'd(„Z?d)d*„Z@d+d,„ZAdcCr;r'r6r<rrrr9U r>r?r@z number of subquantizersz& number of bits per quantization indexz! dimensionality of each subvectorz* number of centroids for each subquantizerú verbose during training?z" parameters used during clusteringzR if non-NULL, use this index for assignment (should be of size d / M) zK Centroid table, size M * ksub * dsub. Layout: (M, ksub, dsub) zV Transposed centroid table, size M * ksub * dsub. Layout: (dsub, M, ksub) zK Squared lengths of centroids, size M * ksub Layout: (M, ksub) cCr‹)z1 return the centroids associated with subvector m)rÚProductQuantizer_get_centroids)rrðr§rrrÚ get_centroidsx rózProductQuantizer.get_centroidscCr‹r')rÚProductQuantizer_trainr“rrrr”| rzProductQuantizer.traincGr$r')rÚProductQuantizer_swiginitÚnew_ProductQuantizerrprrrrH r.zProductQuantizer.__init__cCrJ)z9 compute derived values when d, M and nbits have been set)rÚ#ProductQuantizer_set_derived_valuesrLrrrÚset_derived_values‚ r`z#ProductQuantizer.set_derived_valuescCr‹)z( Define the centroids for subquantizer m)rÚProductQuantizer_set_params)rrZrðrrrÚ set_params† rózProductQuantizer.set_paramscCr‹)z/ Quantize one vector with the product quantizer)rÚProductQuantizer_compute_code)rr8r›rrrÚ compute_codeŠ rózProductQuantizer.compute_codecCr‡)z) same as compute_code for several vectors)rÚProductQuantizer_compute_codesrÄrrrrÅŽ rzProductQuantizer.compute_codescCr‡)zn speed up code assignment using assign_index (non-const because the index is changed) )rÚ0ProductQuantizer_compute_codes_with_assign_indexrÄrrrÚcompute_codes_with_assign_index’ rùz0ProductQuantizer.compute_codes_with_assign_indexcGrnr')rÚProductQuantizer_decoderprrrrÈ™ rrzProductQuantizer.decodecCr‹)z| If we happen to have the distance tables precomputed, this is more efficient to compute the codes. )rÚ1ProductQuantizer_compute_code_from_distance_table)rÚtabr›rrrÚ compute_code_from_distance_tableœ óz1ProductQuantizer.compute_code_from_distance_tablecCr‹)aÜ Compute distance table for one vector. The distance table for x = [x_0 x_1 .. x_(M-1)] is a M * ksub matrix that contains dis_table (m, j) = || x_m - c_(m, j)||^2 for m = 0..M-1 and j = 0 .. ksub - 1 where c_(m, j) is the centroid no j of sub-quantizer m. :type x: float :param x: input vector size d :type dis_table: float :param dis_table: output table, size M * ksub )rÚ'ProductQuantizer_compute_distance_table©rr8Ú dis_tablerrrÚcompute_distance_table£ sz'ProductQuantizer.compute_distance_tablecCr‹r')rÚ)ProductQuantizer_compute_inner_prod_tablerärrrÚcompute_inner_prod_table¶ rz)ProductQuantizer.compute_inner_prod_tablecCr‡)a compute distance table for several vectors :type nx: int :param nx: nb of input vectors :type x: float :param x: input vector size nx * d :param dis_table: output table, size nx * M * ksub )rÚ(ProductQuantizer_compute_distance_tables©rr7r8r\rrrÚcompute_distance_tables¹ rz(ProductQuantizer.compute_distance_tablescCr‡r')rÚ*ProductQuantizer_compute_inner_prod_tablesrêrrrÚcompute_inner_prod_tablesÄ r‰z*ProductQuantizer.compute_inner_prod_tablesTc CrÈ)aS perform a search (L2 distance) :type x: float :param x: query vectors, size nx * d :type nx: int :param nx: nb of queries :type codes: uint8_t :param codes: database codes, size ncodes * code_size :type ncodes: int :param ncodes: nb of nb vectors :type res: :py:class:`float_maxheap_array_t` :param res: heap array to store results (nh == nx) :type init_finalize_heap: boolean, optional :param init_finalize_heap: initialize heap (input) and sort (output)? )rÚProductQuantizer_search©rr8r7rrÁÚresÚinit_finalize_heaprrrr¢Ç ózProductQuantizer.searchc CrÈ)z2 same as search, but with inner product similarity)rÚProductQuantizer_search_iprïrrrÚ search_ipÙ rÌzProductQuantizer.search_ipz Symmetric Distance TablecCrJr')rÚ"ProductQuantizer_compute_sdc_tablerLrrrÚcompute_sdc_tableÞ rMz"ProductQuantizer.compute_sdc_tablec CrÈr')rÚProductQuantizer_search_sdc)rÚqcodesr#ÚbcodesrÁrðrñrrrÚ search_sdcá r.zProductQuantizer.search_sdccCrJ)z‚ Sync transposed centroids with regular centroids. This call is needed if centroids were edited directly. )rÚ*ProductQuantizer_sync_transposed_centroidsrLrrrÚsync_transposed_centroidsä r†z*ProductQuantizer.sync_transposed_centroidscCrJ)z= Clear transposed centroids table so ones are no longer used.)rÚ+ProductQuantizer_clear_transposed_centroidsrLrrrÚclear_transposed_centroidsë r`z+ProductQuantizer.clear_transposed_centroidsNr>)Mrrr1r2rrrr rÚProductQuantizer_M_getÚProductQuantizer_M_setÚMÚProductQuantizer_nbits_getÚProductQuantizer_nbits_setrÚProductQuantizer_dsub_getÚProductQuantizer_dsub_setÚdsubÚProductQuantizer_ksub_getÚProductQuantizer_ksub_setrYÚProductQuantizer_verbose_getÚProductQuantizer_verbose_setrÚProductQuantizer_Train_defaultÚ Train_defaultÚ ProductQuantizer_Train_hot_startÚTrain_hot_startÚProductQuantizer_Train_sharedÚ Train_sharedÚ ProductQuantizer_Train_hypercubeÚTrain_hypercubeÚ$ProductQuantizer_Train_hypercube_pcaÚTrain_hypercube_pcaÚProductQuantizer_train_type_getÚProductQuantizer_train_type_setÚ train_typeÚProductQuantizer_cp_getÚProductQuantizer_cp_setÚcpÚ!ProductQuantizer_assign_index_getÚ!ProductQuantizer_assign_index_setÚ assign_indexÚProductQuantizer_centroids_getÚProductQuantizer_centroids_setrZÚ)ProductQuantizer_transposed_centroids_getÚ)ProductQuantizer_transposed_centroids_setÚtransposed_centroidsÚ)ProductQuantizer_centroids_sq_lengths_getÚ)ProductQuantizer_centroids_sq_lengths_setÚcentroids_sq_lengthsrÑr”rHrÖrØrÚrÅrÝrÈrárærèrërír¢rôÚProductQuantizer_sdc_table_getÚProductQuantizer_sdc_table_setÚ sdc_tablerörúrürþÚdelete_ProductQuantizerrvrrrrrÎR s\    rÎc@szeZdZedd„dd„ddZeZeejej ddZ eej ej ƒZ eejddZeejejƒZdd d „Zd d „ZejZd S)ÚPQEncoderGenericcCr5r'r6r7rrrr9ô r:zPQEncoderGeneric.cCr;r'r6r<rrrr9ô r>r?r@z code for this vectorz& number of bits per subquantizer indexrcCót |t |||¡¡dSr')rÚPQEncoderGeneric_swiginitÚnew_PQEncoderGeneric)rr›rÚoffsetrrrrHû ózPQEncoderGeneric.__init__cCrNr')rÚPQEncoderGeneric_encoderWrrrÚencodeþ rSzPQEncoderGeneric.encodeNrá)rrr1rrrr rÚPQEncoderGeneric_code_getÚPQEncoderGeneric_code_setr›ÚPQEncoderGeneric_offset_getÚPQEncoderGeneric_offset_setr.ÚPQEncoderGeneric_nbits_getrÚPQEncoderGeneric_reg_getÚPQEncoderGeneric_reg_setÚregrHr1Údelete_PQEncoderGenericrvrrrrr*ó s  r*c@óJeZdZedd„dd„ddZeZeejej ƒZ dd„Z dd „Z ej Zd S) Ú PQEncoder8cCr5r'r6r7rrrr9 r:zPQEncoder8.cCr;r'r6r<rrrr9 r>r?r@cCr—r')rÚPQEncoder8_swiginitÚnew_PQEncoder8©rr›rrrrrH rzPQEncoder8.__init__cCrNr')rÚPQEncoder8_encoderWrrrr1 rSzPQEncoder8.encodeN)rrr1rrrr rÚPQEncoder8_code_getÚPQEncoder8_code_setr›rHr1Údelete_PQEncoder8rvrrrrr< ó r<c@r;) Ú PQEncoder16cCr5r'r6r7rrrr9 r:zPQEncoder16.cCr;r'r6r<rrrr9 r>r?r@cCr—r')rÚPQEncoder16_swiginitÚnew_PQEncoder16r?rrrrH rzPQEncoder16.__init__cCrNr')rÚPQEncoder16_encoderWrrrr1 rSzPQEncoder16.encodeN)rrr1rrrr rÚPQEncoder16_code_getÚPQEncoder16_code_setr›rHr1Údelete_PQEncoder16rvrrrrrE rDrEc@szeZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejƒZeejƒZeejejƒZdd„Zdd „ZejZd S) ÚPQDecoderGenericcCr5r'r6r7rrrr9$ r:zPQDecoderGeneric.cCr;r'r6r<rrrr9$ r>r?r@cCr—r')rÚPQDecoderGeneric_swiginitÚnew_PQDecoderGenericr?rrrrH, rzPQDecoderGeneric.__init__cCrJr')rÚPQDecoderGeneric_decoderLrrrrÈ/ rMzPQDecoderGeneric.decodeN)rrr1rrrr rÚPQDecoderGeneric_code_getÚPQDecoderGeneric_code_setr›ÚPQDecoderGeneric_offset_getÚPQDecoderGeneric_offset_setr.ÚPQDecoderGeneric_nbits_getrÚPQDecoderGeneric_mask_getÚmaskÚPQDecoderGeneric_reg_getÚPQDecoderGeneric_reg_setr9rHrÈÚdelete_PQDecoderGenericrvrrrrrL# s   rLc@óPeZdZedd„dd„ddZeZejZ eej ej ƒZ dd„Z dd „ZejZd S) Ú PQDecoder8cCr5r'r6r7rrrr97 r:zPQDecoder8.cCr;r'r6r<rrrr97 r>r?r@cCr—r')rÚPQDecoder8_swiginitÚnew_PQDecoder8r?rrrrH< rzPQDecoder8.__init__cCrJr')rÚPQDecoder8_decoderLrrrrÈ? rMzPQDecoder8.decodeN)rrr1rrrr rÚPQDecoder8_nbitsrÚPQDecoder8_code_getÚPQDecoder8_code_setr›rHrÈÚdelete_PQDecoder8rvrrrrr[6 ó r[c@rZ) Ú PQDecoder16cCr5r'r6r7rrrr9G r:zPQDecoder16.cCr;r'r6r<rrrr9G r>r?r@cCr—r')rÚPQDecoder16_swiginitÚnew_PQDecoder16r?rrrrHL rzPQDecoder16.__init__cCrJr')rÚPQDecoder16_decoderLrrrrÈO rMzPQDecoder16.decodeN)rrr1rrrr rÚPQDecoder16_nbitsrÚPQDecoder16_code_getÚPQDecoder16_code_setr›rHrÈÚdelete_PQDecoder16rvrrrrrdF rcrdc@seZdZdZedd„dd„ddZdd„ZeZee j e j d dZ ee j e jd dZee je jd dZee je jƒZee je jd dZee je jd dZee je jddZee je j ddZ!ee j"e j#ddZ$ee j%e j&ddZ'ee j(e j)ddZ*ee j+e j,ddZ-ee j.e j/ddZ0dd„Z1dd„Z2dd„Z3e j4Z5 e j6Z7 e j8Z9 e j:Z; e jZ?e j@ZA e jBZCe jDZE e jFZG dd„ZHdd„ZIdd „ZJd8d"d#„ZKd9d%d&„ZLd'd(„ZMd:d)d*„ZNee jOe jPd+dZQee jRe jSd,dZTee jUe jVƒZWd-d.„ZXd;d0d1„ZYd2d3„ZZd4d5„Z[d6d7„Z\e j]Z^d!S)<ÚAdditiveQuantizerzë Abstract structure for additive quantizers Different from the product quantizer in which the decoded vector is the concatenation of M sub-vectors, additive quantizers sum M sub-vectors to get the decoded vector. cCr5r'r6r7rrrr9_ r:zAdditiveQuantizer.cCr;r'r6r<rrrr9_ r>r?r@cOrBrCrDrErrrrHa rIzAdditiveQuantizer.__init__z number of codebooksz bits for each stepz codebooksz' total number of bits (indexes + norms)z bits allocated for the normsz size of the codebook in vectorsz' are all nbits = 8 (use faster decoder)rÏz is trained or notz store and search normszG store norms of codebook entries for 4-bit fastscan search z norms and distance matrixes with beam search can get large, so use this to control for the amount of memory that can be allocated cCrN)z" encode a norm into norm_bits bits)rÚAdditiveQuantizer_encode_norm)rÚnormrrrÚ encode_normx r zAdditiveQuantizer.encode_normcCrN)z/ encode norm by non-uniform scalar quantization)rÚAdditiveQuantizer_encode_qcintrWrrrÚ encode_qcint| r zAdditiveQuantizer.encode_qcintcCrN)z/ decode norm by non-uniform scalar quantization)rÚAdditiveQuantizer_decode_qcint©rrérrrÚ decode_qcint€ r zAdditiveQuantizer.decode_qcintcCrJ)z Train the norm quantizer)rÚ$AdditiveQuantizer_set_derived_valuesrLrrrrÖŸ r`z$AdditiveQuantizer.set_derived_valuescCr‹r')rÚAdditiveQuantizer_train_norm)rrQr6rrrÚ train_norm£ rzAdditiveQuantizer.train_normcCr‡r')rÚAdditiveQuantizer_compute_codesrÄrrrrŦ r‰zAdditiveQuantizer.compute_codesNcCrm©a7 Encode a set of vectors :type x: float :param x: vectors to encode, size n * d :type codes: uint8_t :param codes: output codes, size n * code_size :type centroids: float, optional :param centroids: centroids to be added to x, size n * d )rÚ-AdditiveQuantizer_compute_codes_add_centroids©rr8rrQrZrrrÚcompute_codes_add_centroids© r‚z-AdditiveQuantizer.compute_codes_add_centroidsr c CrÈ)an pack a series of code to bit-compact format :type codes: int :param codes: codes to be packed, size n * code_size :type packed_codes: uint8_t :param packed_codes: output bit-compact codes :type ld_codes: int, optional :param ld_codes: leading dimension of codes :type norms: float, optional :param norms: norms of the vectors (size n). Will be computed if needed but not provided :type centroids: float, optional :param centroids: centroids to be added to x, size n * d )rÚAdditiveQuantizer_pack_codes)rrQrÚ packed_codesÚld_codesr6rZrrrÚ pack_codes¶ ròzAdditiveQuantizer.pack_codescCr‡©zÌ Decode a set of vectors :type codes: uint8_t :param codes: codes to decode, size n * code_size :type x: float :param x: output vectors, size n * d )rÚAdditiveQuantizer_decode©rrr8rQrrrrÈÈ rzAdditiveQuantizer.decodecCrm©zÜ Decode a set of vectors in non-packed format :type codes: int :param codes: codes to decode, size n * ld_codes :type x: float :param x: output vectors, size n * d )rÚ!AdditiveQuantizer_decode_unpacked©rrr8rQrrrrÚdecode_unpackedÓ ó z!AdditiveQuantizer.decode_unpackedz$ Also determines what's in the codesz" min/max for quantization of normscCr‹)z. decoding function for a code in a 64-bit word)rÚAdditiveQuantizer_decode_64bitr“rrrÚ decode_64bitá rózAdditiveQuantizer.decode_64bitçð?cCrŽ)a½ Compute inner-product look-up tables. Used in the centroid search functions. :type xq: float :param xq: query vector, size (n, d) :type LUT: float :param LUT: look-up table, size (n, total_codebook_size) :type alpha: float, optional :param alpha: compute alpha * inner-product :type ld_lut: int, optional :param ld_lut: leading dimension of LUT )rÚAdditiveQuantizer_compute_LUT©rrQr$ÚLUTÚalphaÚld_lutrrrÚ compute_LUTå r‚zAdditiveQuantizer.compute_LUTcCrŽ)z exact IP search)rÚ-AdditiveQuantizer_knn_centroids_inner_product)rrQr$rÅrÆrÇrrrÚknn_centroids_inner_productõ r”z-AdditiveQuantizer.knn_centroids_inner_productcCrN)z¨ For L2 search we need the L2 norms of the centroids :type norms: float :param norms: output norms table, size total_codebook_size )rÚ(AdditiveQuantizer_compute_centroid_norms)rr6rrrÚcompute_centroid_normsù ó z(AdditiveQuantizer.compute_centroid_normsc CrÈ)z( Exact L2 search, with precomputed norms)rÚ"AdditiveQuantizer_knn_centroids_L2)rrQr$rÅrÆrÇÚcentroid_normsrrrÚknn_centroids_L2 rÌz"AdditiveQuantizer.knn_centroids_L2r')r NN©r ©r‹r )_rrr1r2rrrHrr rÚAdditiveQuantizer_M_getÚAdditiveQuantizer_M_setrÚAdditiveQuantizer_nbits_getÚAdditiveQuantizer_nbits_setrÚAdditiveQuantizer_codebooks_getÚAdditiveQuantizer_codebooks_setÚ codebooksÚ&AdditiveQuantizer_codebook_offsets_getÚ&AdditiveQuantizer_codebook_offsets_setÚcodebook_offsetsÚAdditiveQuantizer_tot_bits_getÚAdditiveQuantizer_tot_bits_setÚtot_bitsÚAdditiveQuantizer_norm_bits_getÚAdditiveQuantizer_norm_bits_setÚ norm_bitsÚ)AdditiveQuantizer_total_codebook_size_getÚ)AdditiveQuantizer_total_codebook_size_setÚtotal_codebook_sizeÚAdditiveQuantizer_only_8bit_getÚAdditiveQuantizer_only_8bit_setÚ only_8bitÚAdditiveQuantizer_verbose_getÚAdditiveQuantizer_verbose_setrÚ AdditiveQuantizer_is_trained_getÚ AdditiveQuantizer_is_trained_setrëÚAdditiveQuantizer_qnorm_getÚAdditiveQuantizer_qnorm_setÚqnormÚAdditiveQuantizer_norm_tabs_getÚAdditiveQuantizer_norm_tabs_setÚ norm_tabsÚ'AdditiveQuantizer_max_mem_distances_getÚ'AdditiveQuantizer_max_mem_distances_setÚmax_mem_distancesrorqrtÚAdditiveQuantizer_ST_decompressÚ ST_decompressÚAdditiveQuantizer_ST_LUT_nonormÚ ST_LUT_nonormÚ"AdditiveQuantizer_ST_norm_from_LUTÚST_norm_from_LUTÚAdditiveQuantizer_ST_norm_floatÚ ST_norm_floatÚAdditiveQuantizer_ST_norm_qint8Ú ST_norm_qint8ÚAdditiveQuantizer_ST_norm_qint4Ú ST_norm_qint4Ú AdditiveQuantizer_ST_norm_cqint8ÚST_norm_cqint8Ú AdditiveQuantizer_ST_norm_cqint4ÚST_norm_cqint4Ú AdditiveQuantizer_ST_norm_lsq2x4ÚST_norm_lsq2x4ÚAdditiveQuantizer_ST_norm_rq2x4Ú ST_norm_rq2x4rÖrwrÅr|r€rÈr‡Ú!AdditiveQuantizer_search_type_getÚ!AdditiveQuantizer_search_type_setÚ search_typeÚAdditiveQuantizer_norm_min_getÚAdditiveQuantizer_norm_min_setÚnorm_minÚAdditiveQuantizer_norm_max_getÚAdditiveQuantizer_norm_max_setÚnorm_maxrŠr‘r“r•r™Údelete_AdditiveQuantizerrvrrrrrlV sn      rlc@sLeZdZdZedd„dd„ddZeZeej ej ddZ ej Z ejZ ejZ eejejddZejZ ejZ eejejd dZeejejd dZeejej d dZ!eej"ej#d dZ$eej%ej&d dZ'dd„Z(dd„Z)d%dd„Z*dd„Z+d&dd„Z,d'dd„Z-d&dd„Z.d(dd „Z/d!d"„Z0eej1ej2d#dZ3eej4ej5d$dZ6ej7Z8dS))ÚResidualQuantizera Residual quantizer with variable number of bits per sub-quantizer The residual centroids are stored in a big cumulative centroid table. The codes are represented either as a non-compact table of size (n, M) or as the compact output (n, code_size). cCr5r'r6r7rrrr9 r:zResidualQuantizer.cCr;r'r6r<rrrr9 r>r?r@z% Binary or of the Train_* flags belowz. number of iterations for codebook refinement.z- beam size used for training and for encodingz use LUT for beam searchza Currently used mode of approximate min-k computations. Default value is EXACT_TOPK. z clustering parametersz+ if non-NULL, use this index for assignmentcGr$r')rÚResidualQuantizer_swiginitÚnew_ResidualQuantizerrprrrrH0 r.zResidualQuantizer.__init__cCr‹)z Train the residual quantizer)rÚResidualQuantizer_trainr“rrrr”3 rózResidualQuantizer.trainrcCr‹)z< Copy the M codebook levels from other, starting from skip_M)rÚ!ResidualQuantizer_initialize_from)rrÚskip_MrrrÚinitialize_from7 róz!ResidualQuantizer.initialize_fromcCr‹)a’ Encode the vectors and compute codebook that minimizes the quantization error on these codes :type x: float :param x: training vectors, size n * d :type n: int :param n: nb of training vectors, n >= total_codebook_size :rtype: float :return: returns quantization error for the new codebook with old codes )rÚ%ResidualQuantizer_retrain_AQ_codebookr“rrrÚretrain_AQ_codebook; s z%ResidualQuantizer.retrain_AQ_codebookNcCrmry)rÚ-ResidualQuantizer_compute_codes_add_centroidsr{rrrr|J r‚z-ResidualQuantizer.compute_codes_add_centroidsc CrÃ)aù lower-level encode function :type n: int :param n: number of vectors to hanlde :type residuals: float :param residuals: vectors to encode, size (n, beam_size, d) :type beam_size: int :param beam_size: input beam size :type new_beam_size: int :param new_beam_size: output beam size (should be <= K * beam_size) :type new_codes: int :param new_codes: output codes, size (n, new_beam_size, m + 1) :type new_residuals: float, optional :param new_residuals: output residuals, size (n, new_beam_size, d) :type new_distances: float, optional :param new_distances: output distances, size (n, new_beam_size) )rÚResidualQuantizer_refine_beam)rrQÚ beam_sizerÈÚ new_beam_sizeÚ new_codesÚ new_residualsÚ new_distancesrrrÚ refine_beamW szResidualQuantizer.refine_beamc CrÈr')rÚ!ResidualQuantizer_refine_beam_LUT)rrQÚ query_normsÚquery_cprérêrìrrrÚrefine_beam_LUTl r.z!ResidualQuantizer.refine_beam_LUTr cCrN)zþ Beam search can consume a lot of memory. This function estimates the amount of mem used by refine_beam to adjust the batch size :type beam_size: int, optional :param beam_size: if != -1, override the beam size )rÚ"ResidualQuantizer_memory_per_point)rrèrrrÚmemory_per_pointo ó z"ResidualQuantizer.memory_per_pointcCrJ)zu Cross products used in codebook tables These are used to keep trak of norms of centroids. )rÚ)ResidualQuantizer_compute_codebook_tablesrLrrrÚcompute_codebook_tablesy ó z)ResidualQuantizer.compute_codebook_tableszq dot products of all codebook vectors with each other size total_codebook_size * total_codebook_size z norms of all vectorsrár'©NNrš)9rrr1r2rrrr rÚ ResidualQuantizer_train_type_getÚ ResidualQuantizer_train_type_setrÚResidualQuantizer_Train_defaultr Ú'ResidualQuantizer_Train_progressive_dimÚTrain_progressive_dimÚ'ResidualQuantizer_Train_refine_codebookÚTrain_refine_codebookÚ+ResidualQuantizer_niter_codebook_refine_getÚ+ResidualQuantizer_niter_codebook_refine_setÚniter_codebook_refineÚ ResidualQuantizer_Train_top_beamÚTrain_top_beamÚ&ResidualQuantizer_Skip_codebook_tablesÚSkip_codebook_tablesÚ#ResidualQuantizer_max_beam_size_getÚ#ResidualQuantizer_max_beam_size_setÚ max_beam_sizeÚ"ResidualQuantizer_use_beam_LUT_getÚ"ResidualQuantizer_use_beam_LUT_setÚ use_beam_LUTÚ&ResidualQuantizer_approx_topk_mode_getÚ&ResidualQuantizer_approx_topk_mode_setÚapprox_topk_modeÚResidualQuantizer_cp_getÚResidualQuantizer_cp_setrÚ*ResidualQuantizer_assign_index_factory_getÚ*ResidualQuantizer_assign_index_factory_setÚassign_index_factoryrHr”rãrår|rírñróröÚ-ResidualQuantizer_codebook_cross_products_getÚ-ResidualQuantizer_codebook_cross_products_setÚcodebook_cross_productsÚ ResidualQuantizer_cent_norms_getÚ ResidualQuantizer_cent_norms_setÚ cent_normsÚdelete_ResidualQuantizerrvrrrrrÝ sB      rÝcGr¼)aó Encode a residual by sampling from a centroid table. This is a single encoding step the residual quantizer. It allows low-level access to the encoding function, exposed mainly for unit tests. :type n: int :param n: number of vectors to hanlde :type residuals: float :param residuals: vectors to encode, size (n, beam_size, d) :type cent: float :param cent: centroids, size (K, d) :type beam_size: int :param beam_size: input beam size :type m: int :param m: size of the codes for the previous encoding steps :type codes: int :param codes: code array for the previous steps of the beam (n, beam_size, m) :type new_beam_size: int :param new_beam_size: output beam size (should be <= K * beam_size) :type new_codes: int :param new_codes: output codes, size (n, new_beam_size, m + 1) :type new_residuals: float :param new_residuals: output residuals, size (n, new_beam_size, d) :type new_distances: float :param new_distances: output distances, size (n, new_beam_size) :type assign_index: :py:class:`Index`, optional :param assign_index: if non-NULL, will be used to perform assignment )rÚbeam_search_encode_stepr¾rrrr‹ s rcGr¼)zD Encode a set of vectors using their dot products with the codebooks)rÚbeam_search_encode_step_tabr¾rrrr­ r`rc@sdeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZeejejddZ eej!ej"ddZ#eej$ej%ddZ&eej'ej(ƒZ)eej*ej+ƒZ,dd„Z-ej.Z/dd„Z0d*dd„Z1dd„Z2dd„Z3dd„Z4dd„Z5d d!„Z6d"d#„Z7d$d%„Z8d&d'„Z9d*d(d)„Z:dS)+ÚLocalSearchQuantizeraK Implementation of LSQ/LSQ++ described in the following two papers: Revisiting additive quantization Julieta Martinez, et al. ECCV 2016 LSQ++: Lower running time and higher recall in multi-codebook quantization Julieta Martinez, et al. ECCV 2018 This implementation is mostly translated from the Julia implementations by Julieta Martinez: (https://github.com/una-dinosauria/local-search-quantization, https://github.com/una-dinosauria/Rayuela.jl) The trained codes are stored in `codebooks` which is called `centroids` in PQ and RQ. cCr5r'r6r7rrrr9à r:zLocalSearchQuantizer.cCr;r'r6r<rrrr9à r>r?r@z number of codes per codebookz! number of iterations in trainingz' iterations of local search in encodingz' iterations of local search in trainingz number of iterations in icmz temperature factorz regularization factorz" nb of vectors to encode at a timez seed for random generatorzo number of perturbation in each code if non-NULL, use this encoder to encode (owned by the object) cGr$r')rÚLocalSearchQuantizer_swiginitÚnew_LocalSearchQuantizerrprrrrHÕ r.zLocalSearchQuantizer.__init__cCr‹r')rÚLocalSearchQuantizer_trainr“rrrr”Ù rzLocalSearchQuantizer.trainNcCrm)au Encode a set of vectors :type x: float :param x: vectors to encode, size n * d :type codes: uint8_t :param codes: output codes, size n * code_size :type n: int :param n: number of vectors :type centroids: float, optional :param centroids: centroids to be added to x, size n * d )rÚ0LocalSearchQuantizer_compute_codes_add_centroidsr{rrrr|Ü rêz0LocalSearchQuantizer.compute_codes_add_centroidscCr‡)a Update codebooks given encodings :type x: float :param x: training vectors, size n * d :type codes: int :param codes: encoded training vectors, size n * M :type n: int :param n: number of vectors )rÚ%LocalSearchQuantizer_update_codebooksrÄrrrÚupdate_codebooksë rÑz%LocalSearchQuantizer.update_codebookscCrŽ)aœ Encode vectors given codebooks using iterative conditional mode (icm). :type codes: int :param codes: output codes, size n * M :type x: float :param x: vectors to encode, size n * d :type n: int :param n: number of vectors :type ils_iters: int :param ils_iters: number of iterations of iterative local search )rÚLocalSearchQuantizer_icm_encode)rrr8rQÚ ils_itersÚgenrrrÚ icm_encodeø r»zLocalSearchQuantizer.icm_encodec CrÃr')rÚ$LocalSearchQuantizer_icm_encode_impl)rrr8Úunariesr'rQr&rrrrÚicm_encode_impl rz$LocalSearchQuantizer.icm_encode_implcCrŽr')rÚ$LocalSearchQuantizer_icm_encode_step)rrr*ÚbinariesrQÚn_itersrrrÚicm_encode_step r|z$LocalSearchQuantizer.icm_encode_stepcCr‡)zÀ Add some perturbation to codes :type codes: int :param codes: codes to be perturbed, size n * M :type n: int :param n: number of vectors )rÚ"LocalSearchQuantizer_perturb_codes)rrrQr'rrrÚ perturb_codes rz"LocalSearchQuantizer.perturb_codescCr‡)a Add some perturbation to codebooks :type T: float :param T: temperature of simulated annealing :type stddev: std::vector< float > :param stddev: standard derivations of each dimension in training data )rÚ&LocalSearchQuantizer_perturb_codebooks)rÚTÚstddevr'rrrÚperturb_codebooks rz&LocalSearchQuantizer.perturb_codebookscCrN)z€ Compute binary terms :type binaries: float :param binaries: binary terms, size M * M * K * K )rÚ)LocalSearchQuantizer_compute_binary_terms)rr-rrrÚcompute_binary_terms# r–z)LocalSearchQuantizer.compute_binary_termscCr‡)a Compute unary terms :type n: int :param n: number of vectors :type x: float :param x: vectors to encode, size n * d :type unaries: float :param unaries: unary terms, size n * M * K )rÚ(LocalSearchQuantizer_compute_unary_terms)rr8r*rQrrrÚcompute_unary_terms, rÑz(LocalSearchQuantizer.compute_unary_termscCrm)a» Helper function to compute reconstruction error :type codes: int :param codes: encoded codes, size n * M :type x: float :param x: vectors to encode, size n * d :type n: int :param n: number of vectors :type objs: float, optional :param objs: if it is not null, store reconstruction error of each vector into it, size n )rÚLocalSearchQuantizer_evaluate)rrr8rQÚobjsrrrÚevaluate9 szLocalSearchQuantizer.evaluater');rrr1r2rrrr rÚLocalSearchQuantizer_K_getÚLocalSearchQuantizer_K_setÚKÚ$LocalSearchQuantizer_train_iters_getÚ$LocalSearchQuantizer_train_iters_setÚ train_itersÚ)LocalSearchQuantizer_encode_ils_iters_getÚ)LocalSearchQuantizer_encode_ils_iters_setÚencode_ils_itersÚ(LocalSearchQuantizer_train_ils_iters_getÚ(LocalSearchQuantizer_train_ils_iters_setÚtrain_ils_itersÚ"LocalSearchQuantizer_icm_iters_getÚ"LocalSearchQuantizer_icm_iters_setÚ icm_itersÚLocalSearchQuantizer_p_getÚLocalSearchQuantizer_p_setÚpÚLocalSearchQuantizer_lambd_getÚLocalSearchQuantizer_lambd_setÚlambdÚ#LocalSearchQuantizer_chunk_size_getÚ#LocalSearchQuantizer_chunk_size_setÚ chunk_sizeÚ$LocalSearchQuantizer_random_seed_getÚ$LocalSearchQuantizer_random_seed_setÚ random_seedÚLocalSearchQuantizer_nperts_getÚLocalSearchQuantizer_nperts_setÚnpertsÚ,LocalSearchQuantizer_icm_encoder_factory_getÚ,LocalSearchQuantizer_icm_encoder_factory_setÚicm_encoder_factoryÚ5LocalSearchQuantizer_update_codebooks_with_double_getÚ5LocalSearchQuantizer_update_codebooks_with_double_setÚupdate_codebooks_with_doublerHÚdelete_LocalSearchQuantizerrvr”r|r$r(r+r/r1r5r7r9r<rrrrr° s:      rc@sneZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejejƒZdd„ZejZdd „Zd d „Zd S) Ú IcmEncodercCr5r'r6r7rrrr9M r:zIcmEncoder.cCr;r'r6r<rrrr9M r>r?r@cCrhr')rÚIcmEncoder_swiginitÚnew_IcmEncoder©rÚlsqrrrrHS r.zIcmEncoder.__init__cCrJr')rÚIcmEncoder_set_binary_termrLrrrÚset_binary_termW rMzIcmEncoder.set_binary_termcCrŽ)a¿ Encode vectors given codebooks :type codes: int :param codes: output codes, size n * M :type x: float :param x: vectors to encode, size n * d :type gen: std::mt19937 :param gen: random generator :type n: int :param n: number of vectors :type ils_iters: int :param ils_iters: number of iterations of iterative local search )rÚIcmEncoder_encode)rrr8r'rQr&rrrr1Z r§zIcmEncoder.encodeN)rrr1rrrr rÚIcmEncoder_binaries_getÚIcmEncoder_binaries_setr-ÚIcmEncoder_verbose_getÚIcmEncoder_verbose_setrÚIcmEncoder_lsq_getÚIcmEncoder_lsq_setrfrHÚdelete_IcmEncoderrvrhr1rrrrrbL s rbc@s<eZdZedd„dd„ddZeZdd„Zej Z dd „Z d S) ÚIcmEncoderFactorycCr5r'r6r7rrrr9o r:zIcmEncoderFactory.cCr;r'r6r<rrrr9o r>r?r@cCrNr')rÚIcmEncoderFactory_getrerrrÚgetr rSzIcmEncoderFactory.getcCryr')rÚIcmEncoderFactory_swiginitÚnew_IcmEncoderFactoryrLrrrrHv r|zIcmEncoderFactory.__init__N) rrr1rrrr rsrÚdelete_IcmEncoderFactoryrvrHrrrrrqn s  rqc@ó^eZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z d d „Z d d „Zd d„ZejZdS)ÚLSQTimerz] A helper struct to count consuming time during training. It is NOT thread-safe. cCr5r'r6r7rrrr9‚ r:zLSQTimer.cCr;r'r6r<rrrr9‚ r>r?r@cCryr')rÚLSQTimer_swiginitÚ new_LSQTimerrLrrrrH† r|zLSQTimer.__init__cCrNr')rÚ LSQTimer_get©rrrrrrs‰ rSz LSQTimer.getcCr‹r')rÚ LSQTimer_add)rrÚdeltarrrr—Œ rz LSQTimer.addcCrJr')rÚLSQTimer_resetrLrrrr{ rMzLSQTimer.resetN)rrr1r2rrrr rÚLSQTimer_t_getÚLSQTimer_t_setÚtrHrsr—r{Údelete_LSQTimerrvrrrrrx| s rxc@óteZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejejƒZeejejƒZdd„Zdd „ZejZd S) Ú LSQTimerScopecCr5r'r6r7rrrr9— r:zLSQTimerScope.cCr;r'r6r<rrrr9— r>r?r@cCr—r')rÚLSQTimerScope_swiginitÚnew_LSQTimerScope)rÚtimerrrrrrHž rzLSQTimerScope.__init__cCrJr')rÚLSQTimerScope_finishrLrrrÚfinish¡ rMzLSQTimerScope.finishN)rrr1rrrr rÚLSQTimerScope_t0_getÚLSQTimerScope_t0_setÚt0ÚLSQTimerScope_timer_getÚLSQTimerScope_timer_setrˆÚLSQTimerScope_name_getÚLSQTimerScope_name_setrÚLSQTimerScope_finished_getÚLSQTimerScope_finished_setÚfinishedrHrŠÚdelete_LSQTimerScopervrrrrr…– ó r…c@s eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ƒZdd „ZejZd d „Zd d „Zdd„Zddd„Zddd„Zddd„Zdd„Zddd„ZdS) ÚProductAdditiveQuantizera Product Additive Quantizers The product additive quantizer is a variant of AQ and PQ. It first splits the vector space into multiple orthogonal sub-spaces just like PQ does. And then it quantizes each sub-space by an independent additive quantizer. cCr5r'r6r7rrrr9² r:z!ProductAdditiveQuantizer.cCr;r'r6r<rrrr9² r>r?r@z- number of sub-vectors we split a vector intocGr$r')rÚ!ProductAdditiveQuantizer_swiginitÚnew_ProductAdditiveQuantizerrprrrrH· r.z!ProductAdditiveQuantizer.__init__cCr‡r')rÚProductAdditiveQuantizer_init)rr†ÚaqsrÕrrrÚinit» r‰zProductAdditiveQuantizer.initcCrN)z% Train the product additive quantizer)rÚ%ProductAdditiveQuantizer_subquantizer)rrðrrrÚ subquantizer¾ r z%ProductAdditiveQuantizer.subquantizercCr‹r')rÚProductAdditiveQuantizer_trainr“rrrr” rzProductAdditiveQuantizer.trainNcCrmry)rÚ4ProductAdditiveQuantizer_compute_codes_add_centroidsr{rrrr|Å r‚z4ProductAdditiveQuantizer.compute_codes_add_centroidscCrmr')rÚ/ProductAdditiveQuantizer_compute_unpacked_codesr{rrrÚcompute_unpacked_codesÒ rrz/ProductAdditiveQuantizer.compute_unpacked_codesr cCrmr„)rÚ(ProductAdditiveQuantizer_decode_unpackedr†rrrr‡Õ rˆz(ProductAdditiveQuantizer.decode_unpackedcCr‡r)rÚProductAdditiveQuantizer_decoderƒrrrrÈà rzProductAdditiveQuantizer.decoder‹cCrŽ)a¬ Compute inner-product look-up tables. Used in the search functions. :type xq: float :param xq: query vector, size (n, d) :type LUT: float :param LUT: look-up table, size (n, total_codebook_size) :type alpha: float, optional :param alpha: compute alpha * inner-product :type ld_lut: int, optional :param ld_lut: leading dimension of LUT )rÚ$ProductAdditiveQuantizer_compute_LUTrrrrr‘ë r»z$ProductAdditiveQuantizer.compute_LUTr'ršr›)rrr1r2rrrr rÚ$ProductAdditiveQuantizer_nsplits_getÚ$ProductAdditiveQuantizer_nsplits_setÚnsplitsÚ'ProductAdditiveQuantizer_quantizers_getÚ'ProductAdditiveQuantizer_quantizers_setÚ quantizersrHÚdelete_ProductAdditiveQuantizerrvrœržr”r|r¢r‡rÈr‘rrrrr—¨ s      r—c@ó8eZdZdZedd„dd„ddZeZdd„Ze j Z d S) ÚProductLocalSearchQuantizerz Product Local Search QuantizercCr5r'r6r7rrrr9 r:z$ProductLocalSearchQuantizer.cCr;r'r6r<rrrr9 r>r?r@cGr$r')rÚ$ProductLocalSearchQuantizer_swiginitÚnew_ProductLocalSearchQuantizerrprrrrH r.z$ProductLocalSearchQuantizer.__init__N) rrr1r2rrrr rHrÚ"delete_ProductLocalSearchQuantizerrvrrrrr®ý ó  r®c@r­) ÚProductResidualQuantizerz Product Residual QuantizercCr5r'r6r7rrrr9 r:z!ProductResidualQuantizer.cCr;r'r6r<rrrr9 r>r?r@cGr$r')rÚ!ProductResidualQuantizer_swiginitÚnew_ProductResidualQuantizerrprrrrH r.z!ProductResidualQuantizer.__init__N) rrr1r2rrrr rHrÚdelete_ProductResidualQuantizerrvrrrrr³ r²r³c@s‚eZdZdZedd„dd„ddZdd„ZeZee j e j ƒZ ee j e jƒZee je jƒZd d „Zd d „Zd d„Zdd„Ze jZdS)Ú CodePackera, Packing consists in combining a fixed number of codes of constant size (code_size) into a block of data where they may (or may not) be interleaved for efficient consumption by distance computation kernels. This exists for the "fast_scan" indexes on CPU and for some GPU kernels. cCr5r'r6r7rrrr9 r:zCodePacker.cCr;r'r6r<rrrr9 r>r?r@cOrBrCrDrErrrrH! rIzCodePacker.__init__cCr‡r')rÚCodePacker_pack_1©rÚ flat_coder.ÚblockrrrÚpack_1( r‰zCodePacker.pack_1cCr‡r')rÚCodePacker_unpack_1©rr»r.rºrrrÚunpack_1+ r‰zCodePacker.unpack_1cCr‹r')rÚCodePacker_pack_all©rÚ flat_codesr»rrrÚpack_all. rzCodePacker.pack_allcCr‹r')rÚCodePacker_unpack_all©rr»rÂrrrÚ unpack_all1 rzCodePacker.unpack_allN)rrr1r2rrrHrr rÚCodePacker_code_size_getÚCodePacker_code_size_setrœÚCodePacker_nvec_getÚCodePacker_nvec_setÚnvecÚCodePacker_block_size_getÚCodePacker_block_size_setÚ block_sizer¼r¿rÃrÆÚdelete_CodePackerrvrrrrr· s r·c@sXeZdZdZedd„dd„ddZeZdd„Zd d „Z d d „Z d d„Z dd„Z e jZdS)ÚCodePackerFlatz6 Trivial code packer where codes are stored one by onecCr5r'r6r7rrrr9; r:zCodePackerFlat.cCr;r'r6r<rrrr9; r>r?r@cCrhr')rÚCodePackerFlat_swiginitÚnew_CodePackerFlat)rrœrrrrH> r.zCodePackerFlat.__init__cCr‡r')rÚCodePackerFlat_pack_1r¹rrrr¼A r‰zCodePackerFlat.pack_1cCr‡r')rÚCodePackerFlat_unpack_1r¾rrrr¿D r‰zCodePackerFlat.unpack_1cCr‹r')rÚCodePackerFlat_pack_allrÁrrrrÃG rzCodePackerFlat.pack_allcCr‹r')rÚCodePackerFlat_unpack_allrÅrrrrÆJ rzCodePackerFlat.unpack_allN)rrr1r2rrrr rHr¼r¿rÃrÆrÚdelete_CodePackerFlatrvrrrrrÐ8 s rÐc@s’eZdZdZedd„dd„ddZdd„ZeZee j e j ƒZ ee j e jd dZee je jd dZd d „Zd d„Zdd„Zdd„Zdd„Ze jZdS)ÚVectorTransformz/ Any transformation applied on a set of vectorscCr5r'r6r7rrrr9T r:zVectorTransform.cCr;r'r6r<rrrr9T r>r?r@cOrBrCrDrErrrrHV rIzVectorTransform.__init__zinput dimensionzb set if the VectorTransform does not require training, or if training is done already cCr‹)zö Perform training on a representative set of vectors. Does nothing by default. :type n: int :param n: nb of training vectors :type x: float :param x: training vecors, size n * d )rÚVectorTransform_trainr“rrrr”` r˜zVectorTransform.traincCr‹)a+ apply the transformation and return the result in an allocated pointer :type n: int :param n: number of vectors to transform :type x: float :param x: input vectors, size n * d_in :rtype: float :return: output vectors, size n * d_out )rÚVectorTransform_applyr“rrrÚapplyl r˜zVectorTransform.applycCr‡)a, apply the transformation and return the result in a provided matrix :type n: int :param n: number of vectors to transform :type x: float :param x: input vectors, size n * d_in :type xt: float :param xt: output vectors, size n * d_out )rÚVectorTransform_apply_noalloc©rrQr8ÚxtrrrÚ apply_noallocx ržzVectorTransform.apply_noalloccCr‡)zi reverse transformation. May not be implemented or may return approximate result )rÚ!VectorTransform_reverse_transform©rrQrÞr8rrrÚreverse_transform„ rùz!VectorTransform.reverse_transformcCrNr')rÚVectorTransform_check_identicalrŒrrrÚcheck_identical‹ rSzVectorTransform.check_identicalN)rrr1r2rrrHrr rÚVectorTransform_d_in_getÚVectorTransform_d_in_setÚd_inÚVectorTransform_d_out_getÚVectorTransform_d_out_setÚd_outÚVectorTransform_is_trained_getÚVectorTransform_is_trained_setrër”rÛrßrâräÚdelete_VectorTransformrvrrrrrØQ s    rØc@s¼eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ddZeejejddZeejejd dZdd d „Zdd„Zdd„Zdd„Zdd„ZeejejƒZdd„Zdd„ZejZ dS)ÚLinearTransformz\ Generic linear transformation, with bias term applied on output y = A * x + b cCr5r'r6r7rrrr9˜ r:zLinearTransform.cCr;r'r6r<rrrr9˜ r>r?r@zh whether to use the bias term check if matrix A is orthonormal (enables reverse_transform) z) Transformation matrix, size d_out * d_inz bias vector, size d_outrFcCót |t |||¡¡dS)z1 both d_in > d_out and d_out < d_in are supportedN)rÚLinearTransform_swiginitÚnew_LinearTransform)rrçrêÚ have_biasrrrrH¢ ózLinearTransform.__init__cCr‡)z+ same as apply, but result is pre-allocated)rÚLinearTransform_apply_noallocrÝrrrrߦ rzLinearTransform.apply_noalloccCr‡)zc compute x = A^T * (x - b) is reverse transform if A has orthonormal lines )rÚ#LinearTransform_transform_transpose)rrQrr8rrrÚtransform_transposeª rùz#LinearTransform.transform_transposecCr‡)z works only if is_orthonormal)rÚ!LinearTransform_reverse_transformrárrrrâ± rz!LinearTransform.reverse_transformcCrJ)z/ compute A^T * A to set the is_orthonormal flag)rÚ"LinearTransform_set_is_orthonormalrLrrrÚset_is_orthonormalµ r`z"LinearTransform.set_is_orthonormalcCrmr')rÚ LinearTransform_print_if_verbose)rrÚmatrQr†rrrÚprint_if_verboseº rrz LinearTransform.print_if_verbosecCrNr')rÚLinearTransform_check_identicalrŒrrrrä½ rSzLinearTransform.check_identicalN©rrF)!rrr1r2rrrr rÚLinearTransform_have_bias_getÚLinearTransform_have_bias_setròÚ"LinearTransform_is_orthonormal_getÚ"LinearTransform_is_orthonormal_setÚis_orthonormalÚLinearTransform_A_getÚLinearTransform_A_setÚAÚLinearTransform_b_getÚLinearTransform_b_setr…rHrßrörârùÚLinearTransform_verbose_getÚLinearTransform_verbose_setrrüräÚdelete_LinearTransformrvrrrrrî’ s"  rîc@sHeZdZdZedd„dd„ddZeZdd„Zd d „Z d d „Z e j Z d S)ÚRandomRotationMatrixz! Randomly rotate a set of vectorscCr5r'r6r7rrrr9Ç r:zRandomRotationMatrix.cCr;r'r6r<rrrr9Ç r>r?r@cCrN)z, must be called before the transform is used)rÚRandomRotationMatrix_initrkrrrrœÊ r zRandomRotationMatrix.initcCr‹r')rÚRandomRotationMatrix_trainr“rrrr”Î rzRandomRotationMatrix.traincGr$r')rÚRandomRotationMatrix_swiginitÚnew_RandomRotationMatrixrprrrrHÑ r.zRandomRotationMatrix.__init__N)rrr1r2rrrr rœr”rHrÚdelete_RandomRotationMatrixrvrrrrr Ä s r c@sâeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZeejejddZ ddd„Z!dd„Z"dd„Z#dd„Z$ej%Z&dS)Ú PCAMatrixzx Applies a principal component analysis on a set of vectors, with optionally whitening and random rotation. cCr5r'r6r7rrrr9Þ r:zPCAMatrix.cCr;r'r6r<rrrr9Þ r>r?r@zŒ after transformation the components are multiplied by eigenvalues^eigen_power =0: no whitening =-0.5: full whitening zA value added to eigenvalues to avoid division by 0 when whiteningz random rotation after PCAz/ ratio between # training vectors and dimensionz8 try to distribute output eigenvectors in this many binsz Mean, size d_inz= eigenvalues of covariance matrix (= squared singular values)z PCA matrix, size d_in * d_inrFc Cót |t ||||¡¡dSr')rÚPCAMatrix_swiginitÚ new_PCAMatrix)rrçrêÚ eigen_powerÚrandom_rotationrrrrHï ózPCAMatrix.__init__cCr‹)zo train on n vectors. If n < d_in then the eigenvector matrix will be completed with 0s )rÚPCAMatrix_trainr“rrrr”ò râzPCAMatrix.traincCrN)z copy pre-trained PCA matrix)rÚPCAMatrix_copy_fromrŒrrrÚ copy_fromù r zPCAMatrix.copy_fromcCrJ)z7 called after mean, PCAMat and eigenvalues are computed)rÚPCAMatrix_prepare_AbrLrrrÚ prepare_Abý r`zPCAMatrix.prepare_AbN)rrrF)'rrr1r2rrrr rÚPCAMatrix_eigen_power_getÚPCAMatrix_eigen_power_setrÚPCAMatrix_epsilon_getÚPCAMatrix_epsilon_setÚepsilonÚPCAMatrix_random_rotation_getÚPCAMatrix_random_rotation_setrÚPCAMatrix_max_points_per_d_getÚPCAMatrix_max_points_per_d_setÚmax_points_per_dÚPCAMatrix_balanced_bins_getÚPCAMatrix_balanced_bins_setÚ balanced_binsÚPCAMatrix_mean_getÚPCAMatrix_mean_setÚmeanÚPCAMatrix_eigenvalues_getÚPCAMatrix_eigenvalues_setÚ eigenvaluesÚPCAMatrix_PCAMat_getÚPCAMatrix_PCAMat_setÚPCAMatrHr”rrÚdelete_PCAMatrixrvrrrrrØ s"  rc@sleZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZd dd „Zd d „ZejZd S)Ú ITQMatrixzð ITQ implementation from Iterative quantization: A procrustean approach to learning binary codes for large-scale image retrieval, Yunchao Gong, Svetlana Lazebnik, Albert Gordo, Florent Perronnin, PAMI'12. cCr5r'r6r7rrrr9r:zITQMatrix.cCr;r'r6r<rrrr9r>r?r@rcCrhr')rÚITQMatrix_swiginitÚ new_ITQMatrix©rr†rrrrHr.zITQMatrix.__init__cCr‹r')rÚITQMatrix_trainr“rrrr”rzITQMatrix.trainNrá)rrr1r2rrrr rÚITQMatrix_max_iter_getÚITQMatrix_max_iter_setÚmax_iterÚITQMatrix_seed_getÚITQMatrix_seed_setrÚITQMatrix_init_rotation_getÚITQMatrix_init_rotation_setÚ init_rotationrHr”Údelete_ITQMatrixrvrrrrr5s   r5c@sœeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejddZeejejƒZdd d „Zd d „Zdd„Zdd„ZejZdS)Ú ITQTransformzH The full ITQ transform, including normalizations and PCA transformationcCr5r'r6r7rrrr9#r:zITQTransform.cCr;r'r6r<rrrr9#r>r?r@z" max training points per dimensionrFcCr+r')rÚITQTransform_swiginitÚnew_ITQTransform)rrçrêÚdo_pcarrrrH+r/zITQTransform.__init__cCr‹r')rÚITQTransform_trainr“rrrr”.rzITQTransform.traincCr‡r')rÚITQTransform_apply_noallocrÝrrrrß1r‰zITQTransform.apply_noalloccCrNr')rÚITQTransform_check_identicalrŒrrrrä4rSzITQTransform.check_identicalNrþ)rrr1r2rrrr rÚITQTransform_mean_getÚITQTransform_mean_setr-ÚITQTransform_do_pca_getÚITQTransform_do_pca_setrFÚITQTransform_itq_getÚITQTransform_itq_setÚitqÚ"ITQTransform_max_train_per_dim_getÚ"ITQTransform_max_train_per_dim_setÚmax_train_per_dimÚITQTransform_pca_then_itq_getÚITQTransform_pca_then_itq_setÚ pca_then_itqrHr”rßräÚdelete_ITQTransformrvrrrrrC s  rCc@s¼eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejƒZeejejd dZddd„Zdd„Zej Z!dS)Ú OPQMatrixa\ Applies a rotation to align the dimensions with a PQ to minimize the reconstruction error. Can be used before an IndexPQ or an IndexIVFPQ. The method is the non-parametric version described in: "Optimized Product Quantization for Approximate Nearest Neighbor Search" Tiezheng Ge, Kaiming He, Qifa Ke, Jian Sun, CVPR'13 cCr5r'r6r7rrrr9Er:zOPQMatrix.cCr;r'r6r<rrrr9Er>r?r@z nb of subquantizersz$ Number of outer training iterationsz) Number of training iterations for the PQz$ same, for the first outer iterationz0 if there are too many training points, resamplezk if non-NULL, use this product quantizer for training should be constructed with (d_out, M, _) rrr cCrï)z. if d2 != -1, output vectors of this dimensionN)rÚOPQMatrix_swiginitÚ new_OPQMatrix)rr†rÚd2rrrrHRrózOPQMatrix.__init__cCr‹r')rÚOPQMatrix_trainr“rrrr”VrzOPQMatrix.trainN)rrr )"rrr1r2rrrr rÚOPQMatrix_M_getÚOPQMatrix_M_setrÚOPQMatrix_niter_getÚOPQMatrix_niter_setrIÚOPQMatrix_niter_pq_getÚOPQMatrix_niter_pq_setÚniter_pqÚOPQMatrix_niter_pq_0_getÚOPQMatrix_niter_pq_0_setÚ niter_pq_0ÚOPQMatrix_max_train_points_getÚOPQMatrix_max_train_points_setÚmax_train_pointsÚOPQMatrix_verbose_getÚOPQMatrix_verbose_setrÚOPQMatrix_pq_getÚOPQMatrix_pq_setÚpqrHr”Údelete_OPQMatrixrvrrrrrX;s   rXc@sbeZdZdZedd„dd„ddZeZeej ej ddZ dd „Z d d „Z d d „Zdd„ZejZdS)ÚRemapDimensionsTransformz¶ remap dimensions for intput vectors, possibly inserting 0s strictly speaking this is also a linear transform but we don't want to compute it with matrix multiplies cCr5r'r6r7rrrr9dr:z!RemapDimensionsTransform.cCr;r'r6r<rrrr9dr>r?r@zR map from output dimension to input, size d_out -1 -> set output to 0 cCr‡r')rÚ&RemapDimensionsTransform_apply_noallocrÝrrrrßkr‰z&RemapDimensionsTransform.apply_noalloccCr‡)zA reverse transform correct only when the mapping is a permutation)rÚ*RemapDimensionsTransform_reverse_transformrárrrrânrz*RemapDimensionsTransform.reverse_transformcGr$r')rÚ!RemapDimensionsTransform_swiginitÚnew_RemapDimensionsTransformrprrrrHrr.z!RemapDimensionsTransform.__init__cCrNr')rÚ(RemapDimensionsTransform_check_identicalrŒrrrräurSz(RemapDimensionsTransform.check_identicalN)rrr1r2rrrr rÚ RemapDimensionsTransform_map_getÚ RemapDimensionsTransform_map_setÚmaprßrârHräÚdelete_RemapDimensionsTransformrvrrrrrp]s rpc@rw)ÚNormalizationTransformz per-vector normalizationcCr5r'r6r7rrrr9r:zNormalizationTransform.cCr;r'r6r<rrrr9r>r?r@cGr$r')rÚNormalizationTransform_swiginitÚnew_NormalizationTransformrprrrrHƒr.zNormalizationTransform.__init__cCr‡r')rÚ$NormalizationTransform_apply_noallocrÝrrrr߆r‰z$NormalizationTransform.apply_noalloccCr‡)z0 Identity transform since norm is not revertible)rÚ(NormalizationTransform_reverse_transformrárrrrâ‰rz(NormalizationTransform.reverse_transformcCrNr')rÚ&NormalizationTransform_check_identicalrŒrrrrärSz&NormalizationTransform.check_identicalN)rrr1r2rrrr rÚNormalizationTransform_norm_getÚNormalizationTransform_norm_setrnrHrßrâräÚdelete_NormalizationTransformrvrrrrrz|s rzc@sleZdZdZedd„dd„ddZeZeej ej ddZ dd d „Z d d „Z d d„Zdd„Zdd„ZejZdS)ÚCenteringTransformz6 Subtract the mean of each component from the vectors.cCr5r'r6r7rrrr9—r:zCenteringTransform.cCr;r'r6r<rrrr9—r>r?r@z Mean, size d_in = d_outrcCrhr')rÚCenteringTransform_swiginitÚnew_CenteringTransformr8rrrrH›r.zCenteringTransform.__init__cCr‹)z train on n vectors.)rÚCenteringTransform_trainr“rrrr”žrózCenteringTransform.traincCr‡)z subtract the mean)rÚ CenteringTransform_apply_noallocrÝrrrrߢrz CenteringTransform.apply_noalloccCr‡)z add the mean)rÚ$CenteringTransform_reverse_transformrárrrrâ¦rz$CenteringTransform.reverse_transformcCrNr')rÚ"CenteringTransform_check_identicalrŒrrrräªrSz"CenteringTransform.check_identicalNrá)rrr1r2rrrr rÚCenteringTransform_mean_getÚCenteringTransform_mean_setr-rHr”rßrâräÚdelete_CenteringTransformrvrrrrrƒ”s  rƒc@óFeZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z ej Zd S) ÚSearchParametersPreTransformrôcCr5r'r6r7rrrr9¹r:z%SearchParametersPreTransform.cCr;r'r6r<rrrr9¹r>r?r@cCryr')rÚ%SearchParametersPreTransform_swiginitÚ new_SearchParametersPreTransformrLrrrrH½r|z%SearchParametersPreTransform.__init__N)rrr1r2rrrr rÚ-SearchParametersPreTransform_index_params_getÚ-SearchParametersPreTransform_index_params_setÚ index_paramsrHÚ#delete_SearchParametersPreTransformrvrrrrrŽ±s rŽc@s eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ddZeejejddZd d „Zd d „Zd d„Zdd„Zdd„Zdd„Zdd„Zd3dd„Zd3dd„Zdd„Zdd„Zd3d d!„Zd"d#„Zd$d%„Zd&d'„Z d(d)„Z!d*d+„Z"d,d-„Z#d4d/d0„Z$d1d2„Z%ej&Z'dS)5ÚIndexPreTransformzo Index that applies a LinearTransform transform on vectors before handing them over to a sub-index cCr5r'r6r7rrrr9Êr:zIndexPreTransform.cCr;r'r6r<rrrr9Êr>r?r@zchain of tranformsú the sub-indexcGót |tj|Ž¡dS)z« *Overload 1:* whether pointers are deleted in destructor | *Overload 2:* ltrans is the last transform before the index N)rÚIndexPreTransform_swiginitÚnew_IndexPreTransformrprrrrHÐó zIndexPreTransform.__init__cCrNr')rÚ#IndexPreTransform_prepend_transform)rÚltransrrrÚprepend_transformÜrSz#IndexPreTransform.prepend_transformcCr‹r')rÚIndexPreTransform_trainr“rrrr”ßrzIndexPreTransform.traincCr‹r')rÚIndexPreTransform_addr“rrrr—ârzIndexPreTransform.addcCr‡r')rÚIndexPreTransform_add_with_idsr›rrrrår‰zIndexPreTransform.add_with_idscCrJr')rÚIndexPreTransform_resetrLrrrr{èrMzIndexPreTransform.resetcCrN)z: removes IDs from the index. Not supported by all indexes.)rÚIndexPreTransform_remove_idsr­rrrr®ër zIndexPreTransform.remove_idsNc CrÈr')rÚIndexPreTransform_searchr rrrr¢ïr.zIndexPreTransform.searchcCrŽr')rÚIndexPreTransform_range_searchr¥rrrr¦òr|zIndexPreTransform.range_searchcCr‹r')rÚIndexPreTransform_reconstructr±rrrr´õrzIndexPreTransform.reconstructcCr‡r')rÚIndexPreTransform_reconstruct_nrºrrrr½ør‰zIndexPreTransform.reconstruct_nc CrÃr')rÚ(IndexPreTransform_search_and_reconstructrÀrrrrÁûrz(IndexPreTransform.search_and_reconstructcCr‹)zˆ apply the transforms in the chain. The returned float * may be equal to x, otherwise it should be deallocated. )rÚIndexPreTransform_apply_chainr“rrrÚ apply_chainþrâzIndexPreTransform.apply_chaincCr‡)z˜ Reverse the transforms in the chain. May not be implemented for all transforms in the chain or may return approximate results. )rÚIndexPreTransform_reverse_chainrárrrÚ reverse_chainrùzIndexPreTransform.reverse_chaincCrJr')rÚ'IndexPreTransform_get_distance_computerrLrrrrË rMz'IndexPreTransform.get_distance_computercCrJr')rÚIndexPreTransform_sa_code_sizerLrrrrÍrMzIndexPreTransform.sa_code_sizecCr‡r')rÚIndexPreTransform_sa_encoderÏrrrrÐr‰zIndexPreTransform.sa_encodecCr‡r')rÚIndexPreTransform_sa_decoderÓrrrrÔr‰zIndexPreTransform.sa_decodercCr‹r')rÚIndexPreTransform_merge_fromr×rrrrÚrzIndexPreTransform.merge_fromcCrNr')rÚ,IndexPreTransform_check_compatible_for_mergerÞrrrrßrSz,IndexPreTransform.check_compatible_for_merger'rá)(rrr1r2rrrr rÚIndexPreTransform_chain_getÚIndexPreTransform_chain_setÚchainÚIndexPreTransform_index_getÚIndexPreTransform_index_setr€Ú IndexPreTransform_own_fields_getÚ IndexPreTransform_own_fields_setÚ own_fieldsrHrr”r—rr{r®r¢r¦r´r½rÁr©r«rËrÍrÐrÔrÚrßÚdelete_IndexPreTransformrvrrrrr•Äs8      r•c@sÔeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZd d „Zdd„Zdd„Zdd„Zddd„Zdd„Zdd„Zdd„Zdd„Z ej!Z"dS) Ú IndexRefinezŒ Index that queries in a base_index (a fast one) and refines the results with an exact search, hopefully improving the results. cCr5r'r6r7rrrr9(r:zIndexRefine.cCr;r'r6r<rrrr9(r>r?r@z? faster index to pre-select the vectors that should be filteredz refinement indexz& should the base index be deallocated?z same with the refinement indexzk factor between k requested in search and the k requested from the base_index (should be >= 1) cGr$r')rÚIndexRefine_swiginitÚnew_IndexRefinerprrrrH3r.zIndexRefine.__init__cCr‹r')rÚIndexRefine_trainr“rrrr”6rzIndexRefine.traincCr‹r')rÚIndexRefine_addr“rrrr—9rzIndexRefine.addcCrJr')rÚIndexRefine_resetrLrrrr{<rMzIndexRefine.resetNc CrÈr')rÚIndexRefine_searchr rrrr¢?r.zIndexRefine.searchcCr‹r')rÚIndexRefine_reconstructr±rrrr´BrzIndexRefine.reconstructcCrJr')rÚIndexRefine_sa_code_sizerLrrrrÍErMzIndexRefine.sa_code_sizecCr‡r')rÚIndexRefine_sa_encoderÏrrrrÐHr‰zIndexRefine.sa_encodecCr‡)zk The sa_decode decodes from the index_refine, which is assumed to be more accurate )rÚIndexRefine_sa_decoderÓrrrrÔKrùzIndexRefine.sa_decoder')#rrr1r2rrrr rÚIndexRefine_base_index_getÚIndexRefine_base_index_setÚ base_indexÚIndexRefine_refine_index_getÚIndexRefine_refine_index_setÚ refine_indexÚIndexRefine_own_fields_getÚIndexRefine_own_fields_setr¹Ú IndexRefine_own_refine_index_getÚ IndexRefine_own_refine_index_setÚown_refine_indexÚIndexRefine_k_factor_getÚIndexRefine_k_factor_setÚk_factorrHr”r—r{r¢r´rÍrÐrÔÚdelete_IndexRefinervrrrrr»"s&  r»c@sBeZdZdZedd„dd„ddZeZdd„Zd d d „Z e j Z d S) ÚIndexRefineFlatz« Version where the refinement index is an IndexFlat. It has one additional constructor that takes a table of elements to add to the flat refinement index cCr5r'r6r7rrrr9]r:zIndexRefineFlat.cCr;r'r6r<rrrr9]r>r?r@cGr$r')rÚIndexRefineFlat_swiginitÚnew_IndexRefineFlatrprrrrH`r.zIndexRefineFlat.__init__Nc CrÈr')rÚIndexRefineFlat_searchr rrrr¢cr.zIndexRefineFlat.searchr') rrr1r2rrrr rHr¢rÚdelete_IndexRefineFlatrvrrrrrÕVs  rÕc@sÄeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZd d „Zdd„Zddd„Zdd„ZejZdd„Zdd„Zdd„Z dS)ÚIndexLSHz? The sign of each vector component is put in a binary signaturecCr5r'r6r7rrrr9mr:zIndexLSH.cCr;r'r6r<rrrr9mr>r?r@z nb of bits per vectorz, whether to apply a random rotation to inputz% whether we train thresholds or use 0z optional random rotationz thresholds to compare withcCr‹)aP Preprocesses and resizes the input to the size required to binarize the data :type x: float :param x: input vectors, size n * d :rtype: float :return: output vectors, size n * bits. May be the same pointer as x, otherwise it should be deleted by the caller )rÚIndexLSH_apply_preprocessr“rrrÚapply_preprocessurzIndexLSH.apply_preprocesscCr‹r')rÚIndexLSH_trainr“rrrr”‚rzIndexLSH.trainNc CrÈr')rÚIndexLSH_searchr rrrr¢…r.zIndexLSH.searchcCrN)zh transfer the thresholds to a pre-processing stage (and unset train_thresholds) )rÚIndexLSH_transfer_thresholds)rÚvtrrrÚtransfer_thresholdsˆr¯zIndexLSH.transfer_thresholdscGr$r')rÚIndexLSH_swiginitÚ new_IndexLSHrprrrrHr.zIndexLSH.__init__cCr‡r')rÚIndexLSH_sa_encoderÏrrrrГr‰zIndexLSH.sa_encodecCr‡r')rÚIndexLSH_sa_decoderÓrrrrÔ–r‰zIndexLSH.sa_decoder')!rrr1r2rrrr rÚIndexLSH_nbits_getÚIndexLSH_nbits_setrÚIndexLSH_rotate_data_getÚIndexLSH_rotate_data_setÚ rotate_dataÚIndexLSH_train_thresholds_getÚIndexLSH_train_thresholds_setÚtrain_thresholdsÚIndexLSH_rrot_getÚIndexLSH_rrot_setÚrrotÚIndexLSH_thresholds_getÚIndexLSH_thresholds_setÚ thresholdsrÜr”r¢ráÚdelete_IndexLSHrvrHrÐrÔrrrrrÚjs"  rÚc@s¨eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejƒZeejejƒZeejejƒZeejejƒZeejejƒZ dd„Z!ej"Z#d S) ÚSimulatedAnnealingParametersz3 parameters used for the simulated annealing methodcCr5r'r6r7rrrr9Ÿr:z%SimulatedAnnealingParameters.cCr;r'r6r<rrrr9Ÿr>r?r@cCryr')rÚ%SimulatedAnnealingParameters_swiginitÚ new_SimulatedAnnealingParametersrLrrrrHªr|z%SimulatedAnnealingParameters.__init__N)$rrr1r2rrrr rÚ1SimulatedAnnealingParameters_init_temperature_getÚ1SimulatedAnnealingParameters_init_temperature_setÚinit_temperatureÚ2SimulatedAnnealingParameters_temperature_decay_getÚ2SimulatedAnnealingParameters_temperature_decay_setÚtemperature_decayÚ'SimulatedAnnealingParameters_n_iter_getÚ'SimulatedAnnealingParameters_n_iter_setÚn_iterÚ'SimulatedAnnealingParameters_n_redo_getÚ'SimulatedAnnealingParameters_n_redo_setÚn_redoÚ%SimulatedAnnealingParameters_seed_getÚ%SimulatedAnnealingParameters_seed_setrÚ(SimulatedAnnealingParameters_verbose_getÚ(SimulatedAnnealingParameters_verbose_setrÚ/SimulatedAnnealingParameters_only_bit_flips_getÚ/SimulatedAnnealingParameters_only_bit_flips_setÚonly_bit_flipsÚ,SimulatedAnnealingParameters_init_random_getÚ,SimulatedAnnealingParameters_init_random_setÚ init_randomrHÚ#delete_SimulatedAnnealingParametersrvrrrrrõœs rõc@óVeZdZdZedd„dd„ddZdd„ZeZee j e j ƒZ d d „Z d d „Ze jZd S)ÚPermutationObjectivez% abstract class for the loss functioncCr5r'r6r7rrrr9´r:zPermutationObjective.cCr;r'r6r<rrrr9´r>r?r@cOrBrCrDrErrrrH¶rIzPermutationObjective.__init__cCrNr')rÚ!PermutationObjective_compute_cost©rrxrrrÚ compute_cost»rSz!PermutationObjective.compute_costcCr‡r')rÚ PermutationObjective_cost_update©rrxÚiwÚjwrrrÚ cost_update¾r‰z PermutationObjective.cost_updateN)rrr1r2rrrHrr rÚPermutationObjective_n_getÚPermutationObjective_n_setrQrrÚdelete_PermutationObjectivervrrrrr±s rc@s¸eZdZedd„dd„ddZeZeejej ƒZ e dd„ƒZ dd „Z eejejd dZeejejd dZeejejd dZd d„Zdd„Zdd„Zdd„Ze dd„ƒZdd„ZejZdS)ÚReproduceDistancesObjectivecCr5r'r6r7rrrr9Ær:z$ReproduceDistancesObjective.cCr;r'r6r<rrrr9Ær>r?r@cCrJr'©rÚReproduceDistancesObjective_sqrr7rrrÚsqrÊr`zReproduceDistancesObjective.sqrcCrNr')rÚ&ReproduceDistancesObjective_dis_weightrWrrrÚ dis_weightÎrSz&ReproduceDistancesObjective.dis_weightz& "real" corrected distances (size n^2)z wanted distances (size n^2)z% weights for each distance (size n^2)cCr‹r')rÚ*ReproduceDistancesObjective_get_source_disrûrrrÚget_source_disÔrz*ReproduceDistancesObjective.get_source_discCrNr')rÚ(ReproduceDistancesObjective_compute_costrrrrr×rSz(ReproduceDistancesObjective.compute_costcCr‡r')rÚ'ReproduceDistancesObjective_cost_updaterrrrrÚr‰z'ReproduceDistancesObjective.cost_updatec Crr')rÚ$ReproduceDistancesObjective_swiginitÚnew_ReproduceDistancesObjective)rrQÚ source_dis_inÚ target_dis_inÚdis_weight_factorrrrrHÝrz$ReproduceDistancesObjective.__init__cCr‡r'©rÚ.ReproduceDistancesObjective_compute_mean_stdev©ràrÑÚmean_outÚ stddev_outrrrÚcompute_mean_stdevàrz.ReproduceDistancesObjective.compute_mean_stdevcCrNr')rÚ1ReproduceDistancesObjective_set_affine_target_dis)rr(rrrÚset_affine_target_disärSz1ReproduceDistancesObjective.set_affine_target_disN)rrr1rrrr rÚ1ReproduceDistancesObjective_dis_weight_factor_getÚ1ReproduceDistancesObjective_dis_weight_factor_setr*Ú staticmethodrr!Ú*ReproduceDistancesObjective_source_dis_getÚ*ReproduceDistancesObjective_source_dis_setÚ source_disÚ*ReproduceDistancesObjective_target_dis_getÚ*ReproduceDistancesObjective_target_dis_setÚ target_disÚ'ReproduceDistancesObjective_weights_getÚ'ReproduceDistancesObjective_weights_setr…r#rrrHr0r2Ú"delete_ReproduceDistancesObjectivervrrrrrÅs$   rcCrJr'rr7rrrrërMrcCr‡r'r+r-rrrr,îr‰r,c@s–eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ddZeejejƒZdd „ZeejejƒZeejejd dZd d „Zd d„ZejZdS)ÚSimulatedAnnealingOptimizerz= Simulated annealing optimization algorithm for permutations.cCr5r'r6r7rrrr9ôr:z$SimulatedAnnealingOptimizer.cCr;r'r6r<rrrr9ôr>r?r@z size of the permutationcCót |t ||¡¡dS)z! logs values of the cost functionN)rÚ$SimulatedAnnealingOptimizer_swiginitÚnew_SimulatedAnnealingOptimizer)rrlrNrrrrHúrWz$SimulatedAnnealingOptimizer.__init__z& remember initial cost of optimizationcCrNr')rÚ$SimulatedAnnealingOptimizer_optimizerrrrÚoptimizerSz$SimulatedAnnealingOptimizer.optimizecCrNr')rÚ,SimulatedAnnealingOptimizer_run_optimization)rÚ best_permrrrÚrun_optimizationrSz,SimulatedAnnealingOptimizer.run_optimizationN)rrr1r2rrrr rÚ#SimulatedAnnealingOptimizer_obj_getÚ#SimulatedAnnealingOptimizer_obj_setrlÚ!SimulatedAnnealingOptimizer_n_getÚ!SimulatedAnnealingOptimizer_n_setrQÚ'SimulatedAnnealingOptimizer_logfile_getÚ'SimulatedAnnealingOptimizer_logfile_setÚlogfilerHÚ#SimulatedAnnealingOptimizer_rnd_getÚ#SimulatedAnnealingOptimizer_rnd_setÚrndÚ)SimulatedAnnealingOptimizer_init_cost_getÚ)SimulatedAnnealingOptimizer_init_cost_setÚ init_costrDrGÚ"delete_SimulatedAnnealingOptimizerrvrrrrr?ñs r?c@sÀeZdZdZedd„dd„ddZeZej Z ej Z ej Z eejejƒZeejejddZeejejddZeejejd dZeejejƒZd d „Zd d „Zdd„Z dd„Z!dd„Z"ej#Z$dS)ÚPolysemousTrainingz5 optimizes the order of indices in a ProductQuantizercCr5r'r6r7rrrr9 r:zPolysemousTraining.cCr;r'r6r<rrrr9 r>r?r@z” use 1/4 of the training points for the optimization, with max. ntrain_permutation. If ntrain_permutation == 0: train on centroids z( decay of exp that weights distance losszA refuse to train if it would require more than that amount of RAMcCryr')rÚPolysemousTraining_swiginitÚnew_PolysemousTrainingrLrrrrH!r|zPolysemousTraining.__init__cCr‡)z reorder the centroids so that the Hamming distance becomes a good approximation of the SDC distance (called by train) )rÚ*PolysemousTraining_optimize_pq_for_hamming©rrnrQr8rrrÚoptimize_pq_for_hamming$rùz*PolysemousTraining.optimize_pq_for_hammingcCr‡©z" called by optimize_pq_for_hamming)rÚ#PolysemousTraining_optimize_rankingrZrrrÚoptimize_ranking+rz#PolysemousTraining.optimize_rankingcCrNr\)rÚ/PolysemousTraining_optimize_reproduce_distances©rrnrrrÚoptimize_reproduce_distances/r z/PolysemousTraining.optimize_reproduce_distancescCrN)z& make sure we don't blow up the memory)rÚ*PolysemousTraining_memory_usage_per_threadr`rrrÚmemory_usage_per_thread3r z*PolysemousTraining.memory_usage_per_threadN)%rrr1r2rrrr rÚPolysemousTraining_OT_NoneÚOT_NoneÚ/PolysemousTraining_OT_ReproduceDistances_affineÚOT_ReproduceDistances_affineÚ+PolysemousTraining_OT_Ranking_weighted_diffÚOT_Ranking_weighted_diffÚ(PolysemousTraining_optimization_type_getÚ(PolysemousTraining_optimization_type_setÚoptimization_typeÚ)PolysemousTraining_ntrain_permutation_getÚ)PolysemousTraining_ntrain_permutation_setÚntrain_permutationÚ(PolysemousTraining_dis_weight_factor_getÚ(PolysemousTraining_dis_weight_factor_setr*Ú!PolysemousTraining_max_memory_getÚ!PolysemousTraining_max_memory_setÚ max_memoryÚ"PolysemousTraining_log_pattern_getÚ"PolysemousTraining_log_pattern_setÚ log_patternrHr[r^rarcÚdelete_PolysemousTrainingrvrrrrrV s( rVc@seZdZdZedd„dd„ddZeZeej ej ddZ dd „Z d d „Z dd d„Zdd„Zdd„Zdd„ZeejejddZeejejddZejZ ejZ ejZ ejZ ej Z! ej"Z# eej$ej%ƒZ&eej'ej(ƒZ)eej*ej+ddZ,dd„Z-dd„Z.dd„Z/ej0Z1d S)ÚIndexPQz_ Index based on a product quantizer. Stored vectors are approximated by PQ codes. cCr5r'r6r7rrrr9Ar:zIndexPQ.cCr;r'r6r<rrrr9Ar>r?r@z1 The product quantizer used to encode the vectorscGr$r')rÚIndexPQ_swiginitÚ new_IndexPQrprrrrHEr.zIndexPQ.__init__cCr‹r')rÚ IndexPQ_trainr“rrrr”Hrz IndexPQ.trainNc CrÈr')rÚIndexPQ_searchr rrrr¢Kr.zIndexPQ.searchcCr‡r')rÚIndexPQ_sa_encoderÏrrrrÐNr‰zIndexPQ.sa_encodecCr‡r')rÚIndexPQ_sa_decoderÓrrrrÔQr‰zIndexPQ.sa_decodecCrJr')rÚ%IndexPQ_get_FlatCodesDistanceComputerrLrrrrTrMz%IndexPQ.get_FlatCodesDistanceComputerz false = standard PQz, parameters used for the polysemous trainingz$ Hamming threshold used for polysemyc CrÃr')rÚIndexPQ_search_core_polysemous)rrQr8rÅrÆrÇÚ polysemous_htÚgeneralized_hammingrrrÚsearch_core_polysemoushrzIndexPQ.search_core_polysemouscCrŽ)a prepare query for a polysemous search, but instead of computing the result, just get the histogram of Hamming distances. May be computed on a provided dataset if xb != NULL :type dist_histogram: int :param dist_histogram: (M * nbits + 1) )rÚ"IndexPQ_hamming_distance_histogram)rrQr8r¸r%Údist_histogramrrrÚhamming_distance_histogramkóz"IndexPQ.hamming_distance_histogramcCr‡)a compute pairwise distances between queries and database :type n: int :param n: nb of query vectors :type x: float :param x: query vector, size n * d :type dis: int :param dis: output distances, size n * ntotal )rÚIndexPQ_hamming_distance_table)rrQr8rºrrrÚhamming_distance_tableurÑzIndexPQ.hamming_distance_tabler')2rrr1r2rrrr rÚIndexPQ_pq_getÚIndexPQ_pq_setrnrHr”r¢rÐrÔrÚ"IndexPQ_do_polysemous_training_getÚ"IndexPQ_do_polysemous_training_setÚdo_polysemous_trainingÚIndexPQ_polysemous_training_getÚIndexPQ_polysemous_training_setÚpolysemous_trainingÚ IndexPQ_ST_PQÚST_PQÚ IndexPQ_ST_HEÚST_HEÚIndexPQ_ST_generalized_HEÚST_generalized_HEÚIndexPQ_ST_SDCÚST_SDCÚIndexPQ_ST_polysemousÚ ST_polysemousÚ IndexPQ_ST_polysemous_generalizeÚST_polysemous_generalizeÚIndexPQ_search_type_getÚIndexPQ_search_type_setrÕÚIndexPQ_encode_signs_getÚIndexPQ_encode_signs_setÚ encode_signsÚIndexPQ_polysemous_ht_getÚIndexPQ_polysemous_ht_setr‚r„r‡rŠÚdelete_IndexPQrvrrrrry;s@  ryc@óTeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZdd„ZejZd S) ÚSearchParametersPQz* override search parameters from the classcCr5r'r6r7rrrr9‰r:zSearchParametersPQ.cCr;r'r6r<rrrr9‰r>r?r@cCryr')rÚSearchParametersPQ_swiginitÚnew_SearchParametersPQrLrrrrHŽr|zSearchParametersPQ.__init__N)rrr1r2rrrr rÚ"SearchParametersPQ_search_type_getÚ"SearchParametersPQ_search_type_setrÕÚ$SearchParametersPQ_polysemous_ht_getÚ$SearchParametersPQ_polysemous_ht_setr‚rHÚdelete_SearchParametersPQrvrrrrr¨†ó r¨c@ójeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZdd„Zd d „ZejZd S) Ú IndexPQStatszs statistics are robust to internal threading, but not if IndexPQ::search is called by multiple threads cCr5r'r6r7rrrr9›r:zIndexPQStats.cCr;r'r6r<rrrr9›r>r?r@cCryr')rÚIndexPQStats_swiginitÚnew_IndexPQStatsrLrrrrH¡r|zIndexPQStats.__init__cCrJr')rÚIndexPQStats_resetrLrrrr{¤rMzIndexPQStats.resetN)rrr1r2rrrr rÚIndexPQStats_nq_getÚIndexPQStats_nq_setr#ÚIndexPQStats_ncode_getÚIndexPQStats_ncode_setÚncodeÚIndexPQStats_n_hamming_pass_getÚIndexPQStats_n_hamming_pass_setÚn_hamming_passrHr{Údelete_IndexPQStatsrvrrrrr²•s r²c@speZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z dd d „Z d d „Zdd„Zdd„Zdd„ZejZd S)ÚMultiIndexQuantizerze Quantizer where centroids are virtual: they are the Cartesian product of sub-centroids. cCr5r'r6r7rrrr9±r:zMultiIndexQuantizer.cCr;r'r6r<rrrr9±r>r?r@cCr‹r')rÚMultiIndexQuantizer_trainr“rrrr”µrzMultiIndexQuantizer.trainNc CrÈr')rÚMultiIndexQuantizer_searchr rrrr¢¸r.zMultiIndexQuantizer.searchcCr‹)z$ add and reset will crash at runtime)rÚMultiIndexQuantizer_addr“rrrr—»rózMultiIndexQuantizer.addcCrJr')rÚMultiIndexQuantizer_resetrLrrrr{¿rMzMultiIndexQuantizer.resetcGr$r')rÚMultiIndexQuantizer_swiginitÚnew_MultiIndexQuantizerrprrrrHÂr.zMultiIndexQuantizer.__init__cCr‹r')rÚMultiIndexQuantizer_reconstructr±rrrr´ÅrzMultiIndexQuantizer.reconstructr')rrr1r2rrrr rÚMultiIndexQuantizer_pq_getÚMultiIndexQuantizer_pq_setrnr”r¢r—r{rHr´Údelete_MultiIndexQuantizerrvrrrrr¿«s  r¿c@sjeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ƒZdd „Zd d „Zdd d„ZejZd S)ÚMultiIndexQuantizer2zH MultiIndexQuantizer where the PQ assignmnet is performed by sub-indexescCr5r'r6r7rrrr9Ïr:zMultiIndexQuantizer2.cCr;r'r6r<rrrr9Ïr>r?r@z M Indexes on d / M dimensionscGr$r')rÚMultiIndexQuantizer2_swiginitÚnew_MultiIndexQuantizer2rprrrrHÔr.zMultiIndexQuantizer2.__init__cCr‹r')rÚMultiIndexQuantizer2_trainr“rrrr”×rzMultiIndexQuantizer2.trainNc CrÈr')rÚMultiIndexQuantizer2_searchr rrrr¢Úr.zMultiIndexQuantizer2.searchr')rrr1r2rrrr rÚ'MultiIndexQuantizer2_assign_indexes_getÚ'MultiIndexQuantizer2_assign_indexes_setÚassign_indexesÚ#MultiIndexQuantizer2_own_fields_getÚ#MultiIndexQuantizer2_own_fields_setr¹rHr”r¢Údelete_MultiIndexQuantizer2rvrrrrrÊÌs  rÊc@sheZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z dd d „Z d d „Zdd„Zdd„ZejZd S)ÚIndexAdditiveQuantizerzL Abstract class for additive quantizers. The search functions are in common.cCr5r'r6r7rrrr9är:zIndexAdditiveQuantizer.cCr;r'r6r<rrrr9är>r?r@cGr$r')rÚIndexAdditiveQuantizer_swiginitÚnew_IndexAdditiveQuantizerrprrrrHèr.zIndexAdditiveQuantizer.__init__Nc CrÈr')rÚIndexAdditiveQuantizer_searchr rrrr¢ër.zIndexAdditiveQuantizer.searchcCr‡r')rÚ IndexAdditiveQuantizer_sa_encoderÏrrrrÐîr‰z IndexAdditiveQuantizer.sa_encodecCr‡r')rÚ IndexAdditiveQuantizer_sa_decoderÓrrrrÔñr‰z IndexAdditiveQuantizer.sa_decodecCrJr')rÚ4IndexAdditiveQuantizer_get_FlatCodesDistanceComputerrLrrrrôrMz4IndexAdditiveQuantizer.get_FlatCodesDistanceComputerr')rrr1r2rrrr rÚIndexAdditiveQuantizer_aq_getÚIndexAdditiveQuantizer_aq_setÚaqrHr¢rÐrÔrÚdelete_IndexAdditiveQuantizerrvrrrrrÕás  rÕc@óReZdZdZedd„dd„ddZeZeej ej ddZ dd „Z d d „Z ejZd S) ÚIndexResidualQuantizerú“ Index based on a residual quantizer. Stored vectors are approximated by residual quantization codes. Can also be used as a codec cCr5r'r6r7rrrr9r:zIndexResidualQuantizer.cCr;r'r6r<rrrr9r>r?r@ú2 The residual quantizer used to encode the vectorscGr$r')rÚIndexResidualQuantizer_swiginitÚnew_IndexResidualQuantizerrprrrrHr.zIndexResidualQuantizer.__init__cCr‹r')rÚIndexResidualQuantizer_trainr“rrrr” rzIndexResidualQuantizer.trainN)rrr1r2rrrr rÚIndexResidualQuantizer_rq_getÚIndexResidualQuantizer_rq_setÚrqrHr”Údelete_IndexResidualQuantizerrvrrrrráûs rác@r;) ÚIndexLocalSearchQuantizercCr5r'r6r7rrrr9r:z"IndexLocalSearchQuantizer.cCr;r'r6r<rrrr9r>r?r@cGr$r')rÚ"IndexLocalSearchQuantizer_swiginitÚnew_IndexLocalSearchQuantizerrprrrrHr.z"IndexLocalSearchQuantizer.__init__cCr‹r')rÚIndexLocalSearchQuantizer_trainr“rrrr”rzIndexLocalSearchQuantizer.trainN)rrr1rrrr rÚ!IndexLocalSearchQuantizer_lsq_getÚ!IndexLocalSearchQuantizer_lsq_setrfrHr”Ú delete_IndexLocalSearchQuantizerrvrrrrrërDrëc@rà) ÚIndexProductResidualQuantizerz- Index based on a product residual quantizer.cCr5r'r6r7rrrr9"r:z&IndexProductResidualQuantizer.cCr;r'r6r<rrrr9"r>r?r@ú: The product residual quantizer used to encode the vectorscGr$r')rÚ&IndexProductResidualQuantizer_swiginitÚ!new_IndexProductResidualQuantizerrprrrrH&r.z&IndexProductResidualQuantizer.__init__cCr‹r')rÚ#IndexProductResidualQuantizer_trainr“rrrr”)rz#IndexProductResidualQuantizer.trainN)rrr1r2rrrr rÚ%IndexProductResidualQuantizer_prq_getÚ%IndexProductResidualQuantizer_prq_setÚprqrHr”Ú$delete_IndexProductResidualQuantizerrvrrrrròó ròc@rà) Ú IndexProductLocalSearchQuantizerz1 Index based on a product local search quantizer.cCr5r'r6r7rrrr93r:z)IndexProductLocalSearchQuantizer.cCr;r'r6r<rrrr93r>r?r@ú> The product local search quantizer used to encode the vectorscGr$r')rÚ)IndexProductLocalSearchQuantizer_swiginitÚ$new_IndexProductLocalSearchQuantizerrprrrrH7r.z)IndexProductLocalSearchQuantizer.__init__cCr‹r')rÚ&IndexProductLocalSearchQuantizer_trainr“rrrr”:rz&IndexProductLocalSearchQuantizer.trainN)rrr1r2rrrr rÚ)IndexProductLocalSearchQuantizer_plsq_getÚ)IndexProductLocalSearchQuantizer_plsq_setÚplsqrHr”Ú'delete_IndexProductLocalSearchQuantizerrvrrrrrü0rûrüc@s‚eZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z eej ejd dZd d „Zdd d„Zdd„Zdd„Zdd„ZejZd S)ÚAdditiveCoarseQuantizerz‘ A "virtual" index where the elements are the residual quantizer centroids. Intended for use as a coarse quantizer in an IndexIVF. cCr5r'r6r7rrrr9Hr:z AdditiveCoarseQuantizer.cCr;r'r6r<rrrr9Hr>r?r@cGr$r')rÚ AdditiveCoarseQuantizer_swiginitÚnew_AdditiveCoarseQuantizerrprrrrHLr.z AdditiveCoarseQuantizer.__init__z* norms of centroids, useful for knn-searchcCr‹©z N/A)rÚAdditiveCoarseQuantizer_addr“rrrr—PrózAdditiveCoarseQuantizer.addNc CrÈr')rÚAdditiveCoarseQuantizer_searchr rrrr¢Tr.zAdditiveCoarseQuantizer.searchcCr‹r')rÚ#AdditiveCoarseQuantizer_reconstructr±rrrr´Wrz#AdditiveCoarseQuantizer.reconstructcCr‹r')rÚAdditiveCoarseQuantizer_trainr“rrrr”ZrzAdditiveCoarseQuantizer.traincCrJr)rÚAdditiveCoarseQuantizer_resetrLrrrr{]r`zAdditiveCoarseQuantizer.resetr')rrr1r2rrrr rÚAdditiveCoarseQuantizer_aq_getÚAdditiveCoarseQuantizer_aq_setrÞrHÚ*AdditiveCoarseQuantizer_centroid_norms_getÚ*AdditiveCoarseQuantizer_centroid_norms_setr˜r—r¢r´r”r{Údelete_AdditiveCoarseQuantizerrvrrrrrAs  rc@sBeZdZedd„dd„ddZeZeejej ƒZ ej Z dd„Z dS) Ú'SearchParametersResidualCoarseQuantizercCr5r'r6r7rrrr9fr:z0SearchParametersResidualCoarseQuantizer.cCr;r'r6r<rrrr9fr>r?r@cCryr')rÚ0SearchParametersResidualCoarseQuantizer_swiginitÚ+new_SearchParametersResidualCoarseQuantizerrLrrrrHkr|z0SearchParametersResidualCoarseQuantizer.__init__N)rrr1rrrr rÚ7SearchParametersResidualCoarseQuantizer_beam_factor_getÚ7SearchParametersResidualCoarseQuantizer_beam_factor_setÚ beam_factorÚ.delete_SearchParametersResidualCoarseQuantizerrvrHrrrrres  rc@sveZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZd d „Zdd d „Zdd„Zdd„ZejZd S)ÚResidualCoarseQuantizerzØ The ResidualCoarseQuantizer is a bit specialized compared to the default AdditiveCoarseQuantizer because it can use a beam search at search time (slow but may be useful for very large vocabularies) cCr5r'r6r7rrrr9xr:z ResidualCoarseQuantizer.cCr;r'r6r<rrrr9xr>r?r@rãze factor between the beam size and the search k if negative, use exact search-to-centroid cCrN)z$ computes centroid norms if required)rÚ'ResidualCoarseQuantizer_set_beam_factor)rÚnew_beam_factorrrrÚset_beam_factor€r z'ResidualCoarseQuantizer.set_beam_factorNc CrÈr')rÚResidualCoarseQuantizer_searchr rrrr¢„r.zResidualCoarseQuantizer.searchcCrN)z… Copy the M first codebook levels from other. Useful to crop a ResidualQuantizer to its first M quantizers. )rÚ'ResidualCoarseQuantizer_initialize_fromrŒrrrrã‡r¯z'ResidualCoarseQuantizer.initialize_fromcGr$r')rÚ ResidualCoarseQuantizer_swiginitÚnew_ResidualCoarseQuantizerrprrrrHŽr.z ResidualCoarseQuantizer.__init__r')rrr1r2rrrr rÚResidualCoarseQuantizer_rq_getÚResidualCoarseQuantizer_rq_setréÚ'ResidualCoarseQuantizer_beam_factor_getÚ'ResidualCoarseQuantizer_beam_factor_setrrr¢rãrHÚdelete_ResidualCoarseQuantizerrvrrrrrqs  rc@sFeZdZedd„dd„ddZeZeejej ddZ dd„Z ej Z d S) ÚLocalSearchCoarseQuantizercCr5r'r6r7rrrr9–r:z#LocalSearchCoarseQuantizer.cCr;r'r6r<rrrr9–r>r?r@rãcGr$r')rÚ#LocalSearchCoarseQuantizer_swiginitÚnew_LocalSearchCoarseQuantizerrprrrrHšr.z#LocalSearchCoarseQuantizer.__init__N)rrr1rrrr rÚ"LocalSearchCoarseQuantizer_lsq_getÚ"LocalSearchCoarseQuantizer_lsq_setrfrHÚ!delete_LocalSearchCoarseQuantizerrvrrrrr'•s  r'c@r)ÚIOReaderrôcCr5r'r6r7rrrr9©r:zIOReader.cCr;r'r6r<rrrr9©r>r?r@cOrBrCrDrErrrrH«rIzIOReader.__init__cCr‡r')rÚIOReader___call__©rÚptrr†Únitemsrrrrù°r‰zIOReader.__call__cCrJr')rÚIOReader_filenorLrrrÚfileno³rMzIOReader.filenoN)rrr1r2rrrHrr rÚIOReader_name_getÚIOReader_name_setrrùr3Údelete_IOReaderrvrrrrr-¡s r-c@sReZdZedd„dd„ddZdd„ZeZeej ej ƒZ dd „Z d d „Z ejZd S) ÚIOWritercCr5r'r6r7rrrr9»r:zIOWriter.cCr;r'r6r<rrrr9»r>r?r@cOrBrCrDrErrrrH½rIzIOWriter.__init__cCr‡r')rÚIOWriter___call__r/rrrrùÂr‰zIOWriter.__call__cCrJr')rÚIOWriter_filenorLrrrr3ÅrMzIOWriter.filenoN)rrr1rrrHrr rÚIOWriter_name_getÚIOWriter_name_setrrùr3Údelete_IOWriterrvrrrrr7ºs r7c@rv) ÚVectorIOReadercCr5r'r6r7rrrr9Ír:zVectorIOReader.cCr;r'r6r<rrrr9Ír>r?r@cCr‡r')rÚVectorIOReader___call__r/rrrrùÒr‰zVectorIOReader.__call__cCryr')rÚVectorIOReader_swiginitÚnew_VectorIOReaderrLrrrrHÕr|zVectorIOReader.__init__N)rrr1rrrr rÚVectorIOReader_data_getÚVectorIOReader_data_setr„ÚVectorIOReader_rp_getÚVectorIOReader_rp_setÚrprùrHÚdelete_VectorIOReaderrvrrrrr=Ìrƒr=c@r;) ÚVectorIOWritercCr5r'r6r7rrrr9Ýr:zVectorIOWriter.cCr;r'r6r<rrrr9Ýr>r?r@cCr‡r')rÚVectorIOWriter___call__r/rrrrùár‰zVectorIOWriter.__call__cCryr')rÚVectorIOWriter_swiginitÚnew_VectorIOWriterrLrrrrHär|zVectorIOWriter.__init__N)rrr1rrrr rÚVectorIOWriter_data_getÚVectorIOWriter_data_setr„rùrHÚdelete_VectorIOWriterrvrrrrrGÜrDrGc@ó`eZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ dd„ZejZdd „Zd d „Zd S) Ú FileIOReadercCr5r'r6r7rrrr9ìr:zFileIOReader.cCr;r'r6r<rrrr9ìr>r?r@cGr$r')rÚFileIOReader_swiginitÚnew_FileIOReaderrprrrrHñr.zFileIOReader.__init__cCr‡r')rÚFileIOReader___call__r/rrrrùõr‰zFileIOReader.__call__cCrJr')rÚFileIOReader_filenorLrrrr3ørMzFileIOReader.filenoN)rrr1rrrr rÚFileIOReader_f_getÚFileIOReader_f_setÚfÚFileIOReader_need_close_getÚFileIOReader_need_close_setÚ need_closerHÚdelete_FileIOReaderrvrùr3rrrrrOëó rOc@rN) Ú FileIOWritercCr5r'r6r7rrrr9ÿr:zFileIOWriter.cCr;r'r6r<rrrr9ÿr>r?r@cGr$r')rÚFileIOWriter_swiginitÚnew_FileIOWriterrprrrrHr.zFileIOWriter.__init__cCr‡r')rÚFileIOWriter___call__r/rrrrùr‰zFileIOWriter.__call__cCrJr')rÚFileIOWriter_filenorLrrrr3 rMzFileIOWriter.filenoN)rrr1rrrr rÚFileIOWriter_f_getÚFileIOWriter_f_setrVÚFileIOWriter_need_close_getÚFileIOWriter_need_close_setrYrHÚdelete_FileIOWriterrvrùr3rrrrr\þr[r\c@s®eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejddZeejejddZeejejd dZeejejƒZeejejƒZd d „Zd d „Zej Z!dS)ÚBufferedIOReaderzB wraps an ioreader to make buffered reads to avoid too small readscCr5r'r6r7rrrr9r:zBufferedIOReader.cCr;r'r6r<rrrr9r>r?r@z offset in input streamz# number of bytes returned to callerz' range of available bytes in the buffercGr—)z› :type bsz: int, optional :param bsz: buffer size (bytes). Reads will be done by batched of this size N)rÚBufferedIOReader_swiginitÚnew_BufferedIOReaderrprrrrHózBufferedIOReader.__init__cCr‡r')rÚBufferedIOReader___call__r/rrrrù&r‰zBufferedIOReader.__call__N)"rrr1r2rrrr rÚBufferedIOReader_reader_getÚBufferedIOReader_reader_setÚreaderÚBufferedIOReader_bsz_getÚBufferedIOReader_bsz_setÚbszÚBufferedIOReader_ofs_getÚBufferedIOReader_ofs_setÚofsÚBufferedIOReader_ofs2_getÚBufferedIOReader_ofs2_setÚofs2ÚBufferedIOReader_b0_getÚBufferedIOReader_b0_setÚb0ÚBufferedIOReader_b1_getÚBufferedIOReader_b1_setÚb1ÚBufferedIOReader_buffer_getÚBufferedIOReader_buffer_setÚbufferrHrùÚdelete_BufferedIOReaderrvrrrrrfs rfc@s˜eZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejejƒZeejejddZeejejddZeejejƒZdd „Zd d „ZejZd S) ÚBufferedIOWritercCr5r'r6r7rrrr9.r:zBufferedIOWriter.cCr;r'r6r<rrrr9.r>r?r@z% number of bytes received from callerz amount of data in buffercGr$r')rÚBufferedIOWriter_swiginitÚnew_BufferedIOWriterrprrrrH7r.zBufferedIOWriter.__init__cCr‡r')rÚBufferedIOWriter___call__r/rrrrù:r‰zBufferedIOWriter.__call__N)rrr1rrrr rÚBufferedIOWriter_writer_getÚBufferedIOWriter_writer_setÚwriterÚBufferedIOWriter_bsz_getÚBufferedIOWriter_bsz_setrpÚBufferedIOWriter_ofs_getÚBufferedIOWriter_ofs_setrsÚBufferedIOWriter_ofs2_getÚBufferedIOWriter_ofs2_setrvÚBufferedIOWriter_b0_getÚBufferedIOWriter_b0_setryÚBufferedIOWriter_buffer_getÚBufferedIOWriter_buffer_setrrHrùÚdelete_BufferedIOWriterrvrrrrr-s rcGr¼r')rÚfourccr¾rrrr“BrMr“cGr¼r')rÚ fourcc_invr¾rrrr”ErMr”cCrJr')rÚfourcc_inv_printabler7rrrr•HrMr•c@sPeZdZdZedd„dd„ddZdd„ZeZe j Z d d „Z d d „Z d d„ZdS)ÚInvertedListsIteratora Copyright (c) Facebook, Inc. and its affiliates. This source code is licensed under the MIT license found in the LICENSE file in the root directory of this source tree. Definition of inverted lists + a few common classes that implement the interface. cCr5r'r6r7rrrr9Ur:zInvertedListsIterator.cCr;r'r6r<rrrr9Ur>r?r@cOrBrCrDrErrrrHWrIzInvertedListsIterator.__init__cCrJr')rÚ"InvertedListsIterator_is_availablerLrrrÚ is_available\rMz"InvertedListsIterator.is_availablecCrJr')rÚInvertedListsIterator_nextrLrrrr]_rMzInvertedListsIterator.nextcCrJr')rÚ&InvertedListsIterator_get_id_and_codesrLrrrÚget_id_and_codesbrMz&InvertedListsIterator.get_id_and_codesN)rrr1r2rrrHrr rÚdelete_InvertedListsIteratorrvr˜r]r›rrrrr–Js  r–c@s8eZdZdZedd„dd„ddZdd„ZeZee j e j d dZ ee j e jd dZee je jƒZe jZe jZ d d „Zd d„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Z dd „Z!d!d"„Z"d#d$„Z#d%d&„Z$d'd(„Z%d)d*„Z&d+d,„Z'e j(Z)e j*Z+e j,Z-e j.Z/e j0Z1d-d.„Z2d/d0„Z3d1d2„Z4d3d4„Z5d5S)6Ú InvertedListszò Table of inverted lists multithreading rules: - concurrent read accesses are allowed - concurrent update accesses are allowed - for resize and add_entries, only concurrent access to different lists are allowed cCr5r'r6r7rrrr9rr:zInvertedLists.cCr;r'r6r<rrrr9rr>r?r@cOrBrCrDrErrrrHtrIzInvertedLists.__init__ú number of possible key valuesú code size per vector in bytescCrNr')rÚInvertedLists_is_empty©rÚlist_norrrÚis_emptyrSzInvertedLists.is_emptycCrN)z get the size of a list)rÚInvertedLists_list_sizer¡rrrÚ list_size„r zInvertedLists.list_sizecCrN)z) get iterable for lists that use_iterator)rÚInvertedLists_get_iteratorr¡rrrÚ get_iteratorˆr zInvertedLists.get_iteratorcCrN)z­ get the codes for an inverted list must be released by release_codes :rtype: uint8_t :return: codes size list_size * code_size )rÚInvertedLists_get_codesr¡rrrÚ get_codesŒrôzInvertedLists.get_codescCrN)z™ get the ids for an inverted list must be released by release_ids :rtype: int :return: ids size list_size )rÚInvertedLists_get_idsr¡rrrÚget_ids–rôzInvertedLists.get_idscCr‹)zC release codes returned by get_codes (default implementation is nop)rÚInvertedLists_release_codes©rr¢rrrrÚ release_codes rózInvertedLists.release_codescCr‹)z release ids returned by get_ids)rÚInvertedLists_release_ids©rr¢rArrrÚ release_ids¤rózInvertedLists.release_idscCr‹)zN :rtype: int :return: a single id in an inverted list )rÚInvertedLists_get_single_id©rr¢r.rrrÚ get_single_id¨râzInvertedLists.get_single_idcCr‹)z‹ :rtype: uint8_t :return: a single code in an inverted list (should be deallocated with release_codes) )rÚInvertedLists_get_single_coder³rrrÚget_single_code¯rñzInvertedLists.get_single_codecCr‹)zs prepare the following lists (default does nothing) a list can be -1 hence the signed long )rÚInvertedLists_prefetch_lists©rÚlist_nosÚnlistrrrÚprefetch_lists·râzInvertedLists.prefetch_listscCr‡)z" add one entry to an inverted list)rÚInvertedLists_add_entry)rr¢Útheidr›rrrÚ add_entry¾rzInvertedLists.add_entrycCrmr')rÚInvertedLists_add_entries©rr¢Ún_entryrAr›rrrÚ add_entriesÂrrzInvertedLists.add_entriescCrmr')rÚInvertedLists_update_entry)rr¢r.Úidr›rrrÚ update_entryÅrrzInvertedLists.update_entrycCrŽr')rÚInvertedLists_update_entries©rr¢r.rÁrAr›rrrÚupdate_entriesÈr|zInvertedLists.update_entriescCr‹r')rÚInvertedLists_resize©rr¢Únew_sizerrrrŠËrzInvertedLists.resizecCrJr')rÚInvertedLists_resetrLrrrr{ÎrMzInvertedLists.resetcCr‹)z- move all entries from oivf (empty on output))rÚInvertedLists_merge_from)rÚoivfrÙrrrrÚÑrózInvertedLists.merge_fromcCrm)z† copy a subset of the entries index to the other index :rtype: int :return: number of entries copied )rÚInvertedLists_copy_subset_to©rrÚ subset_typeÚa1Úa2rrrÚcopy_subset_toÚrszInvertedLists.copy_subset_tocCrJ)z& 1= perfectly balanced, >1: imbalanced)rÚInvertedLists_imbalance_factorrLrrrrâr`zInvertedLists.imbalance_factorcCrJ)z, display some stats about the inverted lists)rÚInvertedLists_print_statsrLrrrÚ print_statsær`zInvertedLists.print_statscCrJ)z sum up list sizes)rÚInvertedLists_compute_ntotalrLrrrÚcompute_ntotalêr`zInvertedLists.compute_ntotalN)6rrr1r2rrrHrr rÚInvertedLists_nlist_getÚInvertedLists_nlist_setrºÚInvertedLists_code_size_getÚInvertedLists_code_size_setrœÚInvertedLists_use_iterator_getÚInvertedLists_use_iterator_setÚ use_iteratorÚdelete_InvertedListsrvÚInvertedLists_INVALID_CODE_SIZEÚINVALID_CODE_SIZEr£r¥r§r©r«r®r±r´r¶r»r¾rÂrÅrÈrŠr{rÚÚ"InvertedLists_SUBSET_TYPE_ID_RANGEÚSUBSET_TYPE_ID_RANGEÚ InvertedLists_SUBSET_TYPE_ID_MODÚSUBSET_TYPE_ID_MODÚ'InvertedLists_SUBSET_TYPE_ELEMENT_RANGEÚSUBSET_TYPE_ELEMENT_RANGEÚ*InvertedLists_SUBSET_TYPE_INVLIST_FRACTIONÚSUBSET_TYPE_INVLIST_FRACTIONÚ!InvertedLists_SUBSET_TYPE_INVLISTÚSUBSET_TYPE_INVLISTrÔrr×rÙrrrrrhsJ    rc@sˆeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ddZdd „Zd d „Zd d „Zdd„Zdd„Zdd„Zdd„ZejZdS)ÚArrayInvertedListsz> simple (default) implementation as an array of inverted listscCr5r'r6r7rrrr9ôr:zArrayInvertedLists.cCr;r'r6r<rrrr9ôr>r?r@z Inverted lists for indexescCr—r')rÚArrayInvertedLists_swiginitÚnew_ArrayInvertedLists)rrºrœrrrrHùrzArrayInvertedLists.__init__cCrNr')rÚArrayInvertedLists_list_sizer¡rrrr¥ürSzArrayInvertedLists.list_sizecCrNr')rÚArrayInvertedLists_get_codesr¡rrrr©ÿrSzArrayInvertedLists.get_codescCrNr')rÚArrayInvertedLists_get_idsr¡rrrr«rSzArrayInvertedLists.get_idscCrmr')rÚArrayInvertedLists_add_entriesrÀrrrrÂrrzArrayInvertedLists.add_entriescCrŽr')rÚ!ArrayInvertedLists_update_entriesrÇrrrrÈr|z!ArrayInvertedLists.update_entriescCr‹r')rÚArrayInvertedLists_resizerÊrrrrŠ rzArrayInvertedLists.resizeN)rrr1r2rrrr rÚArrayInvertedLists_codes_getÚArrayInvertedLists_codes_setrÚArrayInvertedLists_ids_getÚArrayInvertedLists_ids_setrArHr¥r©r«rÂrÈrŠÚdelete_ArrayInvertedListsrvrrrrrîñs rîc@rò)ÚReadOnlyInvertedListsz+ invlists that fail for all write functionscCr5r'r6r7rrrr9r:zReadOnlyInvertedLists.cCr;r'r6r<rrrr9r>r?r@cOrBrCrDrErrrrHrIzReadOnlyInvertedLists.__init__cCrmr')rÚ!ReadOnlyInvertedLists_add_entriesrÀrrrrÂrrz!ReadOnlyInvertedLists.add_entriescCrŽr')rÚ$ReadOnlyInvertedLists_update_entriesrÇrrrrÈr|z$ReadOnlyInvertedLists.update_entriescCr‹r')rÚReadOnlyInvertedLists_resizerÊrrrrŠ!rzReadOnlyInvertedLists.resizeN)rrr1r2rrrHrr rÂrÈrŠrÚdelete_ReadOnlyInvertedListsrvrrrrrüs rüc@s†eZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z d d „Z d d „Zd d„Zdd„Zdd„Zdd„Zdd„Zdd„ZejZdS)ÚHStackInvertedListsz# Horizontal stack of inverted listscCr5r'r6r7rrrr9+r:zHStackInvertedLists.cCr;r'r6r<rrrr9+r>r?r@cCr@©z1 build InvertedLists by concatenating nil of themN)rÚHStackInvertedLists_swiginitÚnew_HStackInvertedLists©rÚnilÚilsrrrrH/rWzHStackInvertedLists.__init__cCrNr')rÚHStackInvertedLists_list_sizer¡rrrr¥3rSzHStackInvertedLists.list_sizecCrNr')rÚHStackInvertedLists_get_codesr¡rrrr©6rSzHStackInvertedLists.get_codescCrNr')rÚHStackInvertedLists_get_idsr¡rrrr«9rSzHStackInvertedLists.get_idscCr‹r')rÚ"HStackInvertedLists_prefetch_listsr¸rrrr»<rz"HStackInvertedLists.prefetch_listscCr‹r')rÚ!HStackInvertedLists_release_codesr­rrrr®?rz!HStackInvertedLists.release_codescCr‹r')rÚHStackInvertedLists_release_idsr°rrrr±BrzHStackInvertedLists.release_idscCr‹r')rÚ!HStackInvertedLists_get_single_idr³rrrr´Erz!HStackInvertedLists.get_single_idcCr‹r')rÚ#HStackInvertedLists_get_single_coder³rrrr¶Hrz#HStackInvertedLists.get_single_codeN)rrr1r2rrrr rÚHStackInvertedLists_ils_getÚHStackInvertedLists_ils_setr rHr¥r©r«r»r®r±r´r¶Údelete_HStackInvertedListsrvrrrrr (s r c@s¢eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZdd„Zd d „Zd d „Zd d„Zdd„Zdd„Zdd„Zdd„Zdd„ZejZdS)ÚSliceInvertedListsz3 vertical slice of indexes in another InvertedListscCr5r'r6r7rrrr9Rr:zSliceInvertedLists.cCr;r'r6r<rrrr9Rr>r?r@cCr+r')rÚSliceInvertedLists_swiginitÚnew_SliceInvertedLists)rÚilr»Úi1rrrrHXr/zSliceInvertedLists.__init__cCrNr')rÚSliceInvertedLists_list_sizer¡rrrr¥[rSzSliceInvertedLists.list_sizecCrNr')rÚSliceInvertedLists_get_codesr¡rrrr©^rSzSliceInvertedLists.get_codescCrNr')rÚSliceInvertedLists_get_idsr¡rrrr«arSzSliceInvertedLists.get_idscCr‹r')rÚ SliceInvertedLists_release_codesr­rrrr®drz SliceInvertedLists.release_codescCr‹r')rÚSliceInvertedLists_release_idsr°rrrr±grzSliceInvertedLists.release_idscCr‹r')rÚ SliceInvertedLists_get_single_idr³rrrr´jrz SliceInvertedLists.get_single_idcCr‹r')rÚ"SliceInvertedLists_get_single_coder³rrrr¶mrz"SliceInvertedLists.get_single_codecCr‹r')rÚ!SliceInvertedLists_prefetch_listsr¸rrrr»prz!SliceInvertedLists.prefetch_listsN)rrr1r2rrrr rÚSliceInvertedLists_il_getÚSliceInvertedLists_il_setr ÚSliceInvertedLists_i0_getÚSliceInvertedLists_i0_setr»ÚSliceInvertedLists_i1_getÚSliceInvertedLists_i1_setr rHr¥r©r«r®r±r´r¶r»Údelete_SliceInvertedListsrvrrrrr Os" r c@seZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ dd„Zdd „Zd d „Zd d „Zdd„Zdd„Zdd„Zdd„Zdd„ZejZdS)ÚVStackInvertedListscCr5r'r6r7rrrr9xr:zVStackInvertedLists.cCr;r'r6r<rrrr9xr>r?r@cCr@r )rÚVStackInvertedLists_swiginitÚnew_VStackInvertedListsr rrrrH}rWzVStackInvertedLists.__init__cCrNr')rÚVStackInvertedLists_list_sizer¡rrrr¥rSzVStackInvertedLists.list_sizecCrNr')rÚVStackInvertedLists_get_codesr¡rrrr©„rSzVStackInvertedLists.get_codescCrNr')rÚVStackInvertedLists_get_idsr¡rrrr«‡rSzVStackInvertedLists.get_idscCr‹r')rÚ!VStackInvertedLists_release_codesr­rrrr®Šrz!VStackInvertedLists.release_codescCr‹r')rÚVStackInvertedLists_release_idsr°rrrr±rzVStackInvertedLists.release_idscCr‹r')rÚ!VStackInvertedLists_get_single_idr³rrrr´rz!VStackInvertedLists.get_single_idcCr‹r')rÚ#VStackInvertedLists_get_single_coder³rrrr¶“rz#VStackInvertedLists.get_single_codecCr‹r')rÚ"VStackInvertedLists_prefetch_listsr¸rrrr»–rz"VStackInvertedLists.prefetch_listsN)rrr1rrrr rÚVStackInvertedLists_ils_getÚVStackInvertedLists_ils_setr ÚVStackInvertedLists_cumsz_getÚVStackInvertedLists_cumsz_setÚcumszrHr¥r©r«r®r±r´r¶r»Údelete_VStackInvertedListsrvrrrrr' ws r' c@ó”eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZdd„Zd d „Zd d „Zd d„Zdd„Zdd„Zdd„Zdd„Zdd„ZejZdS)ÚMaskedInvertedListszô use the first inverted lists if they are non-empty otherwise use the second This is useful if il1 has a few inverted lists that are too long, and that il0 has replacement lists for those, with empty lists for the others. cCr5r'r6r7rrrr9¦r:zMaskedInvertedLists.cCr;r'r6r<rrrr9¦r>r?r@cCr—r')rÚMaskedInvertedLists_swiginitÚnew_MaskedInvertedLists)rÚil0Úil1rrrrH«rzMaskedInvertedLists.__init__cCrNr')rÚMaskedInvertedLists_list_sizer¡rrrr¥®rSzMaskedInvertedLists.list_sizecCrNr')rÚMaskedInvertedLists_get_codesr¡rrrr©±rSzMaskedInvertedLists.get_codescCrNr')rÚMaskedInvertedLists_get_idsr¡rrrr«´rSzMaskedInvertedLists.get_idscCr‹r')rÚ!MaskedInvertedLists_release_codesr­rrrr®·rz!MaskedInvertedLists.release_codescCr‹r')rÚMaskedInvertedLists_release_idsr°rrrr±ºrzMaskedInvertedLists.release_idscCr‹r')rÚ!MaskedInvertedLists_get_single_idr³rrrr´½rz!MaskedInvertedLists.get_single_idcCr‹r')rÚ#MaskedInvertedLists_get_single_coder³rrrr¶Àrz#MaskedInvertedLists.get_single_codecCr‹r')rÚ"MaskedInvertedLists_prefetch_listsr¸rrrr»Ãrz"MaskedInvertedLists.prefetch_listsN)rrr1r2rrrr rÚMaskedInvertedLists_il0_getÚMaskedInvertedLists_il0_setr< ÚMaskedInvertedLists_il1_getÚMaskedInvertedLists_il1_setr= rHr¥r©r«r®r±r´r¶r»Údelete_MaskedInvertedListsrvrrrrr9 s  r9 c@r8 )ÚStopWordsInvertedListszr if the inverted list in il is smaller than maxsize then return it, otherwise return an empty invlist cCr5r'r6r7rrrr9Ðr:zStopWordsInvertedLists.cCr;r'r6r<rrrr9Ðr>r?r@cCr—r')rÚStopWordsInvertedLists_swiginitÚnew_StopWordsInvertedLists)rr ÚmaxsizerrrrHÕrzStopWordsInvertedLists.__init__cCrNr')rÚ StopWordsInvertedLists_list_sizer¡rrrr¥ØrSz StopWordsInvertedLists.list_sizecCrNr')rÚ StopWordsInvertedLists_get_codesr¡rrrr©ÛrSz StopWordsInvertedLists.get_codescCrNr')rÚStopWordsInvertedLists_get_idsr¡rrrr«ÞrSzStopWordsInvertedLists.get_idscCr‹r')rÚ$StopWordsInvertedLists_release_codesr­rrrr®árz$StopWordsInvertedLists.release_codescCr‹r')rÚ"StopWordsInvertedLists_release_idsr°rrrr±ärz"StopWordsInvertedLists.release_idscCr‹r')rÚ$StopWordsInvertedLists_get_single_idr³rrrr´çrz$StopWordsInvertedLists.get_single_idcCr‹r')rÚ&StopWordsInvertedLists_get_single_coder³rrrr¶êrz&StopWordsInvertedLists.get_single_codecCr‹r')rÚ%StopWordsInvertedLists_prefetch_listsr¸rrrr»írz%StopWordsInvertedLists.prefetch_listsN)rrr1r2rrrr rÚStopWordsInvertedLists_il0_getÚStopWordsInvertedLists_il0_setr< Ú"StopWordsInvertedLists_maxsize_getÚ"StopWordsInvertedLists_maxsize_setrN rHr¥r©r«r®r±r´r¶r»Údelete_StopWordsInvertedListsrvrrrrrK Ês  rK c@sœeZdZdZedd„dd„ddZdd„ZeZee j d dZ ee j d dZ d d „Zd d„Zdd„Ze jZedd„ƒZedd„ƒZedd„ƒZedd„ƒZdS)ÚInvertedListsIOHookaƒ Callbacks to handle other types of InvertedList objects. The callbacks should be registered with add_callback before calling read_index or read_InvertedLists. The callbacks for OnDiskInvertedLists are registrered by default. The invlist type is identified by: - the key (a fourcc) at read time - the class name (as given by typeid.name) at write time cCr5r'r6r7rrrr9r:zInvertedListsIOHook.cCr;r'r6r<rrrr9r>r?r@cOrBrCrDrErrrrHrIzInvertedListsIOHook.__init__z string version of the fourccz typeid.namecCr‹)z7 write the index to the IOWriter (including the fourcc))rÚInvertedListsIOHook_write)rr rVrrrr  rózInvertedListsIOHook.writecCr‹)z3 called when the fourcc matches this class's fourcc)rÚInvertedListsIOHook_read)rrVÚio_flagsrrrr® rózInvertedListsIOHook.readcCrŽ)a read from a ArrayInvertedLists into this invertedlist type. For this to work, the callback has to be enabled and the io_flag has to be set to IO_FLAG_SKIP_IVF_DATA | (16 upper bits of the fourcc) (default implementation fails) )rÚ+InvertedListsIOHook_read_ArrayInvertedLists)rrVr_ rºrœÚsizesrrrÚread_ArrayInvertedListsrˆz+InvertedListsIOHook.read_ArrayInvertedListscCrJr'©rÚ InvertedListsIOHook_add_callback©Úarg1rrrÚ add_callbackr`z InvertedListsIOHook.add_callbackcCrÜr'©rÚ#InvertedListsIOHook_print_callbacksrrrrÚprint_callbacks râz#InvertedListsIOHook.print_callbackscCrJr'©rÚInvertedListsIOHook_lookup©ÚhrrrÚlookup$r`zInvertedListsIOHook.lookupcCrJr'©rÚ$InvertedListsIOHook_lookup_classname©Ú classnamerrrÚlookup_classname(r`z$InvertedListsIOHook.lookup_classnameN)rrr1r2rrrHrr rÚInvertedListsIOHook_key_getr²Ú!InvertedListsIOHook_classname_getrs r r®rb Údelete_InvertedListsIOHookrvr5rg rj ro rt rrrrr\ ôs&     r\ cCrJr'rc re rrrrd /rMrd cCrÜr'rh rrrrri 2rIri cCrJr'rk rm rrrrl 5rMrl cCrJr'rp rr rrrrq 8rMrq c@s®eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejƒZeejejƒZdd„Zd d „Zd d „Zd d„Zdd„Zdd„Zdd„ZejZ dS)ÚBlockInvertedListsaZ Inverted Lists that are organized by blocks. Different from the regular inverted lists, the codes are organized by blocks of size block_size bytes that reprsent a set of n_per_block. Therefore, code allocations are always rounded up to block_size bytes. The codes are also aligned on 32-byte boundaries for use with SIMD. To avoid misinterpretations, the code_size is set to (size_t)(-1), even if arguably the amount of memory consumed by code is block_size / n_per_block. The writing functions add_entries and update_entries operate on block-aligned data. cCr5r'r6r7rrrr9Kr:zBlockInvertedLists.cCr;r'r6r<rrrr9Kr>r?r@cGr$r')rÚBlockInvertedLists_swiginitÚnew_BlockInvertedListsrprrrrHSr.zBlockInvertedLists.__init__cCrNr')rÚBlockInvertedLists_list_sizer¡rrrr¥VrSzBlockInvertedLists.list_sizecCrNr')rÚBlockInvertedLists_get_codesr¡rrrr©YrSzBlockInvertedLists.get_codescCrNr')rÚBlockInvertedLists_get_idsr¡rrrr«\rSzBlockInvertedLists.get_idscCrmr')rÚBlockInvertedLists_add_entriesrÀrrrrÂ_rrzBlockInvertedLists.add_entriescCrŽ©z not implemented)rÚ!BlockInvertedLists_update_entriesrÇrrrrÈbr”z!BlockInvertedLists.update_entriescCr‹r')rÚBlockInvertedLists_resizerÊrrrrŠfrzBlockInvertedLists.resizeN)!rrr1r2rrrr rÚ"BlockInvertedLists_n_per_block_getÚ"BlockInvertedLists_n_per_block_setÚ n_per_blockÚ!BlockInvertedLists_block_size_getÚ!BlockInvertedLists_block_size_setrÎÚBlockInvertedLists_packer_getÚBlockInvertedLists_packer_setÚpackerÚBlockInvertedLists_codes_getÚBlockInvertedLists_codes_setrÚBlockInvertedLists_ids_getÚBlockInvertedLists_ids_setrArHr¥r©r«rÂrÈrŠÚdelete_BlockInvertedListsrvrrrrrx ;s" rx cCrNr')rÚlo_build)Úlist_idr.rrrr nrSr cCrJr')rÚ lo_listno©Úlorrrr‘ qrMr‘ cCrJr')rÚ lo_offsetr’ rrrr” trMr” c@s¸eZdZdZedd„dd„ddZeZej Z ej Z ej ZeejejƒZeejejddZeejejƒZdd „Zd d „Zd d „Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Z ej!Z"dS)Ú DirectMapz8Direct map: a way to map back from ids to inverted listscCr5r'r6r7rrrr9yr:zDirectMap.cCr;r'r6r<rrrr9yr>r?r@zF map for direct access to the elements. Map ids to LO-encoded entries.cCryr')rÚDirectMap_swiginitÚ new_DirectMaprLrrrrH‚r|zDirectMap.__init__cCr‡)z set type and initialize)rÚDirectMap_set_type)rÚnew_typeÚinvlistsrærrrÚset_type…rzDirectMap.set_typecCrN)z get an entry)rÚ DirectMap_get©rrÄrrrrs‰r z DirectMap.getcCrJ)z for quick checks)rÚ DirectMap_norLrrrÚnor`z DirectMap.nocCrN)zT update the direct_map throw if Array and ids is not NULL )rÚDirectMap_check_can_add)rrArrrÚ check_can_add‘ràzDirectMap.check_can_addcCr‡)z non thread-safe version)rÚDirectMap_add_single_id)rrÄr¢r.rrrÚ add_single_id™rzDirectMap.add_single_idcCrJ)z remove all entries)rÚDirectMap_clearrLrrrr‚r`zDirectMap.clearcCr‹)z£ operations on inverted lists that require translation with a DirectMap remove ids from the InvertedLists, possibly using the direct map )rÚDirectMap_remove_ids)rrUrš rrrr®¡rñzDirectMap.remove_idscCrŽ)z% update entries, using the direct map)rÚDirectMap_update_codes)rrš rQrAr¹rrrrÚ update_codes©r”zDirectMap.update_codesN)#rrr1r2rrrr rÚDirectMap_NoMapÚNoMapÚDirectMap_ArrayÚArrayÚDirectMap_HashtableÚ HashtableÚDirectMap_type_getÚDirectMap_type_setrÚDirectMap_array_getÚDirectMap_array_setÚarrayÚDirectMap_hashtable_getÚDirectMap_hashtable_setÚ hashtablerHr› rsrŸ r¡ r£ r‚r®r§ Údelete_DirectMaprvrrrrr• vs( r• c@s”eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejƒZeejejƒZeejejƒZdd„Zd d „ZejZd S) Ú DirectMapAddz+ Thread-safe way of updating the direct_mapcCr5r'r6r7rrrr9´r:zDirectMapAdd.cCr;r'r6r<rrrr9´r>r?r@cCr+r')rÚDirectMapAdd_swiginitÚnew_DirectMapAdd)rÚ direct_maprQrœrrrrH½r/zDirectMapAdd.__init__cCr‡)z5 add vector i (with id xids[i]) at list_no and offset)rÚDirectMapAdd_add)rr§r¢r.rrrr—ÀrzDirectMapAdd.addN)rrr1r2rrrr rÚDirectMapAdd_direct_map_getÚDirectMapAdd_direct_map_setrº ÚDirectMapAdd_type_getÚDirectMapAdd_type_setrÚDirectMapAdd_ntotal_getÚDirectMapAdd_ntotal_setræÚDirectMapAdd_n_getÚDirectMapAdd_n_setrQÚDirectMapAdd_xids_getÚDirectMapAdd_xids_setrœÚDirectMapAdd_all_ofs_getÚDirectMapAdd_all_ofs_setÚall_ofsrHr—Údelete_DirectMapAddrvrrrrr· ±s r· c@sÄeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZd d„Zdd„Zdd„Zdd„Zdd„Zej Z!dS)ÚLevel1Quantizerz© Encapsulates a quantizer object for the IndexIVF The class isolates the fields that are independent of the storage of the lists (especially training) cCr5r'r6r7rrrr9Ðr:zLevel1Quantizer.cCr;r'r6r<rrrr9Ðr>r?r@ú. quantizer that maps vectors to inverted listsz number of inverted listszÓ = 0: use the quantizer as index in a kmeans training = 1: just pass on the training set to the train() of the quantizer = 2: kmeans training on a flat index + add the centroids to the quantizer ú" whether object owns the quantizerú& to override default clustering paramsú) to override index used during clusteringcCrm©zF Trains the quantizer and calls train_residual to train sub-quantizers)rÚLevel1Quantizer_train_q1)rrQr8rr…rrrÚtrain_q1ÝruzLevel1Quantizer.train_q1cCrJ)z7 compute the number of bytes required to store list ids)rÚ Level1Quantizer_coarse_code_sizerLrrrÚcoarse_code_sizeár`z Level1Quantizer.coarse_code_sizecCr‹r')rÚLevel1Quantizer_encode_listno)rr¢r›rrrÚ encode_listnoårzLevel1Quantizer.encode_listnocCrNr')rÚLevel1Quantizer_decode_listnorrrrÚ decode_listnoèrSzLevel1Quantizer.decode_listnocGr$r')rÚLevel1Quantizer_swiginitÚnew_Level1QuantizerrprrrrHër.zLevel1Quantizer.__init__N)"rrr1r2rrrr rÚLevel1Quantizer_quantizer_getÚLevel1Quantizer_quantizer_setÚ quantizerÚLevel1Quantizer_nlist_getÚLevel1Quantizer_nlist_setrºÚ*Level1Quantizer_quantizer_trains_alone_getÚ*Level1Quantizer_quantizer_trains_alone_setÚquantizer_trains_aloneÚLevel1Quantizer_own_fields_getÚLevel1Quantizer_own_fields_setr¹ÚLevel1Quantizer_cp_getÚLevel1Quantizer_cp_setrÚ$Level1Quantizer_clustering_index_getÚ$Level1Quantizer_clustering_index_setÚclustering_indexrÑ rÓ rÕ r× rHÚdelete_Level1QuantizerrvrrrrrÊ Ès  rÊ c@sfeZdZedd„dd„ddZeZeejej ddZ eej ej ddZ eejejƒZejZdd „Zd S) ÚSearchParametersIVFcCr5r'r6r7rrrr9ór:zSearchParametersIVF.cCr;r'r6r<rrrr9ór>r?r@ú number of probes at query timeú' max nb of codes to visit to do a querycCryr')rÚSearchParametersIVF_swiginitÚnew_SearchParametersIVFrLrrrrHúr|zSearchParametersIVF.__init__N)rrr1rrrr rÚSearchParametersIVF_nprobe_getÚSearchParametersIVF_nprobe_setÚnprobeÚ!SearchParametersIVF_max_codes_getÚ!SearchParametersIVF_max_codes_setÚ max_codesÚ(SearchParametersIVF_quantizer_params_getÚ(SearchParametersIVF_quantizer_params_setÚquantizer_paramsÚdelete_SearchParametersIVFrvrHrrrrrê òs rê c@sleZdZedd„dd„ddZdd„ZeZeej ej ddZ eej ej d dZdd d „Zddd„ZejZd S)ÚIndexIVFInterfacecCr5r'r6r7rrrr9r:zIndexIVFInterface.cCr;r'r6r<rrrr9r>r?r@cOrBrCrDrErrrrHrIzIndexIVFInterface.__init__rë rì Nc Cr»)aö search a set of vectors, that are pre-quantized by the IVF quantizer. Fill in the corresponding heaps with the query results. The default implementation uses InvertedListScanners to do the search. :type n: int :param n: nb of vectors to query :type x: float :param x: query vectors, size nx * d :type assign: int :param assign: coarse quantization indices, size nx * nprobe :type centroid_dis: float :param centroid_dis: distances to coarse centroids, size nx * nprobe :param distance: output distances, size n * k :type labels: int :param labels: output labels, size n * k :type store_pairs: boolean :param store_pairs: store inv list index + inv list offset instead in upper/lower 32 bit of result, instead of ids (used for reranking). :type params: :py:class:`IVFSearchParameters`, optional :param params: used to override the object's search parameters :type stats: :py:class:`IndexIVFStats`, optional :param stats: search stats to be updated (can be null) )rÚ$IndexIVFInterface_search_preassigned© rrQr8rÅrªÚ centroid_disrÆrÇÚ store_pairsr¡ÚstatsrrrÚsearch_preassigned sz$IndexIVFInterface.search_preassignedFc CrJ)aZ Range search a set of vectors, that are pre-quantized by the IVF quantizer. Fill in the RangeSearchResults results. The default implementation uses InvertedListScanners to do the search. :param n: nb of vectors to query :type x: float :param x: query vectors, size nx * d :param assign: coarse quantization indices, size nx * nprobe :param centroid_dis: distances to coarse centroids, size nx * nprobe :type result: :py:class:`RangeSearchResult` :param result: Output results :type store_pairs: boolean, optional :param store_pairs: store inv list index + inv list offset instead in upper/lower 32 bit of result, instead of ids (used for reranking). :type params: :py:class:`IVFSearchParameters`, optional :param params: used to override the object's search parameters :type stats: :py:class:`IndexIVFStats`, optional :param stats: search stats to be updated (can be null) )rÚ*IndexIVFInterface_range_search_preassigned© rr7r8rÊr¶Ú coarse_disrËrý r¡rþ rrrÚrange_search_preassigned(sz*IndexIVFInterface.range_search_preassignedrø©FNN)rrr1rrrHrr rÚIndexIVFInterface_nprobe_getÚIndexIVFInterface_nprobe_setrñ ÚIndexIVFInterface_max_codes_getÚIndexIVFInterface_max_codes_setrô rÿ r Údelete_IndexIVFInterfacervrrrrrù s   rù c@sšeZdZdZedd„dd„ddZdd„ZeZee j e j d dZ ee j e jƒZee je jd dZee je jd dZee jƒZee je jd dZd d„Zdd„Zdd„Zdd„Zdd„ZdLdd„Z dd„Z!dd„Z"dMdd „Z#dNd!d"„Z$dOd#d$„Z%dOd%d&„Z&dPd'd(„Z'd)d*„Z(d+d,„Z)d-d.„Z*dOd/d0„Z+d1d2„Z,d3d4„Z-d5d6„Z.d7d8„Z/d9d:„Z0d;d<„Z1e j2Z3d=d>„Z4d?d@„Z5dQdBdC„Z6dDdE„Z7dLdFdG„Z8dHdI„Z9dJdK„Z:dS)RÚIndexIVFaŽ Index based on a inverted file (IVF) In the inverted file, the quantizer (an Index instance) provides a quantization index for each vector to be added. The quantization index maps to a list (aka inverted list or posting list), where the id of the vector is stored. The inverted list object is required only after trainng. If none is set externally, an ArrayInvertedLists is used automatically. At search time, the vector to be searched is also quantized, and only the list corresponding to the quantization index is searched. This speeds up the search by making it non-exhaustive. This can be relaxed using multi-probe search: a few (nprobe) quantization indices are selected and several inverted lists are visited. Sub-classes implement a post-filtering of the index that refines the distance estimation from the query to databse vectors. cCr5r'r6r7rrrr9\r:zIndexIVF.cCr;r'r6r<rrrr9\r>r?r@cOrBrCrDrErrrrH^rIzIndexIVF.__init__ú Access to the actual datarŸa] Parallel mode determines how queries are parallelized with OpenMP 0 (default): split over queries 1: parallelize over inverted lists 2: parallelize over both 3: split over queries with a finer granularity PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to prevent the heap to be initialized and finalized z\ optional map that maps back ids to invlist entries. This enables reconstruct() cCrJr')rÚIndexIVF_resetrLrrrr{urMzIndexIVF.resetcCr‹rÏ )rÚIndexIVF_trainr“rrrr”xrózIndexIVF.traincCr‹)z! Calls add_with_ids with NULL ids)rÚ IndexIVF_addr“rrrr—|róz IndexIVF.addcCr‡)z1 default implementation that calls encode_vectors)rÚIndexIVF_add_with_idsr›rrrr€rzIndexIVF.add_with_idscCrm)aE Implementation of vector addition where the vector assignments are predefined. The default implementation hands over the code extraction to encode_vectors. :type precomputed_idx: int :param precomputed_idx: quantization indices for the input vectors (size n) )rÚIndexIVF_add_core©rrQr8rœÚprecomputed_idxrrrÚadd_core„rczIndexIVF.add_coreFcCrŽ)a1 Encodes a set of vectors as they would appear in the inverted lists :type list_nos: int :param list_nos: inverted list ids as returned by the quantizer (size n). -1s are ignored. :type codes: uint8_t :param codes: output codes, size n * code_size :type include_listno: boolean, optional :param include_listno: include the list ids in the code (in this case add ceil(log8(nlist)) to the code size) )rÚIndexIVF_encode_vectors©rrQr8r¹rÚinclude_listnorrrÚencode_vectorsr‚zIndexIVF.encode_vectorscCr‡)zí Add vectors that are computed with the standalone codec :type codes: uint8_t :param codes: codes to add size n * sa_code_size() :type xids: int :param xids: corresponding ids, size n )rÚIndexIVF_add_sa_codes)rrQrrœrrrÚ add_sa_codes rzIndexIVF.add_sa_codescCr‹)zu Sub-classes that encode the residuals can train their encoders here does nothing by default )rÚIndexIVF_train_residualr“rrrÚtrain_residual«râzIndexIVF.train_residualNc Cr»r')rÚIndexIVF_search_preassignedrû rrrrÿ ²r½zIndexIVF.search_preassignedc CrJr')rÚ!IndexIVF_range_search_preassignedr rrrr µrz!IndexIVF.range_search_preassignedc CrÈ©z/ assign the vectors, then call search_preassign)rÚIndexIVF_searchr rrrr¢¸rÌzIndexIVF.searchcCrŽr')rÚIndexIVF_range_searchr¥rrrr¦¼r|zIndexIVF.range_searchcCr‹)zŸ Get a scanner for this index (store_pairs means ignore labels) The default search implementation uses this to compute the distances )rÚ IndexIVF_get_InvertedListScanner©rrý rUrrrÚget_InvertedListScanner¿rñz IndexIVF.get_InvertedListScannercCr‹)zI reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2)rÚIndexIVF_reconstructr±rrrr´ÇrózIndexIVF.reconstructcCr‡)a= Update a subset of vectors. The index must have a direct_map :type nv: int :param nv: nb of vectors to update :type idx: int :param idx: vector indices to update, size nv :type v: float :param v: vectors of new values, size nv*d )rÚIndexIVF_update_vectors©rÚnvrÕr=rrrÚupdate_vectorsËr?zIndexIVF.update_vectorscCr‡)a¯ Reconstruct a subset of the indexed vectors. Overrides default implementation to bypass reconstruct() which requires direct_map to be maintained. :type i0: int :param i0: first vector to reconstruct :type ni: int :param ni: nb of vectors to reconstruct :type recons: float :param recons: output array of reconstructed vectors, size ni * d )rÚIndexIVF_reconstruct_nrºrrrr½ÚózIndexIVF.reconstruct_nc CrÃ)aº Similar to search, but also reconstructs the stored vectors (or an approximation in the case of lossy coding) for the search results. Overrides default implementation to avoid having to maintain direct_map and instead fetch the code offsets through the `store_pairs` flag in search_preassigned(). :type recons: float :param recons: reconstructed vectors size (n, k, d) )rÚIndexIVF_search_and_reconstructrÀrrrrÁêó zIndexIVF.search_and_reconstructcCr‡©a1 Reconstruct a vector given the location in terms of (inv list index + inv list offset) instead of the id. Useful for reconstructing when the direct_map is not maintained and the inv list offset is computed by search_preassigned() with `store_pairs` set. )rÚ IndexIVF_reconstruct_from_offset©rr¢r.r³rrrÚreconstruct_from_offsetørz IndexIVF.reconstruct_from_offsetcCrN©z Dataset manipulation functions)rÚIndexIVF_remove_idsr­rrrr®r zIndexIVF.remove_idscCrNr')rÚ#IndexIVF_check_compatible_for_mergerÞrrrrßrSz#IndexIVF.check_compatible_for_mergecCr‹r')rÚIndexIVF_merge_fromr×rrrrÚ rzIndexIVF.merge_fromcCrJr')rÚIndexIVF_get_CodePackerrLrrrr rMzIndexIVF.get_CodePackercCrm)zŒ copy a subset of the entries index to the other index see Invlists::copy_subset_to for the meaning of subset_type )rÚIndexIVF_copy_subset_torÐrrrrÔr¿zIndexIVF.copy_subset_tocCrNr')rÚIndexIVF_get_list_sizer¡rrrÚ get_list_sizerSzIndexIVF.get_list_sizecCrJ)z are the ids sorted?)rÚIndexIVF_check_ids_sortedrLrrrÚcheck_ids_sortedr`zIndexIVF.check_ids_sortedTcCrN©zé initialize a direct map :type new_maintain_direct_map: boolean, optional :param new_maintain_direct_map: if true, create a direct map, else clear it )rÚIndexIVF_make_direct_map©rÚnew_maintain_direct_maprrrÚmake_direct_maprôzIndexIVF.make_direct_mapcCrNr')rÚIndexIVF_set_direct_map_type©rrrrrÚset_direct_map_type)rSzIndexIVF.set_direct_map_typecCr‹)zC replace the inverted lists, old one is deallocated if own_invlists)rÚIndexIVF_replace_invlists©rr rrrrÚreplace_invlists,rózIndexIVF.replace_invlistscCrJr')rÚIndexIVF_sa_code_sizerLrrrrÍ0rMzIndexIVF.sa_code_sizecCr‡r')rÚIndexIVF_sa_encoderÏrrrrÐ3r‰zIndexIVF.sa_encode©Frør r')FNr>);rrr1r2rrrHrr rÚIndexIVF_invlists_getÚIndexIVF_invlists_setrš ÚIndexIVF_own_invlists_getÚIndexIVF_own_invlists_setÚ own_invlistsÚIndexIVF_code_size_getÚIndexIVF_code_size_setrœÚIndexIVF_parallel_mode_getÚIndexIVF_parallel_mode_setÚ parallel_modeÚ'IndexIVF_PARALLEL_MODE_NO_HEAP_INIT_getÚPARALLEL_MODE_NO_HEAP_INITÚIndexIVF_direct_map_getÚIndexIVF_direct_map_setrº r{r”r—rr r r r rÿ r r¢r¦r# r´r( r½rÁr0 r®rßrÚrrÔÚdelete_IndexIVFrvr8 r: r? rB rE rÍrÐrrrrr EsT            r c@sÊeZdZdZedd„dd„ddZdd„ZeZee j e j d dZ ee j e jd dZee je jd dZee je jd dZee je jd dZdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Ze j Z!dS)ÚInvertedListScannerzÌ Object that handles a query. The inverted lists to scan are provided externally. The object has a lot of state, but distance_to_code and scan_codes can be called in multiple threads cCr5r'r6r7rrrr9Ar:zInvertedListScanner.cCr;r'r6r<rrrr9Ar>r?r@cOrBrCrDrErrrrHCrIzInvertedListScanner.__init__z remember current listz keep maximum instead of minimumz/ store positions in invlists rather than labelsz search in this subset of idsz- used in default implementation of scan_codescCrN©z" from now on we handle this query.)rÚInvertedListScanner_set_query©rÚ query_vectorrrrröLr zInvertedListScanner.set_querycCr‹©z- following codes come from this inverted list)rÚInvertedListScanner_set_list©rr¢r rrrÚset_listPrózInvertedListScanner.set_listcCrN©z( compute a single query-to-code distance)rÚ$InvertedListScanner_distance_to_coderrrrrTr z$InvertedListScanner.distance_to_codec CrÈ)aÁ scan a set of codes, compute distances to current query and update heap of results if necessary. Default implemetation calls distance_to_code. :type n: int :param n: number of codes to scan :type codes: uint8_t :param codes: codes to scan (n * code_size) :type ids: int :param ids: corresponding ids (ignored if store_pairs) :type distances: float :param distances: heap distances (size k) :type labels: int :param labels: heap labels (size k) :type k: int :param k: heap size :rtype: int :return: number of heap updates performed )rÚInvertedListScanner_scan_codes©rrQrrArÆrÇrÅrrrÚ scan_codesXszInvertedListScanner.scan_codescCrŽr')rÚ!InvertedListScanner_iterate_codes)rÚiteratorrÆrÇrÅr¥rrrÚ iterate_codesor|z!InvertedListScanner.iterate_codescCrŽ)z« scan a set of codes, compute distances to current query and update results if distances are below radius (default implementation fails) )rÚ$InvertedListScanner_scan_codes_range©rrQrrArÊrËrrrÚscan_codes_rangeróz$InvertedListScanner.scan_codes_rangecCrmr')rÚ'InvertedListScanner_iterate_codes_range)rrg rÊrËr¥rrrÚiterate_codes_range{rrz'InvertedListScanner.iterate_codes_rangeN)"rrr1r2rrrHrr rÚInvertedListScanner_list_no_getÚInvertedListScanner_list_no_setr¢Ú InvertedListScanner_keep_max_getÚ InvertedListScanner_keep_max_setÚkeep_maxÚ#InvertedListScanner_store_pairs_getÚ#InvertedListScanner_store_pairs_setrý ÚInvertedListScanner_sel_getÚInvertedListScanner_sel_setrUÚ!InvertedListScanner_code_size_getÚ!InvertedListScanner_code_size_setrœrör` rre rh rk rn Údelete_InvertedListScannerrvrrrrrX 9s$ rX c@s˜eZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejejƒZeejejƒZeejejƒZeejejƒZdd„Zdd „Zd d „ZejZd S) Ú IndexIVFStatscCr5r'r6r7rrrr9ƒr:zIndexIVFStats.cCr;r'r6r<rrrr9ƒr>r?r@cCryr')rÚIndexIVFStats_swiginitÚnew_IndexIVFStatsrLrrrrHŒr|zIndexIVFStats.__init__cCrJr')rÚIndexIVFStats_resetrLrrrr{rMzIndexIVFStats.resetcCrNr')rÚIndexIVFStats_addrŒrrrr—’rSzIndexIVFStats.addN)rrr1rrrr rÚIndexIVFStats_nq_getÚIndexIVFStats_nq_setr#ÚIndexIVFStats_nlist_getÚIndexIVFStats_nlist_setrºÚIndexIVFStats_ndis_getÚIndexIVFStats_ndis_setÚndisÚIndexIVFStats_nheap_updates_getÚIndexIVFStats_nheap_updates_setÚ nheap_updatesÚ#IndexIVFStats_quantization_time_getÚ#IndexIVFStats_quantization_time_setÚquantization_timeÚIndexIVFStats_search_time_getÚIndexIVFStats_search_time_setÚ search_timerHr{r—Údelete_IndexIVFStatsrvrrrrr{ ‚s r{ cCrN)zn check if two indexes have the same parameters and are trained in the same way, otherwise throw. )rrß)Úindex1Úindex2rrrrßšr¯rßcGr¼r')rÚextract_index_ivfr¾rrrr“ ¡rMr“ cGr¼r')rÚtry_extract_index_ivfr¾rrrr” ¤rMr” cCr‹)z÷ Merge index1 into index0. Works on IndexIVF's and IndexIVF's embedded in a IndexPreTransform. On output, the index1 is empty. :type shift_ids: boolean :param shift_ids:: translate the ids from index1 to index0->prev_ntotal )rÚ merge_into)Úindex0r‘ Ú shift_idsrrrr• §ór• cCr‡r')rÚsearch_centroid)r€r8rQÚ centroid_idsrrrr™ ±r‰r™ c CrÃr')rÚsearch_and_return_centroids)r€rQÚxinrÅrÆrÇÚquery_centroid_idsÚresult_centroid_idsrrrr› ´rr› c@sšeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZd d „Zdd„ZejZdS)ÚSlidingIndexWindowz– A set of IndexIVFs concatenated together in a FIFO fashion. at each "step", the oldest index slice is removed and a new index is added. cCr5r'r6r7rrrr9¼r:zSlidingIndexWindow.cCr;r'r6r<rrrr9¼r>r?r@z. common index that contains the sliding windowz InvertedLists of indexz$ number of slices currently in indexz same as index->nlistz$ cumulative list sizes at each slicecCót |t |¡¡dS)z, index should be initially empty and trainedN)rÚSlidingIndexWindow_swiginitÚnew_SlidingIndexWindow©rr€rrrrHÄrÌzSlidingIndexWindow.__init__cCr‹)a$ Add one index to the current index and remove the oldest one. :type sub_index: :py:class:`Index` :param sub_index: slice to swap in (can be NULL) :type remove_oldest: boolean :param remove_oldest: if true, remove the oldest slices )rÚSlidingIndexWindow_step)rÚ sub_indexÚ remove_oldestrrrÚstepÈr•zSlidingIndexWindow.stepN)rrr1r2rrrr rÚSlidingIndexWindow_index_getÚSlidingIndexWindow_index_setr€ÚSlidingIndexWindow_ils_getÚSlidingIndexWindow_ils_setr ÚSlidingIndexWindow_n_slice_getÚSlidingIndexWindow_n_slice_setÚn_sliceÚSlidingIndexWindow_nlist_getÚSlidingIndexWindow_nlist_setrºÚSlidingIndexWindow_sizes_getÚSlidingIndexWindow_sizes_setra rHr§ Údelete_SlidingIndexWindowrvrrrrrŸ ¶s rŸ cCr‹)z( Get a subset of inverted lists [i0, i1))rÚget_invlist_range)r€r»r rrrr´ Ørór´ cCr‡)z Set a subset of inverted lists)rÚset_invlist_range)r€r»r Úsrcrrrrµ Ürrµ c Cr!)a‡ search an IndexIVF, possibly embedded in an IndexPreTransform with given parameters. This is a way to set the nprobe and get statdistics in a thread-safe way. Optionally returns (if non-nullptr): - nb_dis: number of distances computed - ms_per_stage: [0]: preprocessing time [1]: coarse quantization, [2]: list scanning )rÚsearch_with_parameters) r€rQr8rÅrÆrÇr¡Únb_disÚ ms_per_stagerrrr· às r· c CrÃ)z4 same as search_with_parameters but for range search)rÚrange_search_with_parameters)r€rQr8rÊrËr¡r¸ r¹ rrrrº îrWrº cCrN)z¤ Build an IndexIVFResidualQuantizer from an ResidualQuantizer, using the nlevel first components as coarse quantizer and the rest as codes in invlists )rÚivf_residual_from_quantizer)rf Únlevelrrrr» òr¯r» cCr‡)aË add from codes. NB that the norm component is not used, so the code_size can be provided. :type ivfrq: :py:class:`IndexIVFResidualQuantizer` :param ivfrq: index to populate with the codes :type codes: uint8_t :param codes: codes to add, size (ncode, code_size) :type code_size: int, optional :param code_size: override the ivfrq's code_size, useful if the norm encoding is different )rÚ ivf_residual_add_from_flat_codes)Úivfrqrºrrœrrrr½ ùr?r½ c@seZdZdZedd„dd„ddZeZej Z ej Z ej Z ejZejZejZ ejZ eejejƒZejZ ejZ ejZ ej Z! eej"ej#ƒZ$eej%ej&ƒZ'eej(ej)ddZ*eej+ej,ddZ-d d „Z.d d „Z/d d„Z0dd„Z1dd„Z2dd„Z3dd„Z4dd„Z5ddd„Z6ej7Z8dS)ÚScalarQuantizerz The uniform quantizer has a range [vmin, vmax]. The range can be the same for all dimensions (uniform) or specific per dimension (default). cCr5r'r6r7rrrr9r:zScalarQuantizer.cCr;r'r6r<rrrr9r>r?r@z bits per scalar codez% trained values (including the range)cGr$r')rÚScalarQuantizer_swiginitÚnew_ScalarQuantizerrprrrrH*r.zScalarQuantizer.__init__cCrJ)z- updates internal values based on qtype and d)rÚ!ScalarQuantizer_set_derived_sizesrLrrrÚset_derived_sizes-r`z!ScalarQuantizer.set_derived_sizescCr‹r')rÚScalarQuantizer_trainr“rrrr”1rzScalarQuantizer.traincCrŽ)z5 Used by an IVF index to train based on the residuals)rÚScalarQuantizer_train_residual)rrQr8rÜ Ú by_residualrrrrr 4r”zScalarQuantizer.train_residualcCr‡)zÌ Encode a set of vectors :type x: float :param x: vectors to encode, size n * d :type codes: uint8_t :param codes: output codes, size n * code_size )rÚScalarQuantizer_compute_codesrÄrrrrÅ8rzScalarQuantizer.compute_codescCr‡)z¯ Decode a set of vectors :param codes: codes to decode, size n * code_size :type x: float :param x: output vectors, size n * d )rÚScalarQuantizer_decoderÇrrrrÈCr¾zScalarQuantizer.decodecCrJr')rÚ ScalarQuantizer_select_quantizerrLrrrÚselect_quantizerMrMz ScalarQuantizer.select_quantizercGrnr')rÚ%ScalarQuantizer_get_distance_computerrprrrrËPrrz%ScalarQuantizer.get_distance_computerFcCrŽr')rÚ*ScalarQuantizer_select_InvertedListScanner)rrnrÜ rý rUrÆ rrrÚselect_InvertedListScannerSr|z*ScalarQuantizer.select_InvertedListScannerNrH )9rrr1r2rrrr rÚScalarQuantizer_QT_8bitÚQT_8bitÚScalarQuantizer_QT_4bitÚQT_4bitÚScalarQuantizer_QT_8bit_uniformÚQT_8bit_uniformÚScalarQuantizer_QT_4bit_uniformÚQT_4bit_uniformÚScalarQuantizer_QT_fp16ÚQT_fp16ÚScalarQuantizer_QT_8bit_directÚQT_8bit_directÚScalarQuantizer_QT_6bitÚQT_6bitÚScalarQuantizer_qtype_getÚScalarQuantizer_qtype_setÚqtypeÚScalarQuantizer_RS_minmaxÚ RS_minmaxÚScalarQuantizer_RS_meanstdÚ RS_meanstdÚScalarQuantizer_RS_quantilesÚ RS_quantilesÚScalarQuantizer_RS_optimÚRS_optimÚScalarQuantizer_rangestat_getÚScalarQuantizer_rangestat_setÚ rangestatÚ!ScalarQuantizer_rangestat_arg_getÚ!ScalarQuantizer_rangestat_arg_setÚ rangestat_argÚScalarQuantizer_bits_getÚScalarQuantizer_bits_setÚbitsÚScalarQuantizer_trained_getÚScalarQuantizer_trained_setÚtrainedrHrà r”r rÅrÈrÊ rËrÍ Údelete_ScalarQuantizerrvrrrrr¿ sN    r¿ c@steZdZdZedd„dd„ddZeZeej ej ddZ dd „Z d d „Z dd d„Zdd„Zdd„Zdd„ZejZd S)ÚIndexScalarQuantizerz'Flat index built on a scalar quantizer.cCr5r'r6r7rrrr9]r:zIndexScalarQuantizer.cCr;r'r6r<rrrr9]r>r?r@z Used to encode the vectorscGr$r')rÚIndexScalarQuantizer_swiginitÚnew_IndexScalarQuantizerrprrrrHar.zIndexScalarQuantizer.__init__cCr‹r')rÚIndexScalarQuantizer_trainr“rrrr”drzIndexScalarQuantizer.trainNc CrÈr')rÚIndexScalarQuantizer_searchr rrrr¢gr.zIndexScalarQuantizer.searchcCrJr')rÚ2IndexScalarQuantizer_get_FlatCodesDistanceComputerrLrrrrjrMz2IndexScalarQuantizer.get_FlatCodesDistanceComputercCr‡r')rÚIndexScalarQuantizer_sa_encoderÏrrrrÐmr‰zIndexScalarQuantizer.sa_encodecCr‡r')rÚIndexScalarQuantizer_sa_decoderÓrrrrÔpr‰zIndexScalarQuantizer.sa_decoder')rrr1r2rrrr rÚIndexScalarQuantizer_sq_getÚIndexScalarQuantizer_sq_setÚsqrHr”r¢rrÐrÔÚdelete_IndexScalarQuantizerrvrrrrrô Zs  rô c@s†eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZdd„Zd d „Zdd d „Zdd„Zdd„Zdd„Zdd„ZejZdS)ÚIndexIVFScalarQuantizerzì An IVF implementation where the components of the residuals are encoded with a scalar quantizer. All distance computations are asymmetric, so the encoded vectors are decoded and approximate distances are computed. cCr5r'r6r7rrrr9r:z IndexIVFScalarQuantizer.cCr;r'r6r<rrrr9r>r?r@cGr$r')rÚ IndexIVFScalarQuantizer_swiginitÚnew_IndexIVFScalarQuantizerrprrrrH„r.z IndexIVFScalarQuantizer.__init__cCr‹r')rÚ&IndexIVFScalarQuantizer_train_residualr“rrrr ‡rz&IndexIVFScalarQuantizer.train_residualFcCrŽr')rÚ&IndexIVFScalarQuantizer_encode_vectors©rrQr8r¹rÚinclude_listnosrrrr Šr|z&IndexIVFScalarQuantizer.encode_vectorscCrmr')rÚ IndexIVFScalarQuantizer_add_corer rrrr rrz IndexIVFScalarQuantizer.add_corecCr‹r')rÚ/IndexIVFScalarQuantizer_get_InvertedListScannerr" rrrr# rz/IndexIVFScalarQuantizer.get_InvertedListScannercCr‡r')rÚ/IndexIVFScalarQuantizer_reconstruct_from_offsetr/ rrrr0 “r‰z/IndexIVFScalarQuantizer.reconstruct_from_offsetcCr‡r')rÚ!IndexIVFScalarQuantizer_sa_decoderÓrrrrÔ–r‰z!IndexIVFScalarQuantizer.sa_decodeNrH )rrr1r2rrrr rÚIndexIVFScalarQuantizer_sq_getÚIndexIVFScalarQuantizer_sq_setrþ Ú'IndexIVFScalarQuantizer_by_residual_getÚ'IndexIVFScalarQuantizer_by_residual_setrÆ rHr r r r# r0 rÔÚdelete_IndexIVFScalarQuantizerrvrrrrr ws  r c@sâeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZejZ ejZ ejZ ejZ eejejƒZeej ej!d dZ"d d „Z#dd„Z$ddd„Z%dd„Z&dd„Z'ej(Z)dS)ÚIndexIVFSpectralHasha„ Inverted list that stores binary codes of size nbit. Before the binary conversion, the dimension of the vectors is transformed from dim d into dim nbit by vt (a random rotation by default). Each coordinate is subtracted from a value determined by threshold_type, and split into intervals of size period. Half of the interval is a 0 bit, the other half a 1. cCr5r'r6r7rrrr9¨r:zIndexIVFSpectralHash.cCr;r'r6r<rrrr9¨r>r?r@z" transformation from d to nbit dimz own the vtz# nb of bits of the binary signaturez interval size for 0s and 1szH Trained threshold. size nlist * nbit or 0 if Thresh_global cGr$r')rÚIndexIVFSpectralHash_swiginitÚnew_IndexIVFSpectralHashrprrrrH¼r.zIndexIVFSpectralHash.__init__cCr‹r')rÚ#IndexIVFSpectralHash_train_residualr“rrrr ¿rz#IndexIVFSpectralHash.train_residualFcCrŽr')rÚ#IndexIVFSpectralHash_encode_vectorsr rrrr Âr|z#IndexIVFSpectralHash.encode_vectorscCr‹r')rÚ,IndexIVFSpectralHash_get_InvertedListScannerr" rrrr# Årz,IndexIVFSpectralHash.get_InvertedListScannercGrn)a£ *Overload 1:* replace the vector transform for an empty (and possibly untrained) index | *Overload 2:* convenience function to get the VT from an index constucted by an index_factory (should end in "LSH") | *Overload 3:* convenience function to get the VT from an index constucted by an index_factory (should end in "LSH") )rÚIndexIVFSpectralHash_replace_vtrprrrÚ replace_vtÈrºzIndexIVFSpectralHash.replace_vtNrH )*rrr1r2rrrr rÚIndexIVFSpectralHash_vt_getÚIndexIVFSpectralHash_vt_setràÚ#IndexIVFSpectralHash_own_fields_getÚ#IndexIVFSpectralHash_own_fields_setr¹ÚIndexIVFSpectralHash_nbit_getÚIndexIVFSpectralHash_nbit_setrŸÚIndexIVFSpectralHash_period_getÚIndexIVFSpectralHash_period_setÚperiodÚ"IndexIVFSpectralHash_Thresh_globalÚ Thresh_globalÚ$IndexIVFSpectralHash_Thresh_centroidÚThresh_centroidÚ)IndexIVFSpectralHash_Thresh_centroid_halfÚThresh_centroid_halfÚ"IndexIVFSpectralHash_Thresh_medianÚ Thresh_medianÚ'IndexIVFSpectralHash_threshold_type_getÚ'IndexIVFSpectralHash_threshold_type_setÚthreshold_typeÚ IndexIVFSpectralHash_trained_getÚ IndexIVFSpectralHash_trained_setrò rHr r r# r Údelete_IndexIVFSpectralHashrvrrrrr s0   r c@s„eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZdd„Zd d „Zdd d „Zdd„Zdd„ZejZdS)ÚIndexIVFAdditiveQuantizerz] Abstract class for IVF additive quantizers. The search functions are in common. cCr5r'r6r7rrrr9år:z"IndexIVFAdditiveQuantizer.cCr;r'r6r<rrrr9år>r?r@cGr$r')rÚ"IndexIVFAdditiveQuantizer_swiginitÚnew_IndexIVFAdditiveQuantizerrprrrrHër.z"IndexIVFAdditiveQuantizer.__init__cCr‹r')rÚ(IndexIVFAdditiveQuantizer_train_residualr“rrrr îrz(IndexIVFAdditiveQuantizer.train_residualFcCrŽr')rÚ(IndexIVFAdditiveQuantizer_encode_vectorsr rrrr ñr|z(IndexIVFAdditiveQuantizer.encode_vectorscCr‹r')rÚ1IndexIVFAdditiveQuantizer_get_InvertedListScannerr" rrrr# ôrz1IndexIVFAdditiveQuantizer.get_InvertedListScannercCr‡r')rÚ#IndexIVFAdditiveQuantizer_sa_decode)rrQrr8rrrrÔ÷r‰z#IndexIVFAdditiveQuantizer.sa_decodeNrH )rrr1r2rrrr rÚ IndexIVFAdditiveQuantizer_aq_getÚ IndexIVFAdditiveQuantizer_aq_setrÞÚ)IndexIVFAdditiveQuantizer_by_residual_getÚ)IndexIVFAdditiveQuantizer_by_residual_setrÆ Ú3IndexIVFAdditiveQuantizer_use_precomputed_table_getÚ3IndexIVFAdditiveQuantizer_use_precomputed_table_setÚuse_precomputed_tablerHr r r# rÔÚ delete_IndexIVFAdditiveQuantizerrvrrrrr/ ßs  r/ c@óJeZdZdZedd„dd„ddZeZeej ej ddZ dd „Z ej Zd S) ÚIndexIVFResidualQuantizerúv IndexIVF based on a residual quantizer. Stored vectors are approximated by residual quantization codes. cCr5r'r6r7rrrr9r:z"IndexIVFResidualQuantizer.cCr;r'r6r<rrrr9r>r?r@rãcGr$r')rÚ"IndexIVFResidualQuantizer_swiginitÚnew_IndexIVFResidualQuantizerrprrrrHr.z"IndexIVFResidualQuantizer.__init__N)rrr1r2rrrr rÚ IndexIVFResidualQuantizer_rq_getÚ IndexIVFResidualQuantizer_rq_setrérHÚ delete_IndexIVFResidualQuantizerrvrrrrr? þó r? c@r> ) ÚIndexIVFLocalSearchQuantizerr@ cCr5r'r6r7rrrr9r:z%IndexIVFLocalSearchQuantizer.cCr;r'r6r<rrrr9r>r?r@z- The LSQ quantizer used to encode the vectorscGr$r')rÚ%IndexIVFLocalSearchQuantizer_swiginitÚ new_IndexIVFLocalSearchQuantizerrprrrrHr.z%IndexIVFLocalSearchQuantizer.__init__N)rrr1r2rrrr rÚ$IndexIVFLocalSearchQuantizer_lsq_getÚ$IndexIVFLocalSearchQuantizer_lsq_setrfrHÚ#delete_IndexIVFLocalSearchQuantizerrvrrrrrG rF rG c@r> ) Ú IndexIVFProductResidualQuantizerz† IndexIVF based on a product residual quantizer. Stored vectors are approximated by product residual quantization codes. cCr5r'r6r7rrrr9&r:z)IndexIVFProductResidualQuantizer.cCr;r'r6r<rrrr9&r>r?r@rócGr$r')rÚ)IndexIVFProductResidualQuantizer_swiginitÚ$new_IndexIVFProductResidualQuantizerrprrrrH*r.z)IndexIVFProductResidualQuantizer.__init__N)rrr1r2rrrr rÚ(IndexIVFProductResidualQuantizer_prq_getÚ(IndexIVFProductResidualQuantizer_prq_setrùrHÚ'delete_IndexIVFProductResidualQuantizerrvrrrrrM rF rM c@r> ) Ú#IndexIVFProductLocalSearchQuantizerzŽ IndexIVF based on a product local search quantizer. Stored vectors are approximated by product local search quantization codes. cCr5r'r6r7rrrr97r:z,IndexIVFProductLocalSearchQuantizer.cCr;r'r6r<rrrr97r>r?r@rýcGr$r')rÚ,IndexIVFProductLocalSearchQuantizer_swiginitÚ'new_IndexIVFProductLocalSearchQuantizerrprrrrH;r.z,IndexIVFProductLocalSearchQuantizer.__init__N)rrr1r2rrrr rÚ,IndexIVFProductLocalSearchQuantizer_plsq_getÚ,IndexIVFProductLocalSearchQuantizer_plsq_setrrHÚ*delete_IndexIVFProductLocalSearchQuantizerrvrrrrrS 1rF rS c@sPeZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ ejZdd„ZdS) ÚSearchParametersHNSWcCr5r'r6r7rrrr9Cr:zSearchParametersHNSW.cCr;r'r6r<rrrr9Cr>r?r@cCryr')rÚSearchParametersHNSW_swiginitÚnew_SearchParametersHNSWrLrrrrHIr|zSearchParametersHNSW.__init__N)rrr1rrrr rÚ!SearchParametersHNSW_efSearch_getÚ!SearchParametersHNSW_efSearch_setÚefSearchÚ0SearchParametersHNSW_check_relative_distance_getÚ0SearchParametersHNSW_check_relative_distance_setÚcheck_relative_distanceÚdelete_SearchParametersHNSWrvrHrrrrrY Bs rY c@s¤eZdZedd„dd„ddZeZeejej ddZ eej ej ddZ eejejddZeejejd dZeejejd dZeejejd dZeejejƒZeejejd dZeej ej!d dZ"eej#ej$ddZ%eej&ej'ddZ(eej)ej*ddZ+eej,ej-ddZ.dd„Z/dd„Z0dd„Z1dd„Z2dd„Z3d7dd„Z4dd „Z5d!d"„Z6d#d$„Z7d%d&„Z8d8d(d)„Z9d*d+„Z:d,d-„Z;d.d/„Ze?d5d6„ƒZ@ejAZBd'S):ÚHNSWcCr5r'r6r7rrrr9Pr:z HNSW.cCr;r'r6r<rrrr9Pr>r?r@z- assignment probability to each layer (sum=1)zf number of neighbors stored per layer (cumulative), should not be changed after first add z5 level of each vector (base level = 1), size = ntotalzf offsets[i] is the offset in the neighbors array where vector i is stored size ntotal + 1 z… neighbors[offsets[i]:offsets[i+1]] is the list of neighbors of vector i for all levels. this is where all storage goes. zW entry point in the search structure (one of the points with maximum level z maximum levelz& expansion factor at construction timez expansion factor at search timezW during search: do we check whether the next best distance is good enough? z& number of entry points in levels > 0.z% use bounded queue during explorationcCr‹)z‰ initialize the assign_probas and cum_nneighbor_per_level to have 2*M links on level 0 and M links on levels > 0 )rÚHNSW_set_default_probas)rrÚ levelMultrrrÚset_default_probasorâzHNSW.set_default_probascCr‹)z< set nb of neighbors for this level (before adding anything))rÚHNSW_set_nb_neighbors)rÚlevel_norQrrrÚset_nb_neighborsvrózHNSW.set_nb_neighborscCrN)z nb of neighbors for this level)rÚHNSW_nb_neighbors©rÚlayer_norrrÚ nb_neighborszr zHNSW.nb_neighborscCrN)z0 cumumlative nb up to (and excluding) this level)rÚHNSW_cum_nb_neighborsrk rrrÚcum_nb_neighbors~r zHNSW.cum_nb_neighborscCrm)zA range of entries in the neighbors table of vertex no at layer_no)rÚHNSW_neighbor_range)rrŸ rl ÚbeginÚendrrrÚneighbor_range‚ruzHNSW.neighbor_rangeé cCr  )z* only mandatory parameter: nb of neighborsN)rÚ HNSW_swiginitÚnew_HNSW)rrrrrrH†rÌz HNSW.__init__cCrJ)z$ pick a random level for a new point)rÚHNSW_random_levelrLrrrÚ random_levelŠr`zHNSW.random_levelcCrN)z0 add n random levels to table (for debugging...))rÚHNSW_fill_with_random_linksrPrrrÚfill_with_random_linksŽr zHNSW.fill_with_random_linksc CrÃr')rÚHNSW_add_links_starting_from)rÚptdisÚpt_idÚnearestÚ d_nearestÚlevelÚlocksràrrrÚadd_links_starting_from’rzHNSW.add_links_starting_fromcCrŽ)zk add point pt_id on all levels <= pt_level and build the link structure for them. )rÚHNSW_add_with_locks)rr| Úpt_levelr} r ràrrrÚadd_with_locks•rÙzHNSW.add_with_locksNc CrÈ)z, search interface for 1 point, single thread)rÚ HNSW_search)rÚqdisrÅÚIÚDràr¡rrrr¢œrÌz HNSW.searchc Cr»)z+ search only in level 0 from a given vertex)rÚHNSW_search_level_0) rr‡ rÅÚidxiÚsimirñ Ú nearest_iÚ nearest_drÕÚ search_statsràrrrÚsearch_level_0 szHNSW.search_level_0cCrJr')rÚ HNSW_resetrLrrrr{¤rMz HNSW.resetcCrNr')rÚHNSW_clear_neighbor_tables©rr€ rrrÚclear_neighbor_tables§rSzHNSW.clear_neighbor_tablescCrNr')rÚHNSW_print_neighbor_statsr“ rrrÚprint_neighbor_statsªrSzHNSW.print_neighbor_statsFcCr‹r')rÚHNSW_prepare_level_tab)rrQÚ preset_levelsrrrÚprepare_level_tab­rzHNSW.prepare_level_tabcCr‡r'©rÚHNSW_shrink_neighbor_list©r‡ ÚinputÚoutputÚmax_sizerrrÚshrink_neighbor_list°rzHNSW.shrink_neighbor_list©rt r'rH )Crrr1rrrr rÚHNSW_assign_probas_getÚHNSW_assign_probas_setÚ assign_probasÚ HNSW_cum_nneighbor_per_level_getÚ HNSW_cum_nneighbor_per_level_setÚcum_nneighbor_per_levelÚHNSW_levels_getÚHNSW_levels_setÚlevelsÚHNSW_offsets_getÚHNSW_offsets_setÚoffsetsÚHNSW_neighbors_getÚHNSW_neighbors_setÚ neighborsÚHNSW_entry_point_getÚHNSW_entry_point_setÚ entry_pointÚ HNSW_rng_getÚ HNSW_rng_setÚrngÚHNSW_max_level_getÚHNSW_max_level_setÚ max_levelÚHNSW_efConstruction_getÚHNSW_efConstruction_setÚefConstructionÚHNSW_efSearch_getÚHNSW_efSearch_setr^ Ú HNSW_check_relative_distance_getÚ HNSW_check_relative_distance_setra ÚHNSW_upper_beam_getÚHNSW_upper_beam_setÚ upper_beamÚHNSW_search_bounded_queue_getÚHNSW_search_bounded_queue_setÚsearch_bounded_queuerf ri rm ro rs rHrx rz r‚ r… r¢r r{r” r– r™ r5r  Ú delete_HNSWrvrrrrrc OsF     rc cCr‡r'rš rœ rrrr› ¸r‰r› c@sŒeZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejejƒZeejejƒZeejejƒZddd„Zd d „Zd d „ZejZd S)Ú HNSWStatscCr5r'r6r7rrrr9¼r:zHNSWStats.cCr;r'r6r<rrrr9¼r>r?r@rc Cst |t |||||¡¡dSr')rÚHNSWStats_swiginitÚ new_HNSWStats)rrÐrÑÚn3r† ÚnreorderrrrrHÄr½zHNSWStats.__init__cCrJr')rÚHNSWStats_resetrLrrrr{ÇrMzHNSWStats.resetcCrNr')rÚHNSWStats_combinerŒrrrÚcombineÊrSzHNSWStats.combineN)rrrrr)rrr1rrrr rÚHNSWStats_n1_getÚHNSWStats_n1_setrÐÚHNSWStats_n2_getÚHNSWStats_n2_setrÑÚHNSWStats_n3_getÚHNSWStats_n3_setrË ÚHNSWStats_ndis_getÚHNSWStats_ndis_setr† ÚHNSWStats_nreorder_getÚHNSWStats_nreorder_setrÌ rHr{rÏ Údelete_HNSWStatsrvrrrrrÈ »s  rÈ c@süeZdZedd„dd„ddZeZeejƒZ eej ej ƒZ eej ejƒZeejejƒZeejejƒZeejejƒZeejejƒZeejejƒZeejej ƒZ!eej"ej#ƒZ$eej%ej&ƒZ'ddd „Z(d d „Z)d d „Z*dd„Z+dd„Z,dd„Z-dd„Z.ej/Z0dS)ÚReconstructFromNeighborscCr5r'r6r7rrrr9Òr:z!ReconstructFromNeighbors.cCr;r'r6r<rrrr9Òr>r?r@ércCr+r')rÚ!ReconstructFromNeighbors_swiginitÚnew_ReconstructFromNeighbors)rr€rÅÚnsqrrrrHàr/z!ReconstructFromNeighbors.__init__cCr‹)zq codes must be added in the correct order and the IndexHNSW must be populated and sorted )rÚ"ReconstructFromNeighbors_add_codesr“rrrÚ add_codesãrâz"ReconstructFromNeighbors.add_codescCrmr')rÚ*ReconstructFromNeighbors_compute_distances)rrQÚ shortlistÚqueryrÆrrrÚcompute_distancesêrrz*ReconstructFromNeighbors.compute_distancescCr‡)z called by add_codes)rÚ&ReconstructFromNeighbors_estimate_code)rr8r§r›rrrÚ estimate_codeírz&ReconstructFromNeighbors.estimate_codecCr‡)z called by compute_distances)rÚ$ReconstructFromNeighbors_reconstruct)rr§r8Útmprrrr´ñrz$ReconstructFromNeighbors.reconstructcCr‡r')rÚ&ReconstructFromNeighbors_reconstruct_n)rÚn0r¼r8rrrr½õr‰z&ReconstructFromNeighbors.reconstruct_ncCr‹)z> get the M+1 -by-d table for neighbor coordinates for vector i)rÚ+ReconstructFromNeighbors_get_neighbor_table)rr§ÚoutrrrÚget_neighbor_tableøróz+ReconstructFromNeighbors.get_neighbor_tableN)rÜ r)1rrr1rrrr rÚ"ReconstructFromNeighbors_index_getr€ÚReconstructFromNeighbors_M_getÚReconstructFromNeighbors_M_setrÚReconstructFromNeighbors_k_getÚReconstructFromNeighbors_k_setrÅÚ ReconstructFromNeighbors_nsq_getÚ ReconstructFromNeighbors_nsq_setrß Ú&ReconstructFromNeighbors_code_size_getÚ&ReconstructFromNeighbors_code_size_setrœÚ&ReconstructFromNeighbors_k_reorder_getÚ&ReconstructFromNeighbors_k_reorder_setÚ k_reorderÚ%ReconstructFromNeighbors_codebook_getÚ%ReconstructFromNeighbors_codebook_setÚcodebookÚ"ReconstructFromNeighbors_codes_getÚ"ReconstructFromNeighbors_codes_setrÚ#ReconstructFromNeighbors_ntotal_getÚ#ReconstructFromNeighbors_ntotal_setræÚReconstructFromNeighbors_d_getÚReconstructFromNeighbors_d_setr†Ú!ReconstructFromNeighbors_dsub_getÚ!ReconstructFromNeighbors_dsub_setrrHrá rå rç r´r½rî Údelete_ReconstructFromNeighborsrvrrrrrÛ Ñs,   rÛ c@sÌeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejƒZdd„ZejZd d „Zd d „Zd!dd„Zdd„Zdd„Zdd„Zd"dd„Zdd„Zdd„Z dd„Z!dd „Z"d S)#Ú IndexHNSWúe The HNSW index is a normal random-access index with a HNSW link structure built on top cCr5r'r6r7rrrr9r:zIndexHNSW.cCr;r'r6r<rrrr9r>r?r@cGr$r')rÚIndexHNSW_swiginitÚ new_IndexHNSWrprrrrH r.zIndexHNSW.__init__cCr‹r')rÚ IndexHNSW_addr“rrrr—rz IndexHNSW.addcCr‹©z Trains the storage if needed)rÚIndexHNSW_trainr“rrrr”rózIndexHNSW.trainNc CrÈ©z entry point for search)rÚIndexHNSW_searchr rrrr¢rÌzIndexHNSW.searchcCr‹r')rÚIndexHNSW_reconstructr±rrrr´rzIndexHNSW.reconstructcCrJr')rÚIndexHNSW_resetrLrrrr{rMzIndexHNSW.resetcCrNr')rÚ"IndexHNSW_shrink_level_0_neighbors©rr†rrrÚshrink_level_0_neighbors"rSz"IndexHNSW.shrink_level_0_neighborsrc CrJ)a Perform search only on level 0, given the starting points for each vertex. :type search_type: int, optional :param search_type: 1:perform one search per nprobe, 2: enqueue all entry points )rÚIndexHNSW_search_level_0) rrQr8rÅr~ rŽ rÆrÇrñ rÕrrrr %s zIndexHNSW.search_level_0cCr‡©z alternative graph building)rÚ$IndexHNSW_init_level_0_from_knngraph)rrÅr‰ rˆ rrrÚinit_level_0_from_knngraph0rz$IndexHNSW.init_level_0_from_knngraphcCr‡r )rÚ(IndexHNSW_init_level_0_from_entry_points)rÚnptÚpointsÚnearestsrrrÚinit_level_0_from_entry_points4rz(IndexHNSW.init_level_0_from_entry_pointscCrJr')rÚIndexHNSW_reorder_linksrLrrrÚ reorder_links8rMzIndexHNSW.reorder_linkscCrJr')rÚIndexHNSW_link_singletonsrLrrrÚlink_singletons;rMzIndexHNSW.link_singletonsr')rr)#rrr1r2rrrr rÚIndexHNSW_hnsw_getÚIndexHNSW_hnsw_setÚhnswÚIndexHNSW_own_fields_getÚIndexHNSW_own_fields_setr¹ÚIndexHNSW_storage_getÚIndexHNSW_storage_setÚstorageÚ(IndexHNSW_reconstruct_from_neighbors_getÚ(IndexHNSW_reconstruct_from_neighbors_setÚreconstruct_from_neighborsrHÚdelete_IndexHNSWrvr—r”r¢r´r{r r r r r r! rrrrr s*    r c@r­) Ú IndexHNSWFlatz_ Flat index topped with with a HNSW structure to access elements more efficiently. cCr5r'r6r7rrrr9Gr:zIndexHNSWFlat.cCr;r'r6r<rrrr9Gr>r?r@cGr$r')rÚIndexHNSWFlat_swiginitÚnew_IndexHNSWFlatrprrrrHJr.zIndexHNSWFlat.__init__N) rrr1r2rrrr rHrÚdelete_IndexHNSWFlatrvrrrrr. Aó  r. c@r“) Ú IndexHNSWPQz] PQ index topped with with a HNSW structure to access elements more efficiently. cCr5r'r6r7rrrr9Wr:zIndexHNSWPQ.cCr;r'r6r<rrrr9Wr>r?r@cGr$r')rÚIndexHNSWPQ_swiginitÚnew_IndexHNSWPQrprrrrHZr.zIndexHNSWPQ.__init__cCr‹r')rÚIndexHNSWPQ_trainr“rrrr”]rzIndexHNSWPQ.trainN) rrr1r2rrrr rHr”rÚdelete_IndexHNSWPQrvrrrrr3 Qó r3 c@r­) Ú IndexHNSWSQz] SQ index topped with with a HNSW structure to access elements more efficiently. cCr5r'r6r7rrrr9jr:zIndexHNSWSQ.cCr;r'r6r<rrrr9jr>r?r@cGr$r')rÚIndexHNSWSQ_swiginitÚnew_IndexHNSWSQrprrrrHmr.zIndexHNSWSQ.__init__N) rrr1r2rrrr rHrÚdelete_IndexHNSWSQrvrrrrr9 dr2 r9 c@sJeZdZdZedd„dd„ddZeZdd„Zd d „Z dd d „Z e j Z d S)ÚIndexHNSW2Levelz/ 2-level code structure with fast random accesscCr5r'r6r7rrrr9wr:zIndexHNSW2Level.cCr;r'r6r<rrrr9wr>r?r@cGr$r')rÚIndexHNSW2Level_swiginitÚnew_IndexHNSW2LevelrprrrrHzr.zIndexHNSW2Level.__init__cCrJr')rÚIndexHNSW2Level_flip_to_ivfrLrrrÚ flip_to_ivf}rMzIndexHNSW2Level.flip_to_ivfNc CrÈr )rÚIndexHNSW2Level_searchr rrrr¢€rÌzIndexHNSW2Level.searchr')rrr1r2rrrr rHrA r¢rÚdelete_IndexHNSW2Levelrvrrrrr= ts  r= cCr‡)ab SMAWK algorithm. Find the row minima of a monotone matrix. Expose this for testing. :type nrows: int :param nrows: number of rows :type ncols: int :param ncols: number of columns :type x: float :param x: input matrix, size (nrows, ncols) :type argmins: int :param argmins: argmin of each row )rÚsmawk)ÚnrowsÚncolsr8ÚargminsrrrrD ‰srD cCr‡)u} Exact 1D K-Means by dynamic programming From "Fast Exact k-Means, k-Medians and Bregman Divergence Clustering in 1D" Allan Grønlund, Kasper Green Larsen, Alexander Mathiasen, Jesper Sindahl Nielsen, Stefan Schneider, Mingzhou Song, ArXiV'17 Section 2.2 https://arxiv.org/abs/1701.07204 :type x: float :param x: input 1D array :type n: int :param n: input array length :type nclusters: int :param nclusters: number of clusters :type centroids: float :param centroids: output centroids, size nclusters :rtype: float :return: imbalancce factor )rÚkmeans1d)r8rQÚ nclustersrZrrrrH šsrH c@r•) ÚNeighborcCr5r'r6r7rrrr9³r:zNeighbor.cCr;r'r6r<rrrr9³r>r?r@cGr$r')rÚNeighbor_swiginitÚ new_NeighborrprrrrH¹r.zNeighbor.__init__cCrNr')rÚNeighbor___lt__rŒrrrÚ__lt__¼rSzNeighbor.__lt__N)rrr1rrrr rÚNeighbor_id_getÚNeighbor_id_setrÄÚNeighbor_distance_getÚNeighbor_distance_setrXÚNeighbor_flag_getÚNeighbor_flag_setÚflagrHrN Údelete_NeighborrvrrrrrJ ²r©rJ c@seZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejejƒZeejejƒZeejejƒZeejejƒZdd„Zdd „ZejZd S) ÚNhoodcCr5r'r6r7rrrr9Är:zNhood.cCr;r'r6r<rrrr9Är>r?r@cGr$r')rÚNhood_swiginitÚ new_NhoodrprrrrHÍr.zNhood.__init__cCr‹r')rÚ Nhood_insert)rrÄÚdistrrrÚinsertÐrz Nhood.insertN)rrr1rrrr rÚNhood_pool_getÚNhood_pool_setÚpoolÚ Nhood_M_getÚ Nhood_M_setrÚNhood_nn_old_getÚNhood_nn_old_setÚnn_oldÚNhood_nn_new_getÚNhood_nn_new_setÚnn_newÚNhood_rnn_old_getÚNhood_rnn_old_setÚrnn_oldÚNhood_rnn_new_getÚNhood_rnn_new_setÚrnn_newrHr\ Ú delete_NhoodrvrrrrrW Ãs rW c@s$eZdZedd„dd„ddZeZdd„Zej Z dd „Z d d „Z d d „Z dd„Zdd„Zdd„Zdd„Zdd„Zdd„ZeejejƒZeejejƒZeejejƒZeejejƒZeej ej!ƒZ"eej#ej$ƒZ%eej&ej'ƒZ(eej)ej*ƒZ+eej,ej-ƒZ.eej/ej0ƒZ1eej2ej3ƒZ4eej5ej6ƒZ7dS)Ú NNDescentcCr5r'r6r7rrrr9Ør:zNNDescent.cCr;r'r6r<rrrr9Ør>r?r@cCr—r')rÚNNDescent_swiginitÚ new_NNDescent)rr†r?rrrrHÛrzNNDescent.__init__cCr‡r')rÚNNDescent_build)rr‡ rQrrrrÚbuildßr‰zNNDescent.buildcCrŽr')rÚNNDescent_search)rr‡ ÚtopkÚindicesÚdistsràrrrr¢âr|zNNDescent.searchcCrJr')rÚNNDescent_resetrLrrrr{årMzNNDescent.resetcCrN)z" Initialize the KNN graph randomly)rÚNNDescent_init_graph©rr‡ rrrÚ init_graphèr zNNDescent.init_graphcCr‹)z Perform NNDescent algorithm)rÚNNDescent_nndescent)rr‡ rrrrÚ nndescentìrózNNDescent.nndescentcCrN)z Perform local join on each node)rÚNNDescent_joinrz rrrÚjoinðr zNNDescent.joincCrJ)z> Sample new neighbors for each node to peform local join later)rÚNNDescent_updaterLrrrÚupdateôr`zNNDescent.updatecCrm)zF Sample a small number of points to evaluate the quality of KNNG built)rÚNNDescent_generate_eval_set)rr‡ rér=ÚNrrrÚgenerate_eval_setøruzNNDescent.generate_eval_setcCr‹)z# Evaluate the quality of KNNG built)rÚNNDescent_eval_recall)rÚ ctrl_pointsÚ acc_eval_setrrrÚ eval_recallürózNNDescent.eval_recallN)8rrr1rrrr rHrÚdelete_NNDescentrvrs r¢r{r{ r} r r r„ rˆ ÚNNDescent_has_built_getÚNNDescent_has_built_setÚ has_builtÚNNDescent_S_getÚNNDescent_S_setÚSÚNNDescent_R_getÚNNDescent_R_setÚRÚNNDescent_iter_getÚNNDescent_iter_setÚiterÚNNDescent_search_L_getÚNNDescent_search_L_setÚsearch_LÚNNDescent_random_seed_getÚNNDescent_random_seed_setrWÚNNDescent_K_getÚNNDescent_K_setr?ÚNNDescent_d_getÚNNDescent_d_setr†ÚNNDescent_L_getÚNNDescent_L_setÚLÚNNDescent_ntotal_getÚNNDescent_ntotal_setræÚNNDescent_graph_getÚNNDescent_graph_setÚgraphÚNNDescent_final_graph_getÚNNDescent_final_graph_setÚ final_graphrrrrro ×s4ro c@seZdZdZedd„dd„ddZeZeej ej ddZ eej ej ƒZeejejƒZdd „ZejZd d „Zd d „Zddd„Zdd„Zdd„ZdS)ÚIndexNNDescentzp The NNDescent index is a normal random-access index with an NNDescent link structure built on top cCr5r'r6r7rrrr9r:zIndexNNDescent.cCr;r'r6r<rrrr9r>r?r@z Faiss results are 64-bitcGr$r')rÚIndexNNDescent_swiginitÚnew_IndexNNDescentrprrrrHr.zIndexNNDescent.__init__cCr‹r')rÚIndexNNDescent_addr“rrrr—rzIndexNNDescent.addcCr‹r )rÚIndexNNDescent_trainr“rrrr”"rózIndexNNDescent.trainNc CrÈr )rÚIndexNNDescent_searchr rrrr¢&rÌzIndexNNDescent.searchcCr‹r')rÚIndexNNDescent_reconstructr±rrrr´*rzIndexNNDescent.reconstructcCrJr')rÚIndexNNDescent_resetrLrrrr{-rMzIndexNNDescent.resetr')rrr1r2rrrr rÚIndexNNDescent_nndescent_getÚIndexNNDescent_nndescent_setr} ÚIndexNNDescent_own_fields_getÚIndexNNDescent_own_fields_setr¹ÚIndexNNDescent_storage_getÚIndexNNDescent_storage_setr) rHÚdelete_IndexNNDescentrvr—r”r¢r´r{rrrrrª s  rª c@r­) ÚIndexNNDescentFlatzd Flat index topped with with a NNDescent structure to access elements more efficiently. cCr5r'r6r7rrrr99r:zIndexNNDescentFlat.cCr;r'r6r<rrrr99r>r?r@cGr$r')rÚIndexNNDescentFlat_swiginitÚnew_IndexNNDescentFlatrprrrrH<r.zIndexNNDescentFlat.__init__N) rrr1r2rrrr rHrÚdelete_IndexNNDescentFlatrvrrrrr¹ 3r2 r¹ c@sbeZdZdZedd„dd„ddZeZdd„Zdd d „Z d d „Z dd„Z dd„Z dd„Z ejZdS)Ú IndexIVFFlatzÌ Inverted file with stored vectors. Here the inverted file pre-selects the vectors to be searched, but they are not otherwise encoded, the code array just contains the raw float entries. cCr5r'r6r7rrrr9Jr:zIndexIVFFlat.cCr;r'r6r<rrrr9Jr>r?r@cCrmr')rÚIndexIVFFlat_add_corer rrrr MrrzIndexIVFFlat.add_coreFcCrŽr')rÚIndexIVFFlat_encode_vectorsr rrrr Pr|zIndexIVFFlat.encode_vectorscCr‹r')rÚ$IndexIVFFlat_get_InvertedListScannerr" rrrr# Srz$IndexIVFFlat.get_InvertedListScannercCr‡r')rÚ$IndexIVFFlat_reconstruct_from_offsetr/ rrrr0 Vr‰z$IndexIVFFlat.reconstruct_from_offsetcCr‡r')rÚIndexIVFFlat_sa_decoderÓrrrrÔYr‰zIndexIVFFlat.sa_decodecGr$r')rÚIndexIVFFlat_swiginitÚnew_IndexIVFFlatrprrrrH\r.zIndexIVFFlat.__init__NrH )rrr1r2rrrr r r r# r0 rÔrHrÚdelete_IndexIVFFlatrvrrrrr½ Cs  r½ c@s‚eZdZedd„dd„ddZeZeejej ddZ dd„Z d d „Z dd d „Z dd„Zddd„Zdd„Zdd„Zdd„ZejZd S)ÚIndexIVFFlatDedupcCr5r'r6r7rrrr9dr:zIndexIVFFlatDedup.cCr;r'r6r<rrrr9dr>r?r@z˜ Maps ids stored in the index to the ids of vectors that are the same. When a vector is unique, it does not appear in the instances map cCr‹)z also dedups the training set)rÚIndexIVFFlatDedup_trainr“rrrr”lrózIndexIVFFlatDedup.traincCr‡)z& implemented for all IndexIVF* classes)rÚIndexIVFFlatDedup_add_with_idsr›rrrrprzIndexIVFFlatDedup.add_with_idsNc Cr»r')rÚ$IndexIVFFlatDedup_search_preassignedrû rrrrÿ tr½z$IndexIVFFlatDedup.search_preassignedcCrNr')rÚIndexIVFFlatDedup_remove_idsr­rrrr®wrSzIndexIVFFlatDedup.remove_idscCrŽr )rÚIndexIVFFlatDedup_range_searchr¥rrrr¦zr”zIndexIVFFlatDedup.range_searchcCr‡r )rÚ IndexIVFFlatDedup_update_vectorsr& rrrr( ~rz IndexIVFFlatDedup.update_vectorscCr‡r )rÚ)IndexIVFFlatDedup_reconstruct_from_offsetr/ rrrr0 ‚rz)IndexIVFFlatDedup.reconstruct_from_offsetcGr$r')rÚIndexIVFFlatDedup_swiginitÚnew_IndexIVFFlatDeduprprrrrH†r.zIndexIVFFlatDedup.__init__rør')rrr1rrrr rÚIndexIVFFlatDedup_instances_getÚIndexIVFFlatDedup_instances_setÚ instancesr”rrÿ r®r¦r( r0 rHÚdelete_IndexIVFFlatDeduprvrrrrrÆ cs   rÆ cCrJr')rÚstorage_distance_computer)r) rrrrÔ ŽrMrÔ c@s0eZdZedd„dd„ddZeZeejej ddZ eej ej ddZ eejejddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZeej ej!ddZ"d)dd„Z#dd„Z$dd„Z%dd„Z&dd„Z'dd„Z(dd„Z)dd„Z*d d!„Z+d"d#„Z,d$d%„Z-d&d'„Z.ej/Z0d(S)*ÚNSGcCr5r'r6r7rrrr9‘r:z NSG.cCr;r'r6r<rrrr9‘r>r?r@z nb of nodesz nb of neighbors per nodez/ length of the search path at construction timez) candidate pool size at construction timez length of the search pathz enterpointz NSG graph structurez NSG is built or notz random generatorrt cCrhr')rÚ NSG_swiginitÚnew_NSG)rr’ rrrrHr.z NSG.__init__cCrmr')rÚ NSG_build)rr) rQÚ knn_graphrrrrrs  rrz NSG.buildcCrJr')rÚ NSG_resetrLrrrr{£rMz NSG.resetcCrŽr')rÚ NSG_search)rrºrÅrˆ r‰ ràrrrr¢¦r|z NSG.searchcCr‹r')rÚNSG_init_graph)rr) rÙ rrrr{ ©rzNSG.init_graphcCrmr')rÚNSG_add_reverse_links)rÚqr rºr¦ rrrÚadd_reverse_links¬rrzNSG.add_reverse_linksc CrÈr')rÚNSG_sync_prune)rrÞ r_ rºràrÙ r¦ rrrÚ sync_prune¯r.zNSG.sync_prunecCrmr')rÚNSG_link)rr) rÙ r¦ rrrrÚlink²rrzNSG.linkcCr‹r')rÚ NSG_tree_grow)rr) ÚdegreesrrrÚ tree_growµrz NSG.tree_growcCr‡r')rÚNSG_dfs)rràÚrootÚcntrrrÚdfs¸r‰zNSG.dfscCrmr')rÚNSG_attach_unlinked)rr) ràÚvt2rå rrrÚattach_unlinked»rrzNSG.attach_unlinkedcCrJr')rÚNSG_check_graphrLrrrÚ check_graph¾rMzNSG.check_graphNr¡ )1rrr1rrrr rÚNSG_ntotal_getÚNSG_ntotal_setræÚ NSG_R_getÚ NSG_R_setr’ Ú NSG_L_getÚ NSG_L_setr¡ Ú NSG_C_getÚ NSG_C_setÚCÚNSG_search_L_getÚNSG_search_L_setr˜ ÚNSG_enterpoint_getÚNSG_enterpoint_setÚ enterpointÚNSG_final_graph_getÚNSG_final_graph_setr© ÚNSG_is_built_getÚNSG_is_built_setÚis_builtÚ NSG_rng_getÚ NSG_rng_setr¶ rHrs r{r¢r{ rß rá rã ræ rê rí rï Ú delete_NSGrvrrrrrÕ s2  rÕ c@seZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejƒZeejejd dZeejejd dZeejejd dZeejejd dZeejejƒZ eej!ej"ƒZ#eej$ej%ƒZ&d d„Z'ej(Z)dd„Z*dd„Z+dd„Z,ddd„Z-dd„Z.dd„Z/dd„Z0dS)ÚIndexNSGzc The NSG index is a normal random-access index with a NSG link structure built on top cCr5r'r6r7rrrr9Ër:zIndexNSG.cCr;r'r6r<rrrr9Ër>r?r@z the link strcuturez the sequential storagez the index is built or notz K of KNN graph for buildingzx indicate how to build a knn graph - 0: build NSG with brute force search - 1: build NSG with NNDescent z parameters for nndescentcGr$r')rÚIndexNSG_swiginitÚ new_IndexNSGrprrrrHÜr.zIndexNSG.__init__cCrmr')rÚIndexNSG_build)rrQr8rÙ ÚGKrrrrs àrrzIndexNSG.buildcCr‹r')rÚ IndexNSG_addr“rrrr—ãrz IndexNSG.addcCr‹r )rÚIndexNSG_trainr“rrrr”ærózIndexNSG.trainNc CrÈr )rÚIndexNSG_searchr rrrr¢êrÌzIndexNSG.searchcCr‹r')rÚIndexNSG_reconstructr±rrrr´îrzIndexNSG.reconstructcCrJr')rÚIndexNSG_resetrLrrrr{ñrMzIndexNSG.resetcCr‡r')rÚIndexNSG_check_knn_graph)rrÙ rQr?rrrÚcheck_knn_graphôr‰zIndexNSG.check_knn_graphr')1rrr1r2rrrr rÚIndexNSG_nsg_getÚIndexNSG_nsg_setÚnsgÚIndexNSG_own_fields_getÚIndexNSG_own_fields_setr¹ÚIndexNSG_storage_getÚIndexNSG_storage_setr) ÚIndexNSG_is_built_getÚIndexNSG_is_built_setr ÚIndexNSG_GK_getÚIndexNSG_GK_setr ÚIndexNSG_build_type_getÚIndexNSG_build_type_setÚ build_typeÚIndexNSG_nndescent_S_getÚIndexNSG_nndescent_S_setÚ nndescent_SÚIndexNSG_nndescent_R_getÚIndexNSG_nndescent_R_setÚ nndescent_RÚIndexNSG_nndescent_L_getÚIndexNSG_nndescent_L_setÚ nndescent_LÚIndexNSG_nndescent_iter_getÚIndexNSG_nndescent_iter_setÚnndescent_iterrHÚdelete_IndexNSGrvrs r—r”r¢r´r{r rrrrr Ås.  r c@r­) Ú IndexNSGFlatz^ Flat index topped with with a NSG structure to access elements more efficiently. cCr5r'r6r7rrrr9r:zIndexNSGFlat.cCr;r'r6r<rrrr9r>r?r@cGr$r')rÚIndexNSGFlat_swiginitÚnew_IndexNSGFlatrprrrrHr.zIndexNSGFlat.__init__N) rrr1r2rrrr rHrÚdelete_IndexNSGFlatrvrrrrr- úr2 r- c@r“) Ú IndexNSGPQz\ PQ index topped with with a NSG structure to access elements more efficiently. cCr5r'r6r7rrrr9r:zIndexNSGPQ.cCr;r'r6r<rrrr9r>r?r@cGr$r')rÚIndexNSGPQ_swiginitÚnew_IndexNSGPQrprrrrHr.zIndexNSGPQ.__init__cCr‹r')rÚIndexNSGPQ_trainr“rrrr”rzIndexNSGPQ.trainN) rrr1r2rrrr rHr”rÚdelete_IndexNSGPQrvrrrrr1 r8 r1 c@r­) Ú IndexNSGSQz\ SQ index topped with with a NSG structure to access elements more efficiently. cCr5r'r6r7rrrr9#r:zIndexNSGSQ.cCr;r'r6r<rrrr9#r>r?r@cGr$r')rÚIndexNSGSQ_swiginitÚnew_IndexNSGSQrprrrrH&r.zIndexNSGSQ.__init__N) rrr1r2rrrr rHrÚdelete_IndexNSGSQrvrrrrr6 r2 r6 c@s^eZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejejƒZdd„ZejZdS) Ú OnDiskOneListcCr5r'r6r7rrrr9.r:zOnDiskOneList.cCr;r'r6r<rrrr9.r>r?r@cCryr')rÚOnDiskOneList_swiginitÚnew_OnDiskOneListrLrrrrH4r|zOnDiskOneList.__init__N)rrr1rrrr rÚOnDiskOneList_size_getÚOnDiskOneList_size_setr†ÚOnDiskOneList_capacity_getÚOnDiskOneList_capacity_setÚcapacityÚOnDiskOneList_offset_getÚOnDiskOneList_offset_setr.rHÚdelete_OnDiskOneListrvrrrrr: -s r: c@s:eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejƒZeejejƒZeejejƒZdd„Zd d „Zd d „Zd d„Zdd„Zdd„Z d+dd„Z!d+dd„Z"dd„Z#dd„Z$ej%Z&eej'ej(ƒZ)eej*ej+ƒZ,eej-ej.ƒZ/dd„Z0dd„Z1d d!„Z2d"d#„Z3d$d%„Z4d&d'„Z5d(d)„Z6d*S),ÚOnDiskInvertedListsa. On-disk storage of inverted lists. The data is stored in a mmapped chunk of memory (base pointer ptr, size totsize). Each list is a range of memory that contains (object List) that contains: - uint8_t codes[capacity * code_size] - followed by idx_t ids[capacity] in each of the arrays, the size <= capacity first elements are used, the rest is not initialized. Addition and resize are supported by: - roundind up the capacity of the lists to a power of two - maintaining a list of empty slots, sorted by size. - resizing the mmapped block is adjusted as needed. An OnDiskInvertedLists is compact if the size == capacity for all lists and there are no available slots. Addition to the invlists is slow. For incremental add it is better to use a default ArrayInvertedLists object and convert it to an OnDisk with merge_from. When it is known that a set of lists will be accessed, it is useful to call prefetch_lists, that launches a set of threads to read the lists in parallel. cCr5r'r6r7rrrr9Zr:zOnDiskInvertedLists.cCr;r'r6r<rrrr9Zr>r?r@cCrNr')rÚOnDiskInvertedLists_list_sizer¡rrrr¥crSzOnDiskInvertedLists.list_sizecCrNr')rÚOnDiskInvertedLists_get_codesr¡rrrr©frSzOnDiskInvertedLists.get_codescCrNr')rÚOnDiskInvertedLists_get_idsr¡rrrr«irSzOnDiskInvertedLists.get_idscCrmr')rÚOnDiskInvertedLists_add_entriesrÀrrrrÂlrrzOnDiskInvertedLists.add_entriescCrŽr')rÚ"OnDiskInvertedLists_update_entriesrÇrrrrÈor|z"OnDiskInvertedLists.update_entriescCr‹r')rÚOnDiskInvertedLists_resizerÊrrrrŠrrzOnDiskInvertedLists.resizeFcCr‡r')rÚOnDiskInvertedLists_merge_from)rr Ún_ilrrrrrÚur‰zOnDiskInvertedLists.merge_fromcCr‹)z( same as merge_from for a single invlist)rÚ OnDiskInvertedLists_merge_from_1)rr rrrrÚ merge_from_1xróz OnDiskInvertedLists.merge_from_1cCr‹)zI restrict the inverted lists to l0:l1 without touching the mmapped region)rÚ!OnDiskInvertedLists_crop_invlists)rÚl0Úl1rrrÚ crop_invlists|róz!OnDiskInvertedLists.crop_invlistscCr‹r')rÚ"OnDiskInvertedLists_prefetch_listsr¸rrrr»€rz"OnDiskInvertedLists.prefetch_listscCrJr')rÚOnDiskInvertedLists_do_mmaprLrrrÚdo_mmap‡rMzOnDiskInvertedLists.do_mmapcCrNr')rÚ"OnDiskInvertedLists_update_totsize)rÚ new_totsizerrrÚupdate_totsizeŠrSz"OnDiskInvertedLists.update_totsizecCr‹r')rÚ!OnDiskInvertedLists_resize_lockedrÊrrrÚ resize_lockedrz!OnDiskInvertedLists.resize_lockedcCrNr')rÚ!OnDiskInvertedLists_allocate_slot)rrA rrrÚ allocate_slotrSz!OnDiskInvertedLists.allocate_slotcCr‹r')rÚOnDiskInvertedLists_free_slot)rr.rA rrrÚ free_slot“rzOnDiskInvertedLists.free_slotcCrN)z2 override all list sizes and make a packed storage)rÚ'OnDiskInvertedLists_set_all_lists_sizes)rra rrrÚset_all_lists_sizes–r z'OnDiskInvertedLists.set_all_lists_sizescGr$r')rÚOnDiskInvertedLists_swiginitÚnew_OnDiskInvertedListsrprrrrHšr.zOnDiskInvertedLists.__init__NrH )7rrr1r2rrrr rÚOnDiskInvertedLists_lists_getÚOnDiskInvertedLists_lists_setÚlistsÚOnDiskInvertedLists_slots_getÚOnDiskInvertedLists_slots_setÚslotsÚ OnDiskInvertedLists_filename_getÚ OnDiskInvertedLists_filename_setÚfilenameÚOnDiskInvertedLists_totsize_getÚOnDiskInvertedLists_totsize_setÚtotsizeÚOnDiskInvertedLists_ptr_getÚOnDiskInvertedLists_ptr_setr0Ú!OnDiskInvertedLists_read_only_getÚ!OnDiskInvertedLists_read_only_setÚ read_onlyr¥r©r«rÂrÈrŠrÚrO rS r»Údelete_OnDiskInvertedListsrvÚOnDiskInvertedLists_locks_getÚOnDiskInvertedLists_locks_setr ÚOnDiskInvertedLists_pf_getÚOnDiskInvertedLists_pf_setÚpfÚ(OnDiskInvertedLists_prefetch_nthread_getÚ(OnDiskInvertedLists_prefetch_nthread_setÚprefetch_nthreadrV rY r[ r] r_ ra rHrrrrrE ;s>   rE c@s„eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejddZdd „Zd d „Zd d „ZejZdS)ÚZnSphereSearcha  returns the nearest vertex in the sphere to a query. Returns only the coordinates, not an id. Algorithm: all points are derived from a one atom vector up to a permutation and sign changes. The search function finds the most appropriate atom and transformation. cCr5r'r6r7rrrr9ªr:zZnSphereSearch.cCr;r'r6r<rrrr9ªr>r?r@z size dim * ntatomcCr—r')rÚZnSphereSearch_swiginitÚnew_ZnSphereSearch©rr§Úr2rrrrH±rzZnSphereSearch.__init__cGrn)a *Overload 1:* find nearest centroid. x does not need to be normalized | *Overload 2:* full call. Requires externally-allocated temp space | *Overload 3:* full call. Requires externally-allocated temp space )rÚZnSphereSearch_searchrprrrr¢´szZnSphereSearch.searchcCrmr')rÚZnSphereSearch_search_multi)rrQr8Úc_outÚdp_outrrrÚ search_multiÅrrzZnSphereSearch.search_multiN)rrr1r2rrrr rÚZnSphereSearch_dimS_getÚZnSphereSearch_dimS_setÚdimSÚZnSphereSearch_r2_getÚZnSphereSearch_r2_setr‚ ÚZnSphereSearch_natom_getÚZnSphereSearch_natom_setÚnatomÚZnSphereSearch_voc_getÚZnSphereSearch_voc_setÚvocrHr¢r‡ Údelete_ZnSphereSearchrvrrrrr~  s  r~ c@s|eZdZedd„dd„ddZdd„ZeZeej ej ddZ eej ej ƒZd d „Zd d „Zd d„Zdd„Zdd„ZejZdS)ÚEnumeratedVectorscCr5r'r6r7rrrr9Ír:zEnumeratedVectors.cCr;r'r6r<rrrr9Ír>r?r@cOrBrCrDrErrrrHÏrIzEnumeratedVectors.__init__z size of the collectioncCrN)z" encode a vector from a collection)rÚEnumeratedVectors_encoderWrrrr1Õr zEnumeratedVectors.encodecCr‹)z decode it)rÚEnumeratedVectors_decode©rr›rérrrrÈÙrózEnumeratedVectors.decodecCr‡r')rÚEnumeratedVectors_encode_multi)rÚncrérrrrÚ encode_multiÝr‰zEnumeratedVectors.encode_multicCr‡r')rÚEnumeratedVectors_decode_multi)rr™ rrérrrÚ decode_multiàr‰zEnumeratedVectors.decode_multic CrÈr')rÚEnumeratedVectors_find_nn)rrQrr#r$rÕrºrrrÚfind_nnãr.zEnumeratedVectors.find_nnN)rrr1rrrHrr rÚEnumeratedVectors_nv_getÚEnumeratedVectors_nv_setr' ÚEnumeratedVectors_dim_getÚEnumeratedVectors_dim_setr§r1rÈrš rœ rž Údelete_EnumeratedVectorsrvrrrrr” Ìs r” c@sPeZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ dd„ZejZdS) ÚRepeatcCr5r'r6r7rrrr9ër:zRepeat.cCr;r'r6r<rrrr9ër>r?r@cCryr')rÚRepeat_swiginitÚ new_RepeatrLrrrrHðr|zRepeat.__init__N)rrr1rrrr rÚRepeat_val_getÚRepeat_val_setÚvalÚ Repeat_n_getÚ Repeat_n_setrQrHÚ delete_Repeatrvrrrrr¤ ês r¤ c@sneZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZdd d „Zd d „Zd d„Zdd„ZejZdS)ÚRepeatsz” Repeats: used to encode a vector that has n occurrences of val. Encodes the signs and permutation of the vector. Useful for atoms. cCr5r'r6r7rrrr9þr:zRepeats.cCr;r'r6r<rrrr9þr>r?r@rNcCr—r')rÚRepeats_swiginitÚ new_Repeats)rr§rérrrrHrzRepeats.__init__cCrJr')rÚ Repeats_countrLrrrÚcountrMz Repeats.countcCrNr')rÚRepeats_encodersrrrr1 rSzRepeats.encodecCr‹r')rÚRepeats_decoder— rrrrÈ rzRepeats.decode)rN)rrr1r2rrrr rÚRepeats_dim_getÚRepeats_dim_setr§ÚRepeats_repeats_getÚRepeats_repeats_setÚrepeatsrHr± r1rÈÚdelete_Repeatsrvrrrrr­ ÷s  r­ c@szeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZdd„Zd d „Zd d „Zd d„ZejZdS)Ú ZnSphereCodeczØ codec that can return ids for the encoded vectors uses the ZnSphereSearch to encode the vector by encoding the permutation and signs. Depends on ZnSphereSearch because it uses the atom numbers cCr5r'r6r7rrrr9r:zZnSphereCodec.cCr;r'r6r<rrrr9r>r?r@cCr—r')rÚZnSphereCodec_swiginitÚnew_ZnSphereCodecr rrrrH"rzZnSphereCodec.__init__cCrNr')rÚZnSphereCodec_search_and_encoderWrrrÚsearch_and_encode%rSzZnSphereCodec.search_and_encodecCr‹r')rÚZnSphereCodec_decoder— rrrrÈ(rzZnSphereCodec.decodecCrN)z/ takes vectors that do not need to be centroids)rÚZnSphereCodec_encoderWrrrr1+r zZnSphereCodec.encodeN)rrr1r2rrrr rÚZnSphereCodec_code_segments_getÚZnSphereCodec_code_segments_setÚ code_segmentsÚZnSphereCodec_nv_getÚZnSphereCodec_nv_setr' ÚZnSphereCodec_code_size_getÚZnSphereCodec_code_size_setrœrHr¾ rÈr1Údelete_ZnSphereCodecrvrrrrrº s rº c@sÊeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZdd„Zd d „Zd d „Zd d„ZeejejƒZeejejƒZeejejƒZeejej ƒZ!dd„Z"dd„Z#dd„Z$ej%Z&dS)ÚZnSphereCodecReczÎ recursive sphere codec Uses a recursive decomposition on the dimensions to encode centroids found by the ZnSphereSearch. The codes are *not* compatible with the ones of ZnSpehreCodec cCr5r'r6r7rrrr9<r:zZnSphereCodecRec.cCr;r'r6r<rrrr9<r>r?r@cCr—r')rÚZnSphereCodecRec_swiginitÚnew_ZnSphereCodecRecr rrrrHBrzZnSphereCodecRec.__init__cCrNr')rÚ ZnSphereCodecRec_encode_centroidrsrrrÚencode_centroidErSz ZnSphereCodecRec.encode_centroidcCr‹r')rÚZnSphereCodecRec_decoder— rrrrÈHrzZnSphereCodecRec.decodecCrN)z[ vectors need to be centroids (does not work on arbitrary vectors) )rÚZnSphereCodecRec_encoderWrrrr1Kr¯zZnSphereCodecRec.encodecCr‹r')rÚZnSphereCodecRec_get_nv)rÚldÚr2arrrÚget_nvVrzZnSphereCodecRec.get_nvcCr‡r')rÚZnSphereCodecRec_get_nv_cum)rrÑ Úr2trÒ rrrÚ get_nv_cumYr‰zZnSphereCodecRec.get_nv_cumcCrmr')rÚZnSphereCodecRec_set_nv_cum)rrÑ rÕ rÒ r=rrrÚ set_nv_cum\rrzZnSphereCodecRec.set_nv_cumN)'rrr1r2rrrr rÚZnSphereCodecRec_r2_getÚZnSphereCodecRec_r2_setr‚ ÚZnSphereCodecRec_log2_dim_getÚZnSphereCodecRec_log2_dim_setÚlog2_dimÚZnSphereCodecRec_code_size_getÚZnSphereCodecRec_code_size_setrœrHrÍ rÈr1ÚZnSphereCodecRec_all_nv_getÚZnSphereCodecRec_all_nv_setÚall_nvÚZnSphereCodecRec_all_nv_cum_getÚZnSphereCodecRec_all_nv_cum_setÚ all_nv_cumÚ$ZnSphereCodecRec_decode_cache_ld_getÚ$ZnSphereCodecRec_decode_cache_ld_setÚdecode_cache_ldÚ!ZnSphereCodecRec_decode_cache_getÚ!ZnSphereCodecRec_decode_cache_setÚ decode_cacherÓ rÖ rØ Údelete_ZnSphereCodecRecrvrrrrrÉ 3s& rÉ c@sdeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZdd„Zd d „Zd d „ZejZd S)ÚZnSphereCodecAltzg Codec that uses the recursive codec if dim is a power of 2 and the regular one otherwise cCr5r'r6r7rrrr9ir:zZnSphereCodecAlt.cCr;r'r6r<rrrr9ir>r?r@cCr—r')rÚZnSphereCodecAlt_swiginitÚnew_ZnSphereCodecAltr rrrrHnrzZnSphereCodecAlt.__init__cCrNr')rÚZnSphereCodecAlt_encoderWrrrr1qrSzZnSphereCodecAlt.encodecCr‹r')rÚZnSphereCodecAlt_decoder— rrrrÈtrzZnSphereCodecAlt.decodeN)rrr1r2rrrr rÚZnSphereCodecAlt_use_rec_getÚZnSphereCodecAlt_use_rec_setÚuse_recÚZnSphereCodecAlt_znc_rec_getÚZnSphereCodecAlt_znc_rec_setÚznc_recrHr1rÈÚdelete_ZnSphereCodecAltrvrrrrrí cs rí c@sìeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejƒZeejejd dZeejejd dZd d„Zdd„Zdd„Z dd„Z!dd„Z"dd„Z#ddd„Z$dd„Z%ej&Z'dS)Ú IndexLatticezC Index that encodes a vector with a series of Zn lattice quantizerscCr5r'r6r7rrrr9~r:zIndexLattice.cCr;r'r6r<rrrr9~r>r?r@z number of sub-vectorsz dimension of sub-vectorsz the lattice quantizerz0 nb bits used to encode the scale, per subvectorz total, in bytesz5 mins and maxes of the vector norms, per subquantizerc Crr')rÚIndexLattice_swiginitÚnew_IndexLattice)rr†rß Ú scale_nbitr‚ rrrrHˆrzIndexLattice.__init__cCr‹r')rÚIndexLattice_trainr“rrrr”‹rzIndexLattice.traincCrJr')rÚIndexLattice_sa_code_sizerLrrrrÍŽrMzIndexLattice.sa_code_sizecCr‡r')rÚIndexLattice_sa_encoderÏrrrrБr‰zIndexLattice.sa_encodecCr‡r')rÚIndexLattice_sa_decoderÓrrrrÔ”r‰zIndexLattice.sa_decodecCr‹r )rÚIndexLattice_addr“rrrr——rózIndexLattice.addNc CrÈr')rÚIndexLattice_searchr rrrr¢›r.zIndexLattice.searchcCrJr')rÚIndexLattice_resetrLrrrr{žrMzIndexLattice.resetr')(rrr1r2rrrr rÚIndexLattice_nsq_getÚIndexLattice_nsq_setrß ÚIndexLattice_dsq_getÚIndexLattice_dsq_setÚdsqÚ IndexLattice_zn_sphere_codec_getÚ IndexLattice_zn_sphere_codec_setÚzn_sphere_codecÚIndexLattice_scale_nbit_getÚIndexLattice_scale_nbit_setrü ÚIndexLattice_lattice_nbit_getÚIndexLattice_lattice_nbit_setÚ lattice_nbitÚIndexLattice_code_size_getÚIndexLattice_code_size_setrœÚIndexLattice_trained_getÚIndexLattice_trained_setrò rHr”rÍrÐrÔr—r¢r{Údelete_IndexLatticervrrrrrù {s(  rù c@s\eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZd d „ZejZd S) ÚIVFPQSearchParametersrôcCr5r'r6r7rrrr9­r:zIVFPQSearchParameters.cCr;r'r6r<rrrr9­r>r?r@ú% use table computation or on-the-fly?ú( Hamming thresh for polysemous filteringcCryr')rÚIVFPQSearchParameters_swiginitÚnew_IVFPQSearchParametersrLrrrrH²r|zIVFPQSearchParameters.__init__N)rrr1r2rrrr rÚ.IVFPQSearchParameters_scan_table_threshold_getÚ.IVFPQSearchParameters_scan_table_threshold_setÚscan_table_thresholdÚ'IVFPQSearchParameters_polysemous_ht_getÚ'IVFPQSearchParameters_polysemous_ht_setr‚rHÚdelete_IVFPQSearchParametersrvrrrrr¥s rc@s6eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZeejejddZ d-dd„Z!dd„Z"dd„Z#d.dd„Z$dd„Z%dd„Z&dd„Z'dd „Z(d!d"„Z)d-d#d$„Z*d%d&„Z+d'd(„Z,d)d*„Z-d+d,„Z.ej/Z0dS)/Ú IndexIVFPQzz Inverted file with Product Quantizer encoding. Each residual vector is encoded as a product quantizer code. cCr5r'r6r7rrrr9¿r:zIndexIVFPQ.cCr;r'r6r<rrrr9¿r>r?r@z! Encode residual or plain vector?ú produces the codesz% reorder PQ centroids after training?z if NULL, use defaultrrz€ Precompute table that speed up query preprocessing at some memory cost (used only for by_residual with L2 metric) zA if use_precompute_table size nlist * pq.M * pq.ksub FcCrŽr')rÚIndexIVFPQ_encode_vectorsr rrrr Ðr|zIndexIVFPQ.encode_vectorscCr‡r')rÚIndexIVFPQ_sa_decoderÓrrrrÔÓr‰zIndexIVFPQ.sa_decodecCrmr')rÚIndexIVFPQ_add_corer rrrr ÖrrzIndexIVFPQ.add_coreNcCrŽ)z‘ same as add_core, also: - output 2nd level residuals if residuals_2 != NULL - accepts precomputed_idx = nullptr )rÚIndexIVFPQ_add_core_o)rrQr8rœÚ residuals_2r rrrÚ add_core_oÙszIndexIVFPQ.add_core_ocCr‹)z trains the product quantizer)rÚIndexIVFPQ_train_residualr“rrrr árózIndexIVFPQ.train_residualcCr‡)z8 same as train_residual, also output 2nd level residuals)rÚIndexIVFPQ_train_residual_o)rrQr8r'rrrÚtrain_residual_oårzIndexIVFPQ.train_residual_ocCr‡r')rÚ"IndexIVFPQ_reconstruct_from_offsetr/ rrrr0 ér‰z"IndexIVFPQ.reconstruct_from_offsetcCr‹)aò Find exact duplicates in the dataset. the duplicates are returned in pre-allocated arrays (see the max sizes). :type lims: int :param lims: limits between groups of duplicates (max size ntotal / 2 + 1) :type ids: int :param ids: ids[lims[i]] : ids[lims[i+1]-1] is a group of duplicates (max size ntotal) :rtype: int :return: n number of groups found )rÚIndexIVFPQ_find_duplicates)rrAr€rrrÚfind_duplicatesìszIndexIVFPQ.find_duplicatescCr‡r')rÚIndexIVFPQ_encode)rr²r8r›rrrr1þr‰zIndexIVFPQ.encodecCrŽ)a Encode multiple vectors :type n: int :param n: nb vectors to encode :type keys: int :param keys: posting list ids for those vectors (size n) :type x: float :param x: vectors (size n * d) :type codes: uint8_t :param codes: output codes (size n * code_size) :type compute_keys: boolean, optional :param compute_keys: if false, assume keys are precomputed, otherwise compute them )rÚIndexIVFPQ_encode_multiple)rrQr¶r8rÚ compute_keysrrrÚencode_multipleszIndexIVFPQ.encode_multiplecCrm)z inverse of encode_multiple)rÚIndexIVFPQ_decode_multiple)rrQr¶Úxcodesr8rrrÚdecode_multipleruzIndexIVFPQ.decode_multiplecCr‹r')rÚ"IndexIVFPQ_get_InvertedListScannerr" rrrr# rz"IndexIVFPQ.get_InvertedListScannercCrJ)z build precomputed table)rÚIndexIVFPQ_precompute_tablerLrrrÚprecompute_tabler`zIndexIVFPQ.precompute_tablecGr$r')rÚIndexIVFPQ_swiginitÚnew_IndexIVFPQrprrrrHr.zIndexIVFPQ.__init__rH r')1rrr1r2rrrr rÚIndexIVFPQ_by_residual_getÚIndexIVFPQ_by_residual_setrÆ ÚIndexIVFPQ_pq_getÚIndexIVFPQ_pq_setrnÚ%IndexIVFPQ_do_polysemous_training_getÚ%IndexIVFPQ_do_polysemous_training_setrÚ"IndexIVFPQ_polysemous_training_getÚ"IndexIVFPQ_polysemous_training_setr’Ú#IndexIVFPQ_scan_table_threshold_getÚ#IndexIVFPQ_scan_table_threshold_setrÚIndexIVFPQ_polysemous_ht_getÚIndexIVFPQ_polysemous_ht_setr‚Ú$IndexIVFPQ_use_precomputed_table_getÚ$IndexIVFPQ_use_precomputed_table_setr< Ú IndexIVFPQ_precomputed_table_getÚ IndexIVFPQ_precomputed_table_setÚprecomputed_tabler rÔr r(r r+r0 r.r1r2r5r# r8rHÚdelete_IndexIVFPQrvrrrrr!¹s6    r!cCrŽ)ap Pre-compute distance tables for IVFPQ with by-residual and METRIC_L2 :type use_precomputed_table: int :param use_precomputed_table: (I/O) =-1: force disable =0: decide heuristically (default: use tables only if they are < precomputed_tables_max_bytes), set use_precomputed_table on output =1: tables that work for all quantizers (size 256 * nlist * M) =2: specific version for MultiIndexQuantizer (much more compact) :type precomputed_table: faiss::AlignedTable< float,32 > :param precomputed_table: precomputed table to initialize )rÚ"initialize_IVFPQ_precomputed_table)r< rÜ rnrKrÆ rrrrrM&r‚rMc@s„eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejƒZeejejd dZd d „Zd d „ZejZdS)ÚIndexIVFPQStatsz‚ statistics are robust to internal threading, but not if IndexIVFPQ::search_preassigned is called by multiple threads cCr5r'r6r7rrrr9;r:zIndexIVFPQStats.cCr;r'r6r<rrrr9;r>r?r@z nb of refines (IVFPQR)z5 nb of passed Hamming distance tests (for polysemous)z only for IVFPQRcCryr')rÚIndexIVFPQStats_swiginitÚnew_IndexIVFPQStatsrLrrrrHBr|zIndexIVFPQStats.__init__cCrJr')rÚIndexIVFPQStats_resetrLrrrr{ErMzIndexIVFPQStats.resetN)rrr1r2rrrr rÚIndexIVFPQStats_nrefine_getÚIndexIVFPQStats_nrefine_setÚnrefineÚ"IndexIVFPQStats_n_hamming_pass_getÚ"IndexIVFPQStats_n_hamming_pass_setr½Ú!IndexIVFPQStats_search_cycles_getÚ!IndexIVFPQStats_search_cycles_setÚ search_cyclesÚ!IndexIVFPQStats_refine_cycles_getÚ!IndexIVFPQStats_refine_cycles_setÚ refine_cyclesrHr{Údelete_IndexIVFPQStatsrvrrrrrN5s rNc@s°eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZd d „Zd d „Zdd„Zdd„Zdd„Zdd„Zdd„Zddd„Zdd„ZejZdS)Ú IndexIVFPQRz0 Index with an additional level of PQ refinementcCr5r'r6r7rrrr9Or:zIndexIVFPQR.cCr;r'r6r<rrrr9Or>r?r@z 3rd level quantizerz corresponding codeszH factor between k requested in search and the k requested from the IVFPQcCrJr')rÚIndexIVFPQR_resetrLrrrr{UrMzIndexIVFPQR.resetcCrNr')rÚIndexIVFPQR_remove_idsr­rrrr®XrSzIndexIVFPQR.remove_idscCr‹)z" trains the two product quantizers)rÚIndexIVFPQR_train_residualr“rrrr [rózIndexIVFPQR.train_residualcCr‡r')rÚIndexIVFPQR_add_with_idsr›rrrr_r‰zIndexIVFPQR.add_with_idscCrm)zB same as add_with_ids, but optionally use the precomputed list ids)rÚIndexIVFPQR_add_corer rrrr bruzIndexIVFPQR.add_corecCr‡r')rÚ#IndexIVFPQR_reconstruct_from_offsetr/ rrrr0 fr‰z#IndexIVFPQR.reconstruct_from_offsetcCr‹r')rÚIndexIVFPQR_merge_fromr×rrrrÚirzIndexIVFPQR.merge_fromNc Cr»r')rÚIndexIVFPQR_search_preassignedrû rrrrÿ lr½zIndexIVFPQR.search_preassignedcGr$r')rÚIndexIVFPQR_swiginitÚnew_IndexIVFPQRrprrrrHor.zIndexIVFPQR.__init__rø)rrr1r2rrrr rÚIndexIVFPQR_refine_pq_getÚIndexIVFPQR_refine_pq_setÚ refine_pqÚIndexIVFPQR_refine_codes_getÚIndexIVFPQR_refine_codes_setÚ refine_codesÚIndexIVFPQR_k_factor_getÚIndexIVFPQR_k_factor_setrÓr{r®r rr r0 rÚrÿ rHÚdelete_IndexIVFPQRrvrrrrr^Ls"  r^c@s²eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d „ZejZd d„Zddd„Zdd„Zdd„Zdd„Zdd„ZdS)Ú Index2Layerzã Same as an IndexIVFPQ without the inverted lists: codes are stored sequentially The class is mainly inteded to store encoded vectors that can be accessed randomly, the search function is not implemented. cCr5r'r6r7rrrr9r:zIndex2Layer.cCr;r'r6r<rrrr9r>r?r@z first level quantizerz& second level quantizer is always a PQz< size of the code for the first level (ceil(log8(q1.nlist)))z& size of the code for the second levelcGr$r')rÚIndex2Layer_swiginitÚnew_Index2LayerrprrrrH†r.zIndex2Layer.__init__cCr‹r')rÚIndex2Layer_trainr“rrrr”ŠrzIndex2Layer.trainNc CrÈr )rÚIndex2Layer_searchr rrrr¢rÌzIndex2Layer.searchcCrJr')rÚ!Index2Layer_get_distance_computerrLrrrrË‘rMz!Index2Layer.get_distance_computercCrN)z* transfer the flat codes to an IVFPQ index)rÚIndex2Layer_transfer_to_IVFPQrŒrrrÚtransfer_to_IVFPQ”r zIndex2Layer.transfer_to_IVFPQcCr‡r')rÚIndex2Layer_sa_encoderÏrrrrИr‰zIndex2Layer.sa_encodecCr‡r')rÚIndex2Layer_sa_decoderÓrrrrÔ›r‰zIndex2Layer.sa_decoder')rrr1r2rrrr rÚIndex2Layer_q1_getÚIndex2Layer_q1_setÚq1ÚIndex2Layer_pq_getÚIndex2Layer_pq_setrnÚIndex2Layer_code_size_1_getÚIndex2Layer_code_size_1_setÚ code_size_1ÚIndex2Layer_code_size_2_getÚIndex2Layer_code_size_2_setÚ code_size_2rHÚdelete_Index2Layerrvr”r¢rËryrÐrÔrrrrrrvs   rrc@sDeZdZdZedd„dd„ddZdd„ZeZee j e j ƒZ ee j e jƒZee je jƒZee je jƒZee je jƒZee je jƒZee je jƒZee je j ƒZ!ee j"e j#ƒZ$ee j%e j&ƒZ'ee j(e j)ƒZ*ee j+e j,ƒZ-d d „Z.d d „Z/d#dd„Z0dd„Z1dd„Z2dd„Z3dd„Z4dd„Z5dd„Z6dd„Z7d$dd „Z8d!d"„Z9e j:Z;d S)%Ú IndexFastScana* Fast scan version of IndexPQ and IndexAQ. Works for 4-bit PQ and AQ for now. The codes are not stored sequentially but grouped in blocks of size bbs. This makes it possible to compute distances quickly with SIMD instructions. The trailing codes (padding codes that are added to complete the last code) are garbage. Implementations: 12: blocked loop with internal loop on Q with qbs 13: same with reservoir accumulator to store results 14: no qbs with heap accumulator 15: no qbs with reservoir accumulator cCr5r'r6r7rrrr9±r:zIndexFastScan.cCr;r'r6r<rrrr9±r>r?r@cOrBrCrDrErrrrH³rIzIndexFastScan.__init__cCrŽr')rÚIndexFastScan_init_fastscan)rr†rrÚmetricÚbbsrrrÚ init_fastscanÃr|zIndexFastScan.init_fastscancCrJr')rÚIndexFastScan_resetrLrrrr{ÆrMzIndexFastScan.resetNc CrÈr')rÚIndexFastScan_searchr rrrr¢Ér.zIndexFastScan.searchcCr‹r')rÚIndexFastScan_addr“rrrr—ÌrzIndexFastScan.addcCr‡r')rÚIndexFastScan_compute_codes©rrrQr8rrrrÅÏr‰zIndexFastScan.compute_codescCr‡r')rÚIndexFastScan_compute_float_LUT©rÚlutrQr8rrrÚcompute_float_LUTÒr‰zIndexFastScan.compute_float_LUTcCrmr')rÚ#IndexFastScan_compute_quantized_LUT)rrQr8r”Ú normalizersrrrÚcompute_quantized_LUTÕrrz#IndexFastScan.compute_quantized_LUTcCr‹r')rÚIndexFastScan_reconstructr±rrrr´ØrzIndexFastScan.reconstructcCrNr')rÚIndexFastScan_remove_idsr­rrrr®ÛrSzIndexFastScan.remove_idscCrJr')rÚIndexFastScan_get_CodePackerrLrrrrÞrMzIndexFastScan.get_CodePackerrcCr‹r')rÚIndexFastScan_merge_fromr×rrrrÚárzIndexFastScan.merge_fromcCrNr')rÚ(IndexFastScan_check_compatible_for_mergerÞrrrrßärSz(IndexFastScan.check_compatible_for_merger'rá)cCr;r'r6r<rrrr9ìr>r?r@cCryr')rÚFastScanStats_swiginitÚnew_FastScanStatsrLrrrrHór|zFastScanStats.__init__cCrJr')rÚFastScanStats_resetrLrrrr{örMzFastScanStats.resetN)rrr1rrrr rÚFastScanStats_t0_getÚFastScanStats_t0_setrÚFastScanStats_t1_getÚFastScanStats_t1_setÚt1ÚFastScanStats_t2_getÚFastScanStats_t2_setÚt2ÚFastScanStats_t3_getÚFastScanStats_t3_setÚt3rHr{Údelete_FastScanStatsrvrrrrr½ër–r½c@sªeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejƒZdd„ZejZd d „Zd d „Zd d„Zdd„Zdd„Zddd„Zdd„ZdS)ÚIndexAdditiveQuantizerFastScana¶ Fast scan version of IndexAQ. Works for 4-bit AQ for now. The codes are not stored sequentially but grouped in blocks of size bbs. This makes it possible to compute distances quickly with SIMD instructions. Implementations: 12: blocked loop with internal loop on Q with qbs 13: same with reservoir accumulator to store results 14: no qbs with heap accumulator 15: no qbs with reservoir accumulator cCr5r'r6r7rrrr9 r:z'IndexAdditiveQuantizerFastScan.cCr;r'r6r<rrrr9 r>r?r@cGrnr')rÚ#IndexAdditiveQuantizerFastScan_initrprrrrœrrz#IndexAdditiveQuantizerFastScan.initcGr—)z *Overload 1:* build from an existing IndexAQ | *Overload 2:* build from an existing IndexAQ N)rÚ'IndexAdditiveQuantizerFastScan_swiginitÚ"new_IndexAdditiveQuantizerFastScanrprrrrHršz'IndexAdditiveQuantizerFastScan.__init__cCr‹r')rÚ$IndexAdditiveQuantizerFastScan_trainr“rrrr”"rz$IndexAdditiveQuantizerFastScan.traincCr‹r')rÚ2IndexAdditiveQuantizerFastScan_estimate_norm_scaler“rrrÚestimate_norm_scale%rz2IndexAdditiveQuantizerFastScan.estimate_norm_scalecCr‡r')rÚ,IndexAdditiveQuantizerFastScan_compute_codesr‘rrrrÅ(r‰z,IndexAdditiveQuantizerFastScan.compute_codescCr‡r')rÚ0IndexAdditiveQuantizerFastScan_compute_float_LUTr“rrrr•+r‰z0IndexAdditiveQuantizerFastScan.compute_float_LUTNc CrÈr')rÚ%IndexAdditiveQuantizerFastScan_searchr rrrr¢.r.z%IndexAdditiveQuantizerFastScan.searchcCr‡)aµ Decode a set of vectors. NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non- contiguous. But this method requires a contiguous representation. :type n: int :param n: number of vectors :type bytes: uint8_t :param bytes: input encoded vectors, size n * code_size :type x: float :param x: output vectors, size n * d )rÚ(IndexAdditiveQuantizerFastScan_sa_decoderÓrrrrÔ1r* z(IndexAdditiveQuantizerFastScan.sa_decoder')rrr1r2rrrr rÚ%IndexAdditiveQuantizerFastScan_aq_getÚ%IndexAdditiveQuantizerFastScan_aq_setrÞÚ/IndexAdditiveQuantizerFastScan_rescale_norm_getÚ/IndexAdditiveQuantizerFastScan_rescale_norm_setÚ rescale_normÚ-IndexAdditiveQuantizerFastScan_norm_scale_getÚ-IndexAdditiveQuantizerFastScan_norm_scale_setÚ norm_scaleÚ3IndexAdditiveQuantizerFastScan_max_train_points_getÚ3IndexAdditiveQuantizerFastScan_max_train_points_setrirœÚ%delete_IndexAdditiveQuantizerFastScanrvrHr”rÓrÅr•r¢rÔrrrrrÍýs"    rÍc@r> ) ÚIndexResidualQuantizerFastScanrâcCr5r'r6r7rrrr9Kr:z'IndexResidualQuantizerFastScan.cCr;r'r6r<rrrr9Kr>r?r@rãcGr$r')rÚ'IndexResidualQuantizerFastScan_swiginitÚ"new_IndexResidualQuantizerFastScanrprrrrHOr.z'IndexResidualQuantizerFastScan.__init__N)rrr1r2rrrr rÚ%IndexResidualQuantizerFastScan_rq_getÚ%IndexResidualQuantizerFastScan_rq_setrérHÚ%delete_IndexResidualQuantizerFastScanrvrrrrrãDó rãc@r) Ú!IndexLocalSearchQuantizerFastScanz› Index based on a local search quantizer. Stored vectors are approximated by local search quantization codes. Can also be used as a codec cCr5r'r6r7rrrr9]r:z*IndexLocalSearchQuantizerFastScan.cCr;r'r6r<rrrr9]r>r?r@cGr$r')rÚ*IndexLocalSearchQuantizerFastScan_swiginitÚ%new_IndexLocalSearchQuantizerFastScanrprrrrHar.z*IndexLocalSearchQuantizerFastScan.__init__N)rrr1r2rrrr rÚ)IndexLocalSearchQuantizerFastScan_lsq_getÚ)IndexLocalSearchQuantizerFastScan_lsq_setrfrHÚ(delete_IndexLocalSearchQuantizerFastScanrvrrrrrêVs rêc@r> ) Ú%IndexProductResidualQuantizerFastScanz£ Index based on a product residual quantizer. Stored vectors are approximated by product residual quantization codes. Can also be used as a codec cCr5r'r6r7rrrr9or:z.IndexProductResidualQuantizerFastScan.cCr;r'r6r<rrrr9or>r?r@rócGr$r')rÚ.IndexProductResidualQuantizerFastScan_swiginitÚ)new_IndexProductResidualQuantizerFastScanrprrrrHsr.z.IndexProductResidualQuantizerFastScan.__init__N)rrr1r2rrrr rÚ-IndexProductResidualQuantizerFastScan_prq_getÚ-IndexProductResidualQuantizerFastScan_prq_setrùrHÚ,delete_IndexProductResidualQuantizerFastScanrvrrrrrðhrérðc@r> ) Ú(IndexProductLocalSearchQuantizerFastScanz« Index based on a product local search quantizer. Stored vectors are approximated by product local search quantization codes. Can also be used as a codec cCr5r'r6r7rrrr9r:z1IndexProductLocalSearchQuantizerFastScan.cCr;r'r6r<rrrr9r>r?r@rýcGr$r')rÚ1IndexProductLocalSearchQuantizerFastScan_swiginitÚ,new_IndexProductLocalSearchQuantizerFastScanrprrrrH…r.z1IndexProductLocalSearchQuantizerFastScan.__init__N)rrr1r2rrrr rÚ1IndexProductLocalSearchQuantizerFastScan_plsq_getÚ1IndexProductLocalSearchQuantizerFastScan_plsq_setrrHÚ/delete_IndexProductLocalSearchQuantizerFastScanrvrrrrrözréröc@sfeZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z d d „Z d d „Zd d„Zdd„ZejZdS)ÚIndexPQFastScana¶ Fast scan version of IndexPQ. Works for 4-bit PQ for now. The codes are not stored sequentially but grouped in blocks of size bbs. This makes it possible to compute distances quickly with SIMD instructions. Implementations: 12: blocked loop with internal loop on Q with qbs 13: same with reservoir accumulator to store results 14: no qbs with heap accumulator 15: no qbs with reservoir accumulator cCr5r'r6r7rrrr9šr:zIndexPQFastScan.cCr;r'r6r<rrrr9šr>r?r@cGr—)z *Overload 1:* build from an existing IndexPQ | *Overload 2:* build from an existing IndexPQ N)rÚIndexPQFastScan_swiginitÚnew_IndexPQFastScanrprrrrHžršzIndexPQFastScan.__init__cCr‹r')rÚIndexPQFastScan_trainr“rrrr”ªrzIndexPQFastScan.traincCr‡r')rÚIndexPQFastScan_compute_codesr‘rrrrÅ­r‰zIndexPQFastScan.compute_codescCr‡r')rÚ!IndexPQFastScan_compute_float_LUTr“rrrr•°r‰z!IndexPQFastScan.compute_float_LUTcCr‡)a¥ Decode a set of vectors. NOTE: The codes in the IndexPQFastScan object are non-contiguous. But this method requires a contiguous representation. :type n: int :param n: number of vectors :type bytes: uint8_t :param bytes: input encoded vectors, size n * code_size :type x: float :param x: output vectors, size n * d )rÚIndexPQFastScan_sa_decoderÓrrrrÔ³r* zIndexPQFastScan.sa_decodeN)rrr1r2rrrr rÚIndexPQFastScan_pq_getÚIndexPQFastScan_pq_setrnrHr”rÅr•rÔÚdelete_IndexPQFastScanrvrrrrrüŒs   rüc@s2eZdZdZedd„dd„ddZdd„ZeZee j e j ƒZ ee j e jƒZee je jƒZee je jƒZee je jƒZee je jƒZee je jƒZee je j ƒZ!ee j"e j#ƒZ$ee j%e j&ƒZ'd d „Z(d d „Z)e j*Z+ee j,e j-d dZ.dd„Z/dd„Z0dd„Z1dd„Z2d!dd„Z3d!dd„Z4dd„Z5dd„Z6dd „Z7dS)"ÚIndexIVFFastScana€ Fast scan version of IVFPQ and IVFAQ. Works for 4-bit PQ/AQ for now. The codes in the inverted lists are not stored sequentially but grouped in blocks of size bbs. This makes it possible to very quickly compute distances with SIMD instructions. Implementations (implem): 0: auto-select implementation (default) 1: orig's search, re-implemented 2: orig's search, re-ordered by invlist 10: optimizer int16 search, collect results in heap, no qbs 11: idem, collect results in reservoir 12: optimizer int16 search, collect results in heap, uses qbs 13: idem, collect results in reservoir cCr5r'r6r7rrrr9Ùr:zIndexIVFFastScan.cCr;r'r6r<rrrr9Ùr>r?r@cOrBrCrDrErrrrHÛrIzIndexIVFFastScan.__init__cCrŽr')rÚIndexIVFFastScan_init_fastscan)rrrrºrŠr‹rrrrŒér|zIndexIVFFastScan.init_fastscancCrJr')rÚ!IndexIVFFastScan_init_code_packerrLrrrÚinit_code_packerìrMz!IndexIVFFastScan.init_code_packerz& orig's inverted lists (for debugging)cCr‡r')rÚIndexIVFFastScan_add_with_idsr›rrrrñr‰zIndexIVFFastScan.add_with_idscCrJr')rÚ#IndexIVFFastScan_lookup_table_is_3drLrrrÚlookup_table_is_3dôrMz#IndexIVFFastScan.lookup_table_is_3dc CrÈr')rÚIndexIVFFastScan_compute_LUT©rrQr8Ú coarse_idsr r\Úbiasesrrrr‘÷r.zIndexIVFFastScan.compute_LUTc CrÃr')rÚ"IndexIVFFastScan_compute_LUT_uint8)rrQr8rr r\rr—rrrÚcompute_LUT_uint8úrz"IndexIVFFastScan.compute_LUT_uint8Nc CrÈr')rÚIndexIVFFastScan_searchr rrrr¢ýr.zIndexIVFFastScan.searchcCrŽ)z will just fail)rÚIndexIVFFastScan_range_searchr¥rrrr¦r”zIndexIVFFastScan.range_searchcCr‡r')rÚ(IndexIVFFastScan_reconstruct_from_offsetr/ rrrr0 r‰z(IndexIVFFastScan.reconstruct_from_offsetcCrJr')rÚIndexIVFFastScan_get_CodePackerrLrrrrrMzIndexIVFFastScan.get_CodePackercCrJr')rÚ*IndexIVFFastScan_reconstruct_orig_invlistsrLrrrÚreconstruct_orig_invlists rMz*IndexIVFFastScan.reconstruct_orig_invlistsr')8rrr1r2rrrHrr rÚIndexIVFFastScan_bbs_getÚIndexIVFFastScan_bbs_setr‹ÚIndexIVFFastScan_M_getÚIndexIVFFastScan_M_setrÚIndexIVFFastScan_nbits_getÚIndexIVFFastScan_nbits_setrÚIndexIVFFastScan_ksub_getÚIndexIVFFastScan_ksub_setrYÚIndexIVFFastScan_M2_getÚIndexIVFFastScan_M2_setr¶ÚIndexIVFFastScan_implem_getÚIndexIVFFastScan_implem_setr ÚIndexIVFFastScan_skip_getÚIndexIVFFastScan_skip_setr£Ú IndexIVFFastScan_by_residual_getÚ IndexIVFFastScan_by_residual_setrÆ ÚIndexIVFFastScan_qbs_getÚIndexIVFFastScan_qbs_setr¨ÚIndexIVFFastScan_qbs2_getÚIndexIVFFastScan_qbs2_setÚqbs2rŒr Údelete_IndexIVFFastScanrvÚ"IndexIVFFastScan_orig_invlists_getÚ"IndexIVFFastScan_orig_invlists_setÚ orig_invlistsrr r‘rr¢r¦r0 rrrrrrrÇs8   rc@sÊeZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ eejejƒZeejejƒZeejejƒZeejejƒZeejejƒZeejejƒZeej ej!ƒZ"dd„Z#dd „Z$d d „Z%d d „Z&ej'Z(dS)ÚIVFFastScanStatscCr5r'r6r7rrrr9r:zIVFFastScanStats.cCr;r'r6r<rrrr9r>r?r@cCrNr')rÚIVFFastScanStats_Mcy_atrørrrÚMcy_atrSzIVFFastScanStats.Mcy_atcCrNr')rÚ!IVFFastScanStats_Mcy_reservoir_atrørrrÚMcy_reservoir_at rSz!IVFFastScanStats.Mcy_reservoir_atcCryr')rÚIVFFastScanStats_swiginitÚnew_IVFFastScanStatsrLrrrrH#r|zIVFFastScanStats.__init__cCrJr')rÚIVFFastScanStats_resetrLrrrr{&rMzIVFFastScanStats.resetN))rrr1rrrr rÚIVFFastScanStats_times_getÚIVFFastScanStats_times_setÚtimesÚ.IVFFastScanStats_t_compute_distance_tables_getÚ.IVFFastScanStats_t_compute_distance_tables_setÚt_compute_distance_tablesÚIVFFastScanStats_t_round_getÚIVFFastScanStats_t_round_setÚt_roundÚ IVFFastScanStats_t_copy_pack_getÚ IVFFastScanStats_t_copy_pack_setÚ t_copy_packÚIVFFastScanStats_t_scan_getÚIVFFastScanStats_t_scan_setÚt_scanÚIVFFastScanStats_t_to_flat_getÚIVFFastScanStats_t_to_flat_setÚ t_to_flatÚ$IVFFastScanStats_reservoir_times_getÚ$IVFFastScanStats_reservoir_times_setÚreservoir_timesÚ IVFFastScanStats_t_aq_encode_getÚ IVFFastScanStats_t_aq_encode_setÚ t_aq_encodeÚ%IVFFastScanStats_t_aq_norm_encode_getÚ%IVFFastScanStats_t_aq_norm_encode_setÚt_aq_norm_encoder4r6rHr{Údelete_IVFFastScanStatsrvrrrrr2s" r2c@s´eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejƒZdd„ZejZd d „Zd d „Zd d„Zddd„Zddd„Zdd„Zdd„Zdd„ZdS)Ú!IndexIVFAdditiveQuantizerFastScanas Fast scan version of IVFAQ. Works for 4-bit AQ for now. The codes in the inverted lists are not stored sequentially but grouped in blocks of size bbs. This makes it possible to very quickly compute distances with SIMD instructions. Implementations (implem): 0: auto-select implementation (default) 1: orig's search, re-implemented 2: orig's search, re-ordered by invlist 10: optimizer int16 search, collect results in heap, no qbs 11: idem, collect results in reservoir 12: optimizer int16 search, collect results in heap, uses qbs 13: idem, collect results in reservoir cCr5r'r6r7rrrr9?r:z*IndexIVFAdditiveQuantizerFastScan.cCr;r'r6r<rrrr9?r>r?r@cCrmr')rÚ&IndexIVFAdditiveQuantizerFastScan_init)rrÞrºrŠr‹rrrrœFrrz&IndexIVFAdditiveQuantizerFastScan.initcGr$r')rÚ*IndexIVFAdditiveQuantizerFastScan_swiginitÚ%new_IndexIVFAdditiveQuantizerFastScanrprrrrHJr.z*IndexIVFAdditiveQuantizerFastScan.__init__cCr‹r')rÚ0IndexIVFAdditiveQuantizerFastScan_train_residualr“rrrr Mrz0IndexIVFAdditiveQuantizerFastScan.train_residualcCr‹r')rÚ5IndexIVFAdditiveQuantizerFastScan_estimate_norm_scaler“rrrrÓPrz5IndexIVFAdditiveQuantizerFastScan.estimate_norm_scaleFcCrŽ)zq same as the regular IVFAQ encoder. The codes are not reorganized by blocks a that point )rÚ0IndexIVFAdditiveQuantizerFastScan_encode_vectorsr rrrr SrÙz0IndexIVFAdditiveQuantizerFastScan.encode_vectorsNc CrÈr')rÚ(IndexIVFAdditiveQuantizerFastScan_searchr rrrr¢Zr.z(IndexIVFAdditiveQuantizerFastScan.searchcCrJr')rÚ4IndexIVFAdditiveQuantizerFastScan_lookup_table_is_3drLrrrr ]rMz4IndexIVFAdditiveQuantizerFastScan.lookup_table_is_3dc CrÈr')rÚ-IndexIVFAdditiveQuantizerFastScan_compute_LUTrrrrr‘`r.z-IndexIVFAdditiveQuantizerFastScan.compute_LUTcCr‡r')rÚ+IndexIVFAdditiveQuantizerFastScan_sa_decoderÓrrrrÔcr‰z+IndexIVFAdditiveQuantizerFastScan.sa_decoderH r') rrr1r2rrrr rÚ(IndexIVFAdditiveQuantizerFastScan_aq_getÚ(IndexIVFAdditiveQuantizerFastScan_aq_setrÞÚ2IndexIVFAdditiveQuantizerFastScan_rescale_norm_getÚ2IndexIVFAdditiveQuantizerFastScan_rescale_norm_setrÜÚ0IndexIVFAdditiveQuantizerFastScan_norm_scale_getÚ0IndexIVFAdditiveQuantizerFastScan_norm_scale_setrßÚ6IndexIVFAdditiveQuantizerFastScan_max_train_points_getÚ6IndexIVFAdditiveQuantizerFastScan_max_train_points_setrirœÚ(delete_IndexIVFAdditiveQuantizerFastScanrvrHr rÓr r¢r r‘rÔrrrrrV-s$   rVc@óBeZdZedd„dd„ddZeZeejej ƒZ dd„Z ej Z dS) Ú$IndexIVFLocalSearchQuantizerFastScancCr5r'r6r7rrrr9jr:z-IndexIVFLocalSearchQuantizerFastScan.cCr;r'r6r<rrrr9jr>r?r@cGr$r')rÚ-IndexIVFLocalSearchQuantizerFastScan_swiginitÚ(new_IndexIVFLocalSearchQuantizerFastScanrprrrrHnr.z-IndexIVFLocalSearchQuantizerFastScan.__init__N)rrr1rrrr rÚ,IndexIVFLocalSearchQuantizerFastScan_lsq_getÚ,IndexIVFLocalSearchQuantizerFastScan_lsq_setrfrHÚ+delete_IndexIVFLocalSearchQuantizerFastScanrvrrrrrkió  rkc@rj) Ú!IndexIVFResidualQuantizerFastScancCr5r'r6r7rrrr9vr:z*IndexIVFResidualQuantizerFastScan.cCr;r'r6r<rrrr9vr>r?r@cGr$r')rÚ*IndexIVFResidualQuantizerFastScan_swiginitÚ%new_IndexIVFResidualQuantizerFastScanrprrrrHzr.z*IndexIVFResidualQuantizerFastScan.__init__N)rrr1rrrr rÚ(IndexIVFResidualQuantizerFastScan_rq_getÚ(IndexIVFResidualQuantizerFastScan_rq_setrérHÚ(delete_IndexIVFResidualQuantizerFastScanrvrrrrrrurqrrc@rj) Ú+IndexIVFProductLocalSearchQuantizerFastScancCr5r'r6r7rrrr9‚r:z4IndexIVFProductLocalSearchQuantizerFastScan.cCr;r'r6r<rrrr9‚r>r?r@cGr$r')rÚ4IndexIVFProductLocalSearchQuantizerFastScan_swiginitÚ/new_IndexIVFProductLocalSearchQuantizerFastScanrprrrrH†r.z4IndexIVFProductLocalSearchQuantizerFastScan.__init__N)rrr1rrrr rÚ4IndexIVFProductLocalSearchQuantizerFastScan_plsq_getÚ4IndexIVFProductLocalSearchQuantizerFastScan_plsq_setrrHÚ2delete_IndexIVFProductLocalSearchQuantizerFastScanrvrrrrrxrqrxc@rj) Ú(IndexIVFProductResidualQuantizerFastScancCr5r'r6r7rrrr9Žr:z1IndexIVFProductResidualQuantizerFastScan.cCr;r'r6r<rrrr9Žr>r?r@cGr$r')rÚ1IndexIVFProductResidualQuantizerFastScan_swiginitÚ,new_IndexIVFProductResidualQuantizerFastScanrprrrrH’r.z1IndexIVFProductResidualQuantizerFastScan.__init__N)rrr1rrrr rÚ0IndexIVFProductResidualQuantizerFastScan_prq_getÚ0IndexIVFProductResidualQuantizerFastScan_prq_setrùrHÚ/delete_IndexIVFProductResidualQuantizerFastScanrvrrrrr~rqr~c@s eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZd d „Zd d „Zdd„Zddd„Zdd„Zdd„Zdd„ZejZdS)ÚIndexIVFPQFastScanas Fast scan version of IVFPQ. Works for 4-bit PQ for now. The codes in the inverted lists are not stored sequentially but grouped in blocks of size bbs. This makes it possible to very quickly compute distances with SIMD instructions. Implementations (implem): 0: auto-select implementation (default) 1: orig's search, re-implemented 2: orig's search, re-ordered by invlist 10: optimizer int16 search, collect results in heap, no qbs 11: idem, collect results in reservoir 12: optimizer int16 search, collect results in heap, uses qbs 13: idem, collect results in reservoir cCr5r'r6r7rrrr9«r:zIndexIVFPQFastScan.cCr;r'r6r<rrrr9«r>r?r@r"z precomputed tables managementz4 if use_precompute_table size (nlist, pq.M, pq.ksub)cGr$r')rÚIndexIVFPQFastScan_swiginitÚnew_IndexIVFPQFastScanrprrrrH±r.zIndexIVFPQFastScan.__init__cCr‹r')rÚ!IndexIVFPQFastScan_train_residualr“rrrr ´rz!IndexIVFPQFastScan.train_residualcCrJ)zA build precomputed table, possibly updating use_precomputed_table)rÚ#IndexIVFPQFastScan_precompute_tablerLrrrr8·r`z#IndexIVFPQFastScan.precompute_tableFcCrŽ)zq same as the regular IVFPQ encoder. The codes are not reorganized by blocks a that point )rÚ!IndexIVFPQFastScan_encode_vectorsr rrrr »rÙz!IndexIVFPQFastScan.encode_vectorscCrJr')rÚ%IndexIVFPQFastScan_lookup_table_is_3drLrrrr ÂrMz%IndexIVFPQFastScan.lookup_table_is_3dc CrÈr')rÚIndexIVFPQFastScan_compute_LUTrrrrr‘År.zIndexIVFPQFastScan.compute_LUTcCr‡r')rÚIndexIVFPQFastScan_sa_decoderÓrrrrÔÈr‰zIndexIVFPQFastScan.sa_decodeNrH )rrr1r2rrrr rÚIndexIVFPQFastScan_pq_getÚIndexIVFPQFastScan_pq_setrnÚ,IndexIVFPQFastScan_use_precomputed_table_getÚ,IndexIVFPQFastScan_use_precomputed_table_setr< Ú(IndexIVFPQFastScan_precomputed_table_getÚ(IndexIVFPQFastScan_precomputed_table_setrKrHr r8r r r‘rÔÚdelete_IndexIVFPQFastScanrvrrrrr„™s  r„cCrm)a× Functions to quantize PQ floating-point Look Up Tables (LUT) to uint8, and biases to uint16. The accumulation is supposed to take place in uint16. The quantization coefficients are float (a, b) such that original_value = quantized_value * a / b The hardest part of the quantization is with multiple LUTs that need to be added up together. In that case, coefficient a has to be chosen so that the sum fits in a uint16 accumulator. )rÚround_uint8_per_column)ràrQr†Úa_outÚb_outrrrr”Ðs r”cCrŽr')rÚround_uint8_per_column_multi)ràrðrQr†r•r–rrrr—Þr|r—c Cr»)a) LUT quantization to uint8 and bias to uint16. (nprobe, M, ksub, lut_is_3d) determine the size of the the LUT LUT input: - 2D size (M, ksub): single matrix per probe (lut_is_3d=false) - 3D size (nprobe, M, ksub): separate LUT per probe (lut_is_3d=true) bias input: - nullptr: bias is 0 - size (nprobe): one bias per probe Output: - LUTq uint8 version of the LUT (M size is rounded up to M2) - biasq (or nullptr): uint16 version of the LUT - a, b: scalars to approximate the true distance )rÚquantize_LUT_and_bias) rñ rrYÚ lut_is_3drŽÚbiasÚLUTqr¶Úbiasqr•r–rrrr˜ásr˜c Cs t |||||||||| | | ¡ Sr')rÚaq_quantize_LUT_and_bias) rñ rrYrŽršÚM_normrßr›r¶rœr•r–rrrrôs rcCr‡r')rÚaq_estimate_norm_scale)rrYržrŽrrrrŸ÷r‰rŸc@seZdZdZedd„dd„ddZdd„ZeZee j e j d dZ ee j e jd dZee je jd dZee je jd dZee je jd dZee je jddZe jZdd„Zdd„Zdd„Z d.dd„Z!d.dd„Z"d/dd„Z#dd„Z$dd „Z%d!d"„Z&d#d$„Z'd.d%d&„Z(d'd(„Z)d0d*d+„Z*d,d-„Z+dS)1Ú IndexBinaryzÁ Abstract structure for a binary index. Supports adding vertices and searching them. All queries are symmetric because there is no distinction between codes and vectors. cCr5r'r6r7rrrr9 r:zIndexBinary.cCr;r'r6r<rrrr9 r>r?r@cOrBrCrDrErrrrH rIzIndexBinary.__init__rŽz' number of bytes per vector ( = d / 8 )rrzX set if the Index does not require training, or if training is done already r‘cCr‹)zÛ Perform training on a representative set of vectors. :type n: int :param n: nb of training vectors :type x: uint8_t :param x: training vecors, size n * d / 8 )rÚIndexBinary_trainr“rrrr” r•zIndexBinary.traincCr‹)zÓ Add n vectors of dimension d to the index. Vectors are implicitly assigned labels ntotal .. ntotal + n - 1 :type x: uint8_t :param x: input matrix, size n * d / 8 )rÚIndexBinary_addr“rrrr— r˜ zIndexBinary.addcCr‡r™)rÚIndexBinary_add_with_idsr›rrrr( ržzIndexBinary.add_with_idsNc CrÈ)aÐ Query n vectors of dimension d to the index. return at most k vectors. If there are not enough results for a query, the result array is padded with -1s. :type x: uint8_t :param x: input vectors to search, size n * d / 8 :type labels: int :param labels: output labels of the NNs, size n*k :type distances: int :param distances: output pairwise distances, size n*k )rÚIndexBinary_searchr rrrr¢4 r£zIndexBinary.searchcCrŽ)aÿ Query n vectors of dimension d to the index. return all vectors with distance < radius. Note that many indexes do not implement the range_search (only the k-NN search is mandatory). The distances are converted to float to reuse the RangeSearchResult structure, but they are integer. By convention, only distances < radius (strict comparison) are returned, ie. radius = 0 does not return any result and 1 returns only exact same vectors. :type x: uint8_t :param x: input vectors to search, size n * d / 8 :type radius: int :param radius: search radius :type result: :py:class:`RangeSearchResult` :param result: result table )rÚIndexBinary_range_searchr¥rrrr¦D szIndexBinary.range_searchrcCrm)a` Return the indexes of the k vectors closest to the query x. This function is identical to search but only returns labels of neighbors. :type x: uint8_t :param x: input vectors to search, size n * d / 8 :type labels: int :param labels: output labels of the NNs, size n*k )rÚIndexBinary_assignr©rrrrªY r‚zIndexBinary.assigncCrJ)z( Removes all elements from the database.)rÚIndexBinary_resetrLrrrr{f r`zIndexBinary.resetcCrN)z: Removes IDs from the index. Not supported by all indexes.)rÚIndexBinary_remove_idsr­rrrr®j r zIndexBinary.remove_idscCr‹)a Reconstruct a stored vector. This function may not be defined for some indexes. :type key: int :param key: id of the vector to reconstruct :type recons: uint8_t :param recons: reconstucted vector (size d / 8) )rÚIndexBinary_reconstructr±rrrr´n r˜zIndexBinary.reconstructcCr‡)zÖ Reconstruct vectors i0 to i0 + ni - 1. This function may not be defined for some indexes. :type recons: uint8_t :param recons: reconstucted vectors (size ni * d / 8) )rÚIndexBinary_reconstruct_nrºrrrr½z r¾zIndexBinary.reconstruct_nc CrÃ)af Similar to search, but also reconstructs the stored vectors (or an approximation in the case of lossy coding) for the search results. If there are not enough results for a query, the resulting array is padded with -1s. :type recons: uint8_t :param recons: reconstructed vectors size (n, k, d) )rÚ"IndexBinary_search_and_reconstructrÀrrrrÁ„ rÂz"IndexBinary.search_and_reconstructcCrJ)z2 Display the actual class name and some more info.)rÚIndexBinary_displayrLrrrÚdisplay‘ r`zIndexBinary.displayrcCr‹rÕ)rÚIndexBinary_merge_fromr×rrrrÚ• rÛzIndexBinary.merge_fromcCrNrÜ)rÚ&IndexBinary_check_compatible_for_mergerÞrrrrßž ràz&IndexBinary.check_compatible_for_merger'rtrá),rrr1r2rrrHrr rÚIndexBinary_d_getÚIndexBinary_d_setr†ÚIndexBinary_code_size_getÚIndexBinary_code_size_setrœÚIndexBinary_ntotal_getÚIndexBinary_ntotal_setræÚIndexBinary_verbose_getÚIndexBinary_verbose_setrÚIndexBinary_is_trained_getÚIndexBinary_is_trained_setrëÚIndexBinary_metric_type_getÚIndexBinary_metric_type_setr…Údelete_IndexBinaryrvr”r—rr¢r¦rªr{r®r´r½rÁr­rÚrßrrrrr ùs4        r c@s¬eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejƒZeejejƒZd d „Zd d „Zddd„Zddd„Zdd„Zdd„Zdd„ZejZd S)ÚIndexBinaryFlatzC Index that stores the full vectors and performs exhaustive search.cCr5r'r6r7rrrr9¬ r:zIndexBinaryFlat.cCr;r'r6r<rrrr9¬ r>r?r@z& database vectors, size ntotal * d / 8út Select between using a heap or counting to select the k smallest values when scanning inverted lists. cCr‹r')rÚIndexBinaryFlat_addr“rrrr—¶ rzIndexBinaryFlat.addcCrJr')rÚIndexBinaryFlat_resetrLrrrr{¹ rMzIndexBinaryFlat.resetNc CrÈr')rÚIndexBinaryFlat_searchr rrrr¢¼ r.zIndexBinaryFlat.searchcCrŽr')rÚIndexBinaryFlat_range_searchr¥rrrr¦¿ r|zIndexBinaryFlat.range_searchcCr‹r')rÚIndexBinaryFlat_reconstructr±rrrr´ rzIndexBinaryFlat.reconstructcCrN)z¼ Remove some ids. Note that because of the indexing structure, the semantics of this operation are different from the usual ones: the new ids are shifted. )rÚIndexBinaryFlat_remove_idsr­rrrr®Å ràzIndexBinaryFlat.remove_idscGr$r')rÚIndexBinaryFlat_swiginitÚnew_IndexBinaryFlatrprrrrHÍ r.zIndexBinaryFlat.__init__r')rrr1r2rrrr rÚIndexBinaryFlat_xb_getÚIndexBinaryFlat_xb_setr%ÚIndexBinaryFlat_use_heap_getÚIndexBinaryFlat_use_heap_setÚuse_heapÚ$IndexBinaryFlat_query_batch_size_getÚ$IndexBinaryFlat_query_batch_size_setÚquery_batch_sizeÚ$IndexBinaryFlat_approx_topk_mode_getÚ$IndexBinaryFlat_approx_topk_mode_setrr—r{r¢r¦r´r®rHÚdelete_IndexBinaryFlatrvrrrrr½© s    r½c@sÂeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ƒZeejejddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZ eej!ej"ddZ#eej$ej%ddZ&eej'ej(ddZ)eej*ej+ddZ,dd„Z-ej.Z/dd„Z0dd„Z1dd„Z2dd„Z3dd„Z4dAdd „Z5dBd"d#„Z6dAd$d%„Z7dAd&d'„Z8d(d)„Z9d*d+„Z:d,d-„Z;dAd.d/„Zd4d5„Z?d6d7„Z@d8d9„ZAdCd;d<„ZBd=d>„ZCdBd?d@„ZDdS)DÚIndexBinaryIVFa_ Index based on a inverted file (IVF) In the inverted file, the quantizer (an IndexBinary instance) provides a quantization index for each vector to be added. The quantization index maps to a list (aka inverted list or posting list), where the id of the vector is stored. Otherwise the object is similar to the IndexIVF cCr5r'r6r7rrrr9à r:zIndexBinaryIVF.cCr;r'r6r<rrrr9à r>r?r@r rë rì r¾z collect computations per batchz> map for direct access to the elements. Enables reconstruct().rË ržrÌ rÍ rÎ cGr$r')rÚIndexBinaryIVF_swiginitÚnew_IndexBinaryIVFrprrrrHò r.zIndexBinaryIVF.__init__cCrJr')rÚIndexBinaryIVF_resetrLrrrr{ö rMzIndexBinaryIVF.resetcCr‹)z Trains the quantizer)rÚIndexBinaryIVF_trainr“rrrr”ù rózIndexBinaryIVF.traincCr‹r')rÚIndexBinaryIVF_addr“rrrr—ý rzIndexBinaryIVF.addcCr‡r')rÚIndexBinaryIVF_add_with_idsr›rrrr!r‰zIndexBinaryIVF.add_with_idscCrm)zð Implementation of vector addition where the vector assignments are predefined. :type precomputed_idx: int :param precomputed_idx: quantization indices for the input vectors (size n) )rÚIndexBinaryIVF_add_corer rrrr !rˆzIndexBinaryIVF.add_coreNc CrJ)aB Search a set of vectors, that are pre-quantized by the IVF quantizer. Fill in the corresponding heaps with the query results. search() calls this. :type n: int :param n: nb of vectors to query :type x: uint8_t :param x: query vectors, size nx * d :type assign: int :param assign: coarse quantization indices, size nx * nprobe :type centroid_dis: int :param centroid_dis: distances to coarse centroids, size nx * nprobe :param distance: output distances, size n * k :type labels: int :param labels: output labels, size n * k :type store_pairs: boolean :param store_pairs: store inv list index + inv list offset instead in upper/lower 32 bit of result, instead of ids (used for reranking). :type params: :py:class:`IVFSearchParameters`, optional :param params: used to override the object's search parameters )rÚ!IndexBinaryIVF_search_preassigned) rrQr8rÅrªrü rÆrÇrý r¡rrrrÿ !sz!IndexBinaryIVF.search_preassignedFcCrNr')rÚ&IndexBinaryIVF_get_InvertedListScanner)rrý rrrr# *!rSz&IndexBinaryIVF.get_InvertedListScannerc CrÈr )rÚIndexBinaryIVF_searchr rrrr¢-!rÌzIndexBinaryIVF.searchcCrŽr')rÚIndexBinaryIVF_range_searchr¥rrrr¦1!r|zIndexBinaryIVF.range_searchc CrÈr')rÚ'IndexBinaryIVF_range_search_preassigned)rrQr8rÊrªrü rËrrrr 4!r.z'IndexBinaryIVF.range_search_preassignedcCr‹r')rÚIndexBinaryIVF_reconstructr±rrrr´7!rzIndexBinaryIVF.reconstructcCr‡)aµ Reconstruct a subset of the indexed vectors. Overrides default implementation to bypass reconstruct() which requires direct_map to be maintained. :type i0: int :param i0: first vector to reconstruct :type ni: int :param ni: nb of vectors to reconstruct :type recons: uint8_t :param recons: output array of reconstructed vectors, size ni * d / 8 )rÚIndexBinaryIVF_reconstruct_nrºrrrr½:!r* zIndexBinaryIVF.reconstruct_nc CrÃ)aÀ Similar to search, but also reconstructs the stored vectors (or an approximation in the case of lossy coding) for the search results. Overrides default implementation to avoid having to maintain direct_map and instead fetch the code offsets through the `store_pairs` flag in search_preassigned(). :type recons: uint8_t :param recons: reconstructed vectors size (n, k, d / 8) )rÚ%IndexBinaryIVF_search_and_reconstructrÀrrrrÁJ!r, z%IndexBinaryIVF.search_and_reconstructcCr‡r- )rÚ&IndexBinaryIVF_reconstruct_from_offsetr/ rrrr0 X!rz&IndexBinaryIVF.reconstruct_from_offsetcCrNr1 )rÚIndexBinaryIVF_remove_idsr­rrrr®c!r zIndexBinaryIVF.remove_idscCr‹r')rÚIndexBinaryIVF_merge_from)rrrÙrrrrÚg!rzIndexBinaryIVF.merge_fromcCrNr')rÚ)IndexBinaryIVF_check_compatible_for_mergerÞrrrrßj!rSz)IndexBinaryIVF.check_compatible_for_mergecCrNr')rÚIndexBinaryIVF_get_list_sizer¡rrrr8 m!rSzIndexBinaryIVF.get_list_sizeTcCrNr; )rÚIndexBinaryIVF_make_direct_mapr= rrrr? p!rôzIndexBinaryIVF.make_direct_mapcCrNr')rÚ"IndexBinaryIVF_set_direct_map_typerA rrrrB z!rSz"IndexBinaryIVF.set_direct_map_typecCr‹r')rÚIndexBinaryIVF_replace_invlistsrD rrrrE }!rzIndexBinaryIVF.replace_invlistsr'rH r>)Errr1r2rrrr rÚIndexBinaryIVF_invlists_getÚIndexBinaryIVF_invlists_setrš ÚIndexBinaryIVF_own_invlists_getÚIndexBinaryIVF_own_invlists_setrM ÚIndexBinaryIVF_nprobe_getÚIndexBinaryIVF_nprobe_setrñ ÚIndexBinaryIVF_max_codes_getÚIndexBinaryIVF_max_codes_setrô ÚIndexBinaryIVF_use_heap_getÚIndexBinaryIVF_use_heap_setrËÚ%IndexBinaryIVF_per_invlist_search_getÚ%IndexBinaryIVF_per_invlist_search_setÚper_invlist_searchÚIndexBinaryIVF_direct_map_getÚIndexBinaryIVF_direct_map_setrº ÚIndexBinaryIVF_quantizer_getÚIndexBinaryIVF_quantizer_setrÜ ÚIndexBinaryIVF_nlist_getÚIndexBinaryIVF_nlist_setrºÚIndexBinaryIVF_own_fields_getÚIndexBinaryIVF_own_fields_setr¹ÚIndexBinaryIVF_cp_getÚIndexBinaryIVF_cp_setrÚ#IndexBinaryIVF_clustering_index_getÚ#IndexBinaryIVF_clustering_index_setrè rHÚdelete_IndexBinaryIVFrvr{r”r—rr rÿ r# r¢r¦r r´r½rÁr0 r®rÚrßr8 r? rB rE rrrrrÒÔ sN        rÒc@s\eZdZedd„dd„ddZdd„ZeZdd „Zd d „Z d d „Z dd„Z dd„Z e jZdS)ÚBinaryInvertedListScannercCr5r'r6r7rrrr9„!r:z"BinaryInvertedListScanner.cCr;r'r6r<rrrr9„!r>r?r@cOrBrCrDrErrrrH†!rIz"BinaryInvertedListScanner.__init__cCrNrY )rÚ#BinaryInvertedListScanner_set_queryr[ rrrröŠ!r z#BinaryInvertedListScanner.set_querycCr‹r] )rÚ"BinaryInvertedListScanner_set_listr_ rrrr` Ž!róz"BinaryInvertedListScanner.set_listcCrNra )rÚ*BinaryInvertedListScanner_distance_to_coderrrrr’!r z*BinaryInvertedListScanner.distance_to_codec CrÈ)a@ compute the distances to codes. (distances, labels) should be organized as a min- or max-heap :type n: int :param n: number of codes to scan :type codes: uint8_t :param codes: codes to scan (n * code_size) :type ids: int :param ids: corresponding ids (ignored if store_pairs) :type distances: int :param distances: heap distances (size k) :type labels: int :param labels: heap labels (size k) :type k: int :param k: heap size )rÚ$BinaryInvertedListScanner_scan_codesrd rrrre –!sz$BinaryInvertedListScanner.scan_codescCrŽr')rÚ*BinaryInvertedListScanner_scan_codes_rangerj rrrrk ª!r|z*BinaryInvertedListScanner.scan_codes_rangeN)rrr1rrrHrr rör` rre rk rÚ delete_BinaryInvertedListScannerrvrrrrrƒ!s rc@szeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ddZdd „ZejZd d „Zd d „Zddd„Zdd„ZdS)ÚIndexBinaryFromFloatz¿ IndexBinary backed by a float Index. Supports adding vertices and searching them. All queries are symmetric because there is no distinction between codes and vectors. cCr5r'r6r7rrrr9»!r:zIndexBinaryFromFloat.cCr;r'r6r<rrrr9»!r>r?r@z' Whether object owns the index pointer.cGr$r')rÚIndexBinaryFromFloat_swiginitÚnew_IndexBinaryFromFloatrprrrrHÀ!r.zIndexBinaryFromFloat.__init__cCr‹r')rÚIndexBinaryFromFloat_addr“rrrr—Ä!rzIndexBinaryFromFloat.addcCrJr')rÚIndexBinaryFromFloat_resetrLrrrr{Ç!rMzIndexBinaryFromFloat.resetNc CrÈr')rÚIndexBinaryFromFloat_searchr rrrr¢Ê!r.zIndexBinaryFromFloat.searchcCr‹r')rÚIndexBinaryFromFloat_trainr“rrrr”Í!rzIndexBinaryFromFloat.trainr')rrr1r2rrrr rÚIndexBinaryFromFloat_index_getÚIndexBinaryFromFloat_index_setr€Ú#IndexBinaryFromFloat_own_fields_getÚ#IndexBinaryFromFloat_own_fields_setr¹rHÚdelete_IndexBinaryFromFloatrvr—r{r¢r”rrrrr ±!s   r c@s”eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZdd„ZejZd d „Zd d „Zd d„Zddd„Zdd„Zdd„ZdS)ÚIndexBinaryHNSWr cCr5r'r6r7rrrr9Ù!r:zIndexBinaryHNSW.cCr;r'r6r<rrrr9Ù!r>r?r@cGr$r')rÚIndexBinaryHNSW_swiginitÚnew_IndexBinaryHNSWrprrrrHß!r.zIndexBinaryHNSW.__init__cCrJr')rÚ%IndexBinaryHNSW_get_distance_computerrLrrrrËã!rMz%IndexBinaryHNSW.get_distance_computercCr‹r')rÚIndexBinaryHNSW_addr“rrrr—æ!rzIndexBinaryHNSW.addcCr‹r )rÚIndexBinaryHNSW_trainr“rrrr”é!rózIndexBinaryHNSW.trainNc CrÈr )rÚIndexBinaryHNSW_searchr rrrr¢í!rÌzIndexBinaryHNSW.searchcCr‹r')rÚIndexBinaryHNSW_reconstructr±rrrr´ñ!rzIndexBinaryHNSW.reconstructcCrJr')rÚIndexBinaryHNSW_resetrLrrrr{ô!rMzIndexBinaryHNSW.resetr')rrr1r2rrrr rÚIndexBinaryHNSW_hnsw_getÚIndexBinaryHNSW_hnsw_setr$ ÚIndexBinaryHNSW_own_fields_getÚIndexBinaryHNSW_own_fields_setr¹ÚIndexBinaryHNSW_storage_getÚIndexBinaryHNSW_storage_setr) rHÚdelete_IndexBinaryHNSWrvrËr—r”r¢r´r{rrrrrÓ!s  rc@sžeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZdd„Zd d „Zd d „Zd d„Zddd„Zddd„Zdd„Zdd„ZejZdS)ÚIndexBinaryHashú+ just uses the b first bits as a hash valuecCr5r'r6r7rrrr9ý!r:zIndexBinaryHash.cCr;r'r6r<rrrr9ý!r>r?r@cGr$r')rÚIndexBinaryHash_swiginitÚnew_IndexBinaryHashrprrrrH"r.zIndexBinaryHash.__init__cCrJr')rÚIndexBinaryHash_resetrLrrrr{"rMzIndexBinaryHash.resetcCr‹r')rÚIndexBinaryHash_addr“rrrr— "rzIndexBinaryHash.addcCr‡r')rÚIndexBinaryHash_add_with_idsr›rrrr "r‰zIndexBinaryHash.add_with_idsNcCrŽr')rÚIndexBinaryHash_range_searchr¥rrrr¦"r|zIndexBinaryHash.range_searchc CrÈr')rÚIndexBinaryHash_searchr rrrr¢"r.zIndexBinaryHash.searchcCrJr')rÚIndexBinaryHash_displayrLrrrr­"rMzIndexBinaryHash.displaycCrJr')rÚIndexBinaryHash_hashtable_sizerLrrrÚhashtable_size"rMzIndexBinaryHash.hashtable_sizer')rrr1r2rrrr rÚIndexBinaryHash_invlists_getÚIndexBinaryHash_invlists_setrš ÚIndexBinaryHash_b_getÚIndexBinaryHash_b_setr…ÚIndexBinaryHash_nflip_getÚIndexBinaryHash_nflip_setÚnfliprHr{r—rr¦r¢r­r2Údelete_IndexBinaryHashrvrrrrr'ú!s    r'c@r„) ÚIndexBinaryHashStatscCr5r'r6r7rrrr9 "r:zIndexBinaryHashStats.cCr;r'r6r<rrrr9 "r>r?r@cCryr')rÚIndexBinaryHashStats_swiginitÚnew_IndexBinaryHashStatsrLrrrrH'"r|zIndexBinaryHashStats.__init__cCrJr')rÚIndexBinaryHashStats_resetrLrrrr{*"rMzIndexBinaryHashStats.resetN)rrr1rrrr rÚIndexBinaryHashStats_nq_getÚIndexBinaryHashStats_nq_setr#ÚIndexBinaryHashStats_n0_getÚIndexBinaryHashStats_n0_setrë ÚIndexBinaryHashStats_nlist_getÚIndexBinaryHashStats_nlist_setrºÚIndexBinaryHashStats_ndis_getÚIndexBinaryHashStats_ndis_setr† rHr{Údelete_IndexBinaryHashStatsrvrrrrr;"r–r;c@sÄeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejddZeejejddZeejejd dZd d „ZejZd d „Zdd„Zddd„Z ddd„Z!dd„Z"dS)ÚIndexBinaryMultiHashr(cCr5r'r6r7rrrr94"r:zIndexBinaryMultiHash.cCr;r'r6r<rrrr94"r>r?r@z nb of hash mapsz nb bits per hash mapz# nb bit flips to use at search timecGr$r')rÚIndexBinaryMultiHash_swiginitÚnew_IndexBinaryMultiHashrprrrrH="r.zIndexBinaryMultiHash.__init__cCrJr')rÚIndexBinaryMultiHash_resetrLrrrr{A"rMzIndexBinaryMultiHash.resetcCr‹r')rÚIndexBinaryMultiHash_addr“rrrr—D"rzIndexBinaryMultiHash.addNcCrŽr')rÚ!IndexBinaryMultiHash_range_searchr¥rrrr¦G"r|z!IndexBinaryMultiHash.range_searchc CrÈr')rÚIndexBinaryMultiHash_searchr rrrr¢J"r.zIndexBinaryMultiHash.searchcCrJr')rÚ#IndexBinaryMultiHash_hashtable_sizerLrrrr2M"rMz#IndexBinaryMultiHash.hashtable_sizer')#rrr1r2rrrr rÚ IndexBinaryMultiHash_storage_getÚ IndexBinaryMultiHash_storage_setr) Ú#IndexBinaryMultiHash_own_fields_getÚ#IndexBinaryMultiHash_own_fields_setr¹ÚIndexBinaryMultiHash_maps_getÚIndexBinaryMultiHash_maps_setÚmapsÚIndexBinaryMultiHash_nhash_getÚIndexBinaryMultiHash_nhash_setÚnhashÚIndexBinaryMultiHash_b_getÚIndexBinaryMultiHash_b_setr…ÚIndexBinaryMultiHash_nflip_getÚIndexBinaryMultiHash_nflip_setr9rHÚdelete_IndexBinaryMultiHashrvr{r—r¦r¢r2rrrrrH1"s"   rHc@ózeZdZdZedd„dd„ddZdd„ZeZe j Z d d „Z d d „Z d d„Zdd„Zdd„Zdd„Zee je jddZdS)ÚThreadedIndexBaseúr A holder of indices in a collection of threads The interface to this class itself is not thread safe cCr5r'r6r7rrrr9Y"r:zThreadedIndexBase.cCr;r'r6r<rrrr9Y"r>r?r@cOrBrCrDrErrrrH["rIzThreadedIndexBase.__init__cCrN©a override an index that is managed by ourselves. WARNING: once an index is added, it becomes unsafe to touch it from any other thread than that on which is managing it, until we are shut down. Use runOnIndex to perform work on it instead. )rÚThreadedIndexBase_addIndexr£ rrrÚaddIndex`"r–zThreadedIndexBase.addIndexcCrN©z Remove an index that is managed by ourselves. This will flush all pending work on that index, and then shut down its managing thread, and will remove the index. )rÚThreadedIndexBase_removeIndexr£ rrrÚ removeIndexi"ràzThreadedIndexBase.removeIndexcGrnr')rÚThreadedIndexBase_runOnIndexrprrrÚ runOnIndexq"rrzThreadedIndexBase.runOnIndexcCrJ©zL faiss::Index API All indices receive the same call )rÚThreadedIndexBase_resetrLrrrr{t"r†zThreadedIndexBase.resetcCrJ©z" Returns the number of sub-indices)rÚThreadedIndexBase_countrLrrrr± {"r`zThreadedIndexBase.countcGrn©z— *Overload 1:* Returns the i-th sub-index | *Overload 2:* Returns the i-th sub-index (const version) )rÚThreadedIndexBase_atrprrrrˆ"rczThreadedIndexBase.atúE Whether or not we are responsible for deleting our contained indicesN)rrr1r2rrrHrr rÚdelete_ThreadedIndexBaservrdrgrir{r± rˆÚ!ThreadedIndexBase_own_indices_getÚ!ThreadedIndexBase_own_indices_setÚ own_indicesrrrrr`S"ó  r`c@r_)ÚThreadedIndexBaseBinaryracCr5r'r6r7rrrr9•"r:z ThreadedIndexBaseBinary.cCr;r'r6r<rrrr9•"r>r?r@cOrBrCrDrErrrrH—"rIz ThreadedIndexBaseBinary.__init__cCrNrb)rÚ ThreadedIndexBaseBinary_addIndexr£ rrrrdœ"r–z ThreadedIndexBaseBinary.addIndexcCrNre)rÚ#ThreadedIndexBaseBinary_removeIndexr£ rrrrg¥"ràz#ThreadedIndexBaseBinary.removeIndexcGrnr')rÚ"ThreadedIndexBaseBinary_runOnIndexrprrrri­"rrz"ThreadedIndexBaseBinary.runOnIndexcCrJrj)rÚThreadedIndexBaseBinary_resetrLrrrr{°"r†zThreadedIndexBaseBinary.resetcCrJrl)rÚThreadedIndexBaseBinary_countrLrrrr± ·"r`zThreadedIndexBaseBinary.countcGrnrn)rÚThreadedIndexBaseBinary_atrprrrrˆ»"rczThreadedIndexBaseBinary.atrpN)rrr1r2rrrHrr rÚdelete_ThreadedIndexBaseBinaryrvrdrgrir{r± rˆÚ'ThreadedIndexBaseBinary_own_indices_getÚ'ThreadedIndexBaseBinary_own_indices_setrtrrrrrv"rurvc@ó€eZdZdZedd„dd„ddZeZdd„Zd d „Z d d „Z d d„Z dd„Z ddd„Z dd„ZeejejƒZdd„ZejZdS)Ú IndexShardsúcCr;r'r6r<rrrr9Î"r>r?r@cGr—©a7 *Overload 1:* The dimension that all sub-indices must share will be the dimension of the first sub-index added :type threaded: boolean, optional :param threaded: do we use one thread per sub_index or do queries sequentially? :type successive_ids: boolean, optional :param successive_ids: should we shift the returned ids by the size of each sub-index or return them as they are? | *Overload 2:* :type threaded: boolean, optional :param threaded: do we use one thread per sub_index or do queries sequentially? :type successive_ids: boolean, optional :param successive_ids: should we shift the returned ids by the size of each sub-index or return them as they are? | *Overload 3:* :type threaded: boolean, optional :param threaded: do we use one thread per sub_index or do queries sequentially? :param successive_ids: should we shift the returned ids by the size of each sub-index or return them as they are? | *Overload 4:* :param threaded: do we use one thread per sub_index or do queries sequentially? :param successive_ids: should we shift the returned ids by the size of each sub-index or return them as they are? | *Overload 5:* int version due to the implicit bool conversion ambiguity of int as dimension | *Overload 6:* int version due to the implicit bool conversion ambiguity of int as dimension | *Overload 7:* int version due to the implicit bool conversion ambiguity of int as dimension N)rÚIndexShards_swiginitÚnew_IndexShardsrprrrrHÑ"óBzIndexShards.__init__cCrN©z Alias for addIndex())rÚIndexShards_add_shardr£ rrrÚ add_shard#r zIndexShards.add_shardcCrN©z Alias for removeIndex())rÚIndexShards_remove_shardr£ rrrÚ remove_shard#r zIndexShards.remove_shardcCr‹©z; supported only for sub-indices that implement add_with_ids)rÚIndexShards_addr“rrrr—#rózIndexShards.addcCr‡©a> Cases (successive_ids, xids): - true, non-NULL ERROR: it makes no sense to pass in ids and request them to be shifted - true, NULL OK: but should be called only once (calls add() on sub-indexes). - false, non-NULL OK: will call add_with_ids with passed in xids distributed evenly over shards - false, NULL OK: will call add_with_ids on each sub-index, starting at ntotal )rÚIndexShards_add_with_idsr›rrrr!#r¸zIndexShards.add_with_idsNc CrÈr')rÚIndexShards_searchr rrrr¢/#r.zIndexShards.searchcCr‹r')rÚIndexShards_trainr“rrrr”2#rzIndexShards.traincCrJ©zd Synchronize the top-level index (IndexShards) with data in the sub-indices )rÚIndexShards_syncWithSubIndexesrLrrrÚsyncWithSubIndexes6#r†zIndexShards.syncWithSubIndexesr')rrr1r2rrrr rHr‰rŒr—rr¢r”rÚIndexShards_successive_ids_getÚIndexShards_successive_ids_setÚsuccessive_idsr•Údelete_IndexShardsrvrrrrrË"óD  rc@r€)ÚIndexBinaryShardsr‚cCr5r'r6r7rrrr9D#r:zIndexBinaryShards.cCr;r'r6r<rrrr9D#r>r?r@cGr—rƒ)rÚIndexBinaryShards_swiginitÚnew_IndexBinaryShardsrprrrrHG#r†zIndexBinaryShards.__init__cCrNr‡)rÚIndexBinaryShards_add_shardr£ rrrr‰‹#r zIndexBinaryShards.add_shardcCrNrŠ)rÚIndexBinaryShards_remove_shardr£ rrrrŒ#r zIndexBinaryShards.remove_shardcCr‹r)rÚIndexBinaryShards_addr“rrrr—“#rózIndexBinaryShards.addcCr‡r)rÚIndexBinaryShards_add_with_idsr›rrrr—#r¸zIndexBinaryShards.add_with_idsNc CrÈr')rÚIndexBinaryShards_searchr rrrr¢¥#r.zIndexBinaryShards.searchcCr‹r')rÚIndexBinaryShards_trainr“rrrr”¨#rzIndexBinaryShards.traincCrJr“)rÚ$IndexBinaryShards_syncWithSubIndexesrLrrrr•¬#r†z$IndexBinaryShards.syncWithSubIndexesr')rrr1r2rrrr rHr‰rŒr—rr¢r”rÚ$IndexBinaryShards_successive_ids_getÚ$IndexBinaryShards_successive_ids_setr˜r•Údelete_IndexBinaryShardsrvrrrrr›A#ršr›c@s\eZdZdZedd„dd„ddZeZdd d „Zd d „Z d d„Z dd„Z ddd„Z e jZdS)ÚIndexShardsIVFz¡ IndexShards with a common coarse quantizer. All the indexes added should be IndexIVFInterface indexes so that the search_precomputed can be called. cCr5r'r6r7rrrr9½#r:zIndexShardsIVF.cCr;r'r6r<rrrr9½#r>r?r@FTc Crr')rÚIndexShardsIVF_swiginitÚnew_IndexShardsIVF)rrÜ rºÚthreadedr˜rrrrHÀ#rzIndexShardsIVF.__init__cCrNr')rÚIndexShardsIVF_addIndexr£ rrrrdÃ#rSzIndexShardsIVF.addIndexcCr‡r')rÚIndexShardsIVF_add_with_idsr›rrrrÆ#r‰zIndexShardsIVF.add_with_idscCr‹r')rÚIndexShardsIVF_trainr“rrrr”É#rzIndexShardsIVF.trainNc CrÈr')rÚIndexShardsIVF_searchr rrrr¢Ì#r.zIndexShardsIVF.search)FTr')rrr1r2rrrr rHrdrr”r¢rÚdelete_IndexShardsIVFrvrrrrr¨·#s   r¨c@óreZdZdZedd„dd„ddZeZdd„Zd d „Z d d „Z d d„Z dd„Z ddd„Z dd„Zdd„ZejZdS)Ú IndexReplicasúÏ Takes individual faiss::Index instances, and splits queries for sending to each Index instance, and joins the results together when done. Each index is managed by a separate CPU thread. cCr5r'r6r7rrrr9Û#r:zIndexReplicas.cCr;r'r6r<rrrr9Û#r>r?r@cGr—©aþ *Overload 1:* The dimension that all sub-indices must share will be the dimension of the first sub-index added :type threaded: boolean, optional :param threaded: do we use one thread per sub-index or do queries sequentially? | *Overload 2:* :type d: int :param d: the dimension that all sub-indices must share :type threaded: boolean, optional :param threaded: do we use one thread per sub index or do queries sequentially? | *Overload 3:* :type d: int :param d: the dimension that all sub-indices must share :param threaded: do we use one thread per sub index or do queries sequentially? | *Overload 4:* int version due to the implicit bool conversion ambiguity of int as dimension | *Overload 5:* int version due to the implicit bool conversion ambiguity of int as dimension N)rÚIndexReplicas_swiginitÚnew_IndexReplicasrprrrrHÞ#ó&zIndexReplicas.__init__cCrNr‡)rÚIndexReplicas_add_replicar£ rrrÚ add_replica$r zIndexReplicas.add_replicacCrNrŠ)rÚIndexReplicas_remove_replicar£ rrrÚremove_replica $r zIndexReplicas.remove_replicacCr‹rj)rÚIndexReplicas_trainr“rrrr”$râzIndexReplicas.traincCr‹rj)rÚIndexReplicas_addr“rrrr—$râzIndexReplicas.addNc CrÈ©z— faiss::Index API Query is partitioned into a slice for each sub-index split by ceil(n / #indices) for our sub-indices )rÚIndexReplicas_searchr rrrr¢$rizIndexReplicas.searchcCr‹©z" reconstructs from the first index)rÚIndexReplicas_reconstruct©rrr=rrrr´$$rózIndexReplicas.reconstructcCrJr“)rÚ IndexReplicas_syncWithSubIndexesrLrrrr•($r†z IndexReplicas.syncWithSubIndexesr')rrr1r2rrrr rHr¹r»r”r—r¢r´r•rÚdelete_IndexReplicasrvrrrrr²Ó#ó(  r²c@r±)ÚIndexBinaryReplicasr³cCr5r'r6r7rrrr9;$r:zIndexBinaryReplicas.cCr;r'r6r<rrrr9;$r>r?r@cGr—r´)rÚIndexBinaryReplicas_swiginitÚnew_IndexBinaryReplicasrprrrrH>$r·zIndexBinaryReplicas.__init__cCrNr‡)rÚIndexBinaryReplicas_add_replicar£ rrrr¹f$r zIndexBinaryReplicas.add_replicacCrNrŠ)rÚ"IndexBinaryReplicas_remove_replicar£ rrrr»j$r z"IndexBinaryReplicas.remove_replicacCr‹rj)rÚIndexBinaryReplicas_trainr“rrrr”n$râzIndexBinaryReplicas.traincCr‹rj)rÚIndexBinaryReplicas_addr“rrrr—u$râzIndexBinaryReplicas.addNc CrÈr¾)rÚIndexBinaryReplicas_searchr rrrr¢|$rizIndexBinaryReplicas.searchcCr‹rÀ)rÚIndexBinaryReplicas_reconstructrÂrrrr´„$rózIndexBinaryReplicas.reconstructcCrJr“)rÚ&IndexBinaryReplicas_syncWithSubIndexesrLrrrr•ˆ$r†z&IndexBinaryReplicas.syncWithSubIndexesr')rrr1r2rrrr rHr¹r»r”r—r¢r´r•rÚdelete_IndexBinaryReplicasrvrrrrrÆ3$rÅrÆc@s¤eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejƒZeejejƒZddd „Zd d „Zd d „Zdd„Zddd„Zdd„Zdd„ZejZdS)ÚIndexSplitVectorsz€ splits input vectors in segments and assigns each segment to a sub-index used to distribute a MultiIndexQuantizer cCr5r'r6r7rrrr9™$r:zIndexSplitVectors.cCr;r'r6r<rrrr9™$r>r?r@FcCr@)z sum of dimensions seen so farN)rÚIndexSplitVectors_swiginitÚnew_IndexSplitVectors)rr†r«rrrrH $rWzIndexSplitVectors.__init__cCrNr')rÚIndexSplitVectors_add_sub_indexr~rrrÚ add_sub_index¤$rSzIndexSplitVectors.add_sub_indexcCrJr')rÚ'IndexSplitVectors_sync_with_sub_indexesrLrrrÚsync_with_sub_indexes§$rMz'IndexSplitVectors.sync_with_sub_indexescCr‹r')rÚIndexSplitVectors_addr“rrrr—ª$rzIndexSplitVectors.addNc CrÈr')rÚIndexSplitVectors_searchr rrrr¢­$r.zIndexSplitVectors.searchcCr‹r')rÚIndexSplitVectors_trainr“rrrr”°$rzIndexSplitVectors.traincCrJr')rÚIndexSplitVectors_resetrLrrrr{³$rMzIndexSplitVectors.resetrH r')rrr1r2rrrr rÚ IndexSplitVectors_own_fields_getÚ IndexSplitVectors_own_fields_setr¹ÚIndexSplitVectors_threaded_getÚIndexSplitVectors_threaded_setr«Ú!IndexSplitVectors_sub_indexes_getÚ!IndexSplitVectors_sub_indexes_setÚ sub_indexesÚIndexSplitVectors_sum_d_getÚIndexSplitVectors_sum_d_setÚsum_drHrÕr×r—r¢r”r{Údelete_IndexSplitVectorsrvrrrrrÑ“$s    rÑc@sheZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z d d „Z dd d „Zdd„Zdd„ZejZd S)Ú IndexRandomzQ index that returns random results. used mainly for time benchmarks cCr5r'r6r7rrrr9À$r:zIndexRandom.cCr;r'r6r<rrrr9À$r>r?r@cGr$r')rÚIndexRandom_swiginitÚnew_IndexRandomrprrrrHÄ$r.zIndexRandom.__init__cCr‹r')rÚIndexRandom_addr“rrrr—Ç$rzIndexRandom.addNc CrÈr')rÚIndexRandom_searchr rrrr¢Ê$r.zIndexRandom.searchcCr‹r')rÚIndexRandom_reconstructr±rrrr´Í$rzIndexRandom.reconstructcCrJr')rÚIndexRandom_resetrLrrrr{Ð$rMzIndexRandom.resetr')rrr1r2rrrr rÚIndexRandom_seed_getÚIndexRandom_seed_setrrHr—r¢r´r{Údelete_IndexRandomrvrrrrrçº$s  rçc@ó¸eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ddZeejejddZd d „Zd d „Zddd„Zdd„Zdd„Zdd„Zddd„Zd dd„Zdd„ZejZdd„Zd S)!Ú IndexIDMapú, Index that translates search results to idscCr5r'r6r7rrrr9Ú$r:zIndexIDMap.cCr;r'r6r<rrrr9Ú$r>r?r@r–ú)whether pointers are deleted in destructocCr‡©zi :type xids: int :param xids: if non-null, ids to store for the vectors (size n) )rÚIndexIDMap_add_with_idsr›rrrrà$rùzIndexIDMap.add_with_idscCr‹©z! this will fail. Use add_with_ids)rÚIndexIDMap_addr“rrrr—ç$rózIndexIDMap.addNc CrÈr')rÚIndexIDMap_searchr rrrr¢ë$r.zIndexIDMap.searchcCr‹r')rÚIndexIDMap_trainr“rrrr”î$rzIndexIDMap.traincCrJr')rÚIndexIDMap_resetrLrrrr{ñ$rMzIndexIDMap.resetcCrN©z remove ids adapted to IndexFlat)rÚIndexIDMap_remove_idsr­rrrr®ô$r zIndexIDMap.remove_idscCrŽr')rÚIndexIDMap_range_searchr¥rrrr¦ø$r|zIndexIDMap.range_searchrcCr‹r')rÚIndexIDMap_merge_fromr×rrrrÚû$rzIndexIDMap.merge_fromcCrNr')rÚ%IndexIDMap_check_compatible_for_mergerÞrrrrßþ$rSz%IndexIDMap.check_compatible_for_mergecGr$r')rÚIndexIDMap_swiginitÚnew_IndexIDMaprprrrrH%r.zIndexIDMap.__init__r'rá)rrr1r2rrrr rÚIndexIDMap_index_getÚIndexIDMap_index_setr€ÚIndexIDMap_own_fields_getÚIndexIDMap_own_fields_setr¹ÚIndexIDMap_id_map_getÚIndexIDMap_id_map_setÚid_maprr—r¢r”r{r®r¦rÚrßÚdelete_IndexIDMaprvrHrrrrrò×$ó$    ròc@rñ)!ÚIndexBinaryIDMaprócCr5r'r6r7rrrr9 %r:zIndexBinaryIDMap.cCr;r'r6r<rrrr9 %r>r?r@r–rôcCr‡rõ)rÚIndexBinaryIDMap_add_with_idsr›rrrr%rùzIndexBinaryIDMap.add_with_idscCr‹r÷)rÚIndexBinaryIDMap_addr“rrrr—%rózIndexBinaryIDMap.addNc CrÈr')rÚIndexBinaryIDMap_searchr rrrr¢%r.zIndexBinaryIDMap.searchcCr‹r')rÚIndexBinaryIDMap_trainr“rrrr”%rzIndexBinaryIDMap.traincCrJr')rÚIndexBinaryIDMap_resetrLrrrr{"%rMzIndexBinaryIDMap.resetcCrNrü)rÚIndexBinaryIDMap_remove_idsr­rrrr®%%r zIndexBinaryIDMap.remove_idscCrŽr')rÚIndexBinaryIDMap_range_searchr¥rrrr¦)%r|zIndexBinaryIDMap.range_searchrcCr‹r')rÚIndexBinaryIDMap_merge_fromr×rrrrÚ,%rzIndexBinaryIDMap.merge_fromcCrNr')rÚ+IndexBinaryIDMap_check_compatible_for_mergerÞrrrrß/%rSz+IndexBinaryIDMap.check_compatible_for_mergecGr$r')rÚIndexBinaryIDMap_swiginitÚnew_IndexBinaryIDMaprprrrrH3%r.zIndexBinaryIDMap.__init__r'rá)rrr1r2rrrr rÚIndexBinaryIDMap_index_getÚIndexBinaryIDMap_index_setr€ÚIndexBinaryIDMap_own_fields_getÚIndexBinaryIDMap_own_fields_setr¹ÚIndexBinaryIDMap_id_map_getÚIndexBinaryIDMap_id_map_setr rr—r¢r”r{r®r¦rÚrßÚdelete_IndexBinaryIDMaprvrHrrrrr %r r c@óxeZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z d d „Z d d „Zd d„Zdd„Zddd„ZejZdd„ZdS)Ú IndexIDMap2úo same as IndexIDMap but also provides an efficient reconstruction implementation via a 2-way index cCr5r'r6r7rrrr9?%r:zIndexIDMap2.cCr;r'r6r<rrrr9?%r>r?r@cCrJ©z make the rev_map from scratch)rÚIndexIDMap2_construct_rev_maprLrrrÚconstruct_rev_mapC%r`zIndexIDMap2.construct_rev_mapcCr‡r')rÚIndexIDMap2_add_with_idsr›rrrrG%r‰zIndexIDMap2.add_with_idscCrNr')rÚIndexIDMap2_remove_idsr­rrrr®J%rSzIndexIDMap2.remove_idscCr‹r')rÚIndexIDMap2_reconstructr±rrrr´M%rzIndexIDMap2.reconstructcCrJ©z2 check that the rev_map and the id_map are in sync)rÚIndexIDMap2_check_consistencyrLrrrÚcheck_consistencyP%r`zIndexIDMap2.check_consistencyrcCr‹r')rÚIndexIDMap2_merge_fromr×rrrrÚT%rzIndexIDMap2.merge_fromcGr$r')rÚIndexIDMap2_swiginitÚnew_IndexIDMap2rprrrrHX%r.zIndexIDMap2.__init__Nrá)rrr1r2rrrr rÚIndexIDMap2_rev_map_getÚIndexIDMap2_rev_map_setÚrev_mapr$rr®r´r*rÚÚdelete_IndexIDMap2rvrHrrrrr 9%ó  r c@r)ÚIndexBinaryIDMap2r!cCr5r'r6r7rrrr9d%r:zIndexBinaryIDMap2.cCr;r'r6r<rrrr9d%r>r?r@cCrJr")rÚ#IndexBinaryIDMap2_construct_rev_maprLrrrr$h%r`z#IndexBinaryIDMap2.construct_rev_mapcCr‡r')rÚIndexBinaryIDMap2_add_with_idsr›rrrrl%r‰zIndexBinaryIDMap2.add_with_idscCrNr')rÚIndexBinaryIDMap2_remove_idsr­rrrr®o%rSzIndexBinaryIDMap2.remove_idscCr‹r')rÚIndexBinaryIDMap2_reconstructr±rrrr´r%rzIndexBinaryIDMap2.reconstructcCrJr()rÚ#IndexBinaryIDMap2_check_consistencyrLrrrr*u%r`z#IndexBinaryIDMap2.check_consistencyrcCr‹r')rÚIndexBinaryIDMap2_merge_fromr×rrrrÚy%rzIndexBinaryIDMap2.merge_fromcGr$r')rÚIndexBinaryIDMap2_swiginitÚnew_IndexBinaryIDMap2rprrrrH}%r.zIndexBinaryIDMap2.__init__Nrá)rrr1r2rrrr rÚIndexBinaryIDMap2_rev_map_getÚIndexBinaryIDMap2_rev_map_setr0r$rr®r´r*rÚÚdelete_IndexBinaryIDMap2rvrHrrrrr3^%r2r3c@s~eZdZdZedd„dd„ddZdd„ZeZee j e j d dZ ee j e jd dZe jZd d „Zddd„Zdd„Zdd„Zd S)ÚIndexRowwiseMinMaxBaseaç Index wrapper that performs rowwise normalization to [0,1], preserving the coefficients. This is a vector codec index only. Basically, this index performs a rowwise scaling to [0,1] of every row in an input dataset before calling subindex::train() and subindex::sa_encode(). sa_encode() call stores the scaling coefficients (scaler and minv) in the very beginning of every output code. The format: [scaler][minv][subindex::sa_encode() output] The de-scaling in sa_decode() is done using: output_rescaled = scaler * output + minv An additional ::train_inplace() function is provided in order to do an inplace scaling before calling subindex::train() and, thus, avoiding the cloning of the input dataset, but modifying the input dataset because of the scaling and the scaling back. It is up to user to call this function instead of ::train() Derived classes provide different data types for scaling coefficients. Currently, versions with fp16 and fp32 scaling coefficients are available. fp16 version adds 4 extra bytes per encoded vector fp32 version adds 8 extra bytes per encoded vector Provides base functions for rowwise normalizing indices. cCr5r'r6r7rrrr9%r:zIndexRowwiseMinMaxBase.cCr;r'r6r<rrrr9%r>r?r@cOrBrCrDrErrrrHŸ%rIzIndexRowwiseMinMaxBase.__init__z sub-indexz: whether the subindex needs to be freed in the destructor.cCr‹r')rÚIndexRowwiseMinMaxBase_addr“rrrr—¦%rzIndexRowwiseMinMaxBase.addNc CrÈr')rÚIndexRowwiseMinMaxBase_searchr rrrr¢©%r.zIndexRowwiseMinMaxBase.searchcCrJr')rÚIndexRowwiseMinMaxBase_resetrLrrrr{¬%rMzIndexRowwiseMinMaxBase.resetcCr‹r')rÚ$IndexRowwiseMinMaxBase_train_inplacer“rrrÚ train_inplace¯%rz$IndexRowwiseMinMaxBase.train_inplacer')rrr1r2rrrHrr rÚ IndexRowwiseMinMaxBase_index_getÚ IndexRowwiseMinMaxBase_index_setr€Ú%IndexRowwiseMinMaxBase_own_fields_getÚ%IndexRowwiseMinMaxBase_own_fields_setr¹Údelete_IndexRowwiseMinMaxBaservr—r¢r{rDrrrrr?ƒ%s  r?c@ó`eZdZdZedd„dd„ddZeZdd„Zd d „Z d d „Z d d„Z dd„Z dd„Z ejZdS)ÚIndexRowwiseMinMaxFP16z, Stores scaling coefficients as fp16 values.cCr5r'r6r7rrrr9¸%r:zIndexRowwiseMinMaxFP16.cCr;r'r6r<rrrr9¸%r>r?r@cGr$r')rÚIndexRowwiseMinMaxFP16_swiginitÚnew_IndexRowwiseMinMaxFP16rprrrrH»%r.zIndexRowwiseMinMaxFP16.__init__cCr‹r')rÚIndexRowwiseMinMaxFP16_trainr“rrrr”¾%rzIndexRowwiseMinMaxFP16.traincCr‹r')rÚ$IndexRowwiseMinMaxFP16_train_inplacer“rrrrDÁ%rz$IndexRowwiseMinMaxFP16.train_inplacecCrJr')rÚ#IndexRowwiseMinMaxFP16_sa_code_sizerLrrrrÍÄ%rMz#IndexRowwiseMinMaxFP16.sa_code_sizecCr‡r')rÚ IndexRowwiseMinMaxFP16_sa_encoderÏrrrrÐÇ%r‰z IndexRowwiseMinMaxFP16.sa_encodecCr‡r')rÚ IndexRowwiseMinMaxFP16_sa_decoderÓrrrrÔÊ%r‰z IndexRowwiseMinMaxFP16.sa_decodeN)rrr1r2rrrr rHr”rDrÍrÐrÔrÚdelete_IndexRowwiseMinMaxFP16rvrrrrrKµ%ó rKc@rJ)ÚIndexRowwiseMinMaxz, Stores scaling coefficients as fp32 values.cCr5r'r6r7rrrr9Ô%r:zIndexRowwiseMinMax.cCr;r'r6r<rrrr9Ô%r>r?r@cGr$r')rÚIndexRowwiseMinMax_swiginitÚnew_IndexRowwiseMinMaxrprrrrH×%r.zIndexRowwiseMinMax.__init__cCr‹r')rÚIndexRowwiseMinMax_trainr“rrrr”Ú%rzIndexRowwiseMinMax.traincCr‹r')rÚ IndexRowwiseMinMax_train_inplacer“rrrrDÝ%rz IndexRowwiseMinMax.train_inplacecCrJr')rÚIndexRowwiseMinMax_sa_code_sizerLrrrrÍà%rMzIndexRowwiseMinMax.sa_code_sizecCr‡r')rÚIndexRowwiseMinMax_sa_encoderÏrrrrÐã%r‰zIndexRowwiseMinMax.sa_encodecCr‡r')rÚIndexRowwiseMinMax_sa_decoderÓrrrrÔæ%r‰zIndexRowwiseMinMax.sa_decodeN)rrr1r2rrrr rHr”rDrÍrÐrÔrÚdelete_IndexRowwiseMinMaxrvrrrrrUÑ%rTrUc@sœeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZdd d„Zdd„ZejZdS)ÚRangeSearchResulta  The objective is to have a simple result structure while minimizing the number of mem copies in the result. The method do_allocation can be overloaded to allocate the result tables in the matrix type of a scripting language like Lua or Python. cCr5r'r6r7rrrr9õ%r:zRangeSearchResult.cCr;r'r6r<rrrr9õ%r>r?r@z nb of queriesz size (nq + 1)z0 result for query i is labels[lims[i]:lims[i+1]]z% corresponding distances (not sorted)z size of the result buffers usedTcCr@)z1 lims must be allocated on input to range_search.N)rÚRangeSearchResult_swiginitÚnew_RangeSearchResult)rr#Ú alloc_limsrrrrHý%rWzRangeSearchResult.__init__cCrJ)zd called when lims contains the nb of elements result entries for each query )rÚRangeSearchResult_do_allocationrLrrrÚ do_allocation&r†zRangeSearchResult.do_allocationNr>)rrr1r2rrrr rÚRangeSearchResult_nq_getÚRangeSearchResult_nq_setr#ÚRangeSearchResult_lims_getÚRangeSearchResult_lims_setr€ÚRangeSearchResult_labels_getÚRangeSearchResult_labels_setrÇÚRangeSearchResult_distances_getÚRangeSearchResult_distances_setrÆÚ!RangeSearchResult_buffer_size_getÚ!RangeSearchResult_buffer_size_setÚ buffer_sizerHrcÚdelete_RangeSearchResultrvrrrrr^í%s  r^c@s~eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejddZdd „ZejZd d „Zd d „Zdd„ZdS)Ú BufferListzu List of temporary buffers used to store results before they are copied to the RangeSearchResult object. cCr5r'r6r7rrrr9&r:zBufferList.cCr;r'r6r<rrrr9&r>r?r@z" write pointer in the last buffer.cCrhr')rÚBufferList_swiginitÚnew_BufferList)rrnrrrrH&r.zBufferList.__init__cCrJ)z create a new buffer)rÚBufferList_append_bufferrLrrrÚ append_buffer&r`zBufferList.append_buffercCr‹)z: add one result, possibly appending a new buffer if needed)rÚBufferList_add)rrÄrºrrrr— &rózBufferList.addcCrm)zr copy elemnts ofs:ofs+n-1 seen as linear data in the buffers to tables dest_ids, dest_dis )rÚBufferList_copy_range)rrsrQÚdest_idsÚdest_disrrrÚ copy_range$&r¿zBufferList.copy_rangeN)rrr1r2rrrr rÚBufferList_buffer_size_getÚBufferList_buffer_size_setrnÚBufferList_buffers_getÚBufferList_buffers_setÚbuffersÚBufferList_wp_getÚBufferList_wp_setÚwprHÚdelete_BufferListrvrtr—ryrrrrrp &s rpc@r±) ÚRangeQueryResultz$ result structure for a single querycCr5r'r6r7rrrr91&r:zRangeQueryResult.cCr;r'r6r<rrrr91&r>r?r@cCr‹)z1 called by search function to report a new result)rÚRangeQueryResult_add)rrºrÄrrrr—7&rózRangeQueryResult.addcCryr')rÚRangeQueryResult_swiginitÚnew_RangeQueryResultrLrrrrH;&r|zRangeQueryResult.__init__N)rrr1r2rrrr rÚRangeQueryResult_qno_getÚRangeQueryResult_qno_setÚqnoÚRangeQueryResult_nres_getÚRangeQueryResult_nres_setÚnresÚRangeQueryResult_pres_getÚRangeQueryResult_pres_setÚpresr—rHÚdelete_RangeQueryResultrvrrrrrƒ.&s rƒc@sˆeZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z eej ejd dZd d „Zd d „Zdd„Zddd„Zeddd„ƒZejZdS)ÚRangeSearchPartialResultz/ the entries in the buffers are split per querycCr5r'r6r7rrrr9E&r:z!RangeSearchPartialResult.cCr;r'r6r<rrrr9E&r>r?r@cCr  )z/ eventually the result will be stored in res_inN)rÚ!RangeSearchPartialResult_swiginitÚnew_RangeSearchPartialResult)rÚres_inrrrrHI&rÌz!RangeSearchPartialResult.__init__z% query ids + nb of results per query.cCrN)z begin a new result)rÚ#RangeSearchPartialResult_new_result)rr‰rrrÚ new_resultN&r z#RangeSearchPartialResult.new_resultcCrJr')rÚ!RangeSearchPartialResult_finalizerLrrrÚfinalizeR&rMz!RangeSearchPartialResult.finalizecCrJ)z, called by range_search before do_allocation)rÚ!RangeSearchPartialResult_set_limsrLrrrÚset_limsU&r`z!RangeSearchPartialResult.set_limsFcCrN)z+ called by range_search after do_allocation)rÚ$RangeSearchPartialResult_copy_result)rÚ incrementalrrrÚ copy_resultY&r z$RangeSearchPartialResult.copy_resultTcCrN)z{ merge a set of PartialResult's into one RangeSearchResult on ouptut the partialresults are empty! ©rÚRangeSearchPartialResult_merge©Úpartial_resultsÚ do_deleterrrÚmerge]&ràzRangeSearchPartialResult.mergeNrH r>)rrr1r2rrrr rÚ RangeSearchPartialResult_res_getÚ RangeSearchPartialResult_res_setrðrHÚ$RangeSearchPartialResult_queries_getÚ$RangeSearchPartialResult_queries_setÚqueriesr–r˜ršrr5r£Údelete_RangeSearchPartialResultrvrrrrr‘B&s   r‘cCrN)zo merge a set of PartialResult's into one RangeSearchResult on ouptut the partialresults are empty! ržr rrrrŸi&r¯rŸc@sleZdZedd„dd„ddZdd„ZeZdd „Ze j Z e d d „ƒZ e d d „ƒZe dd„ƒZe dd„ƒZdS)ÚInterruptCallbackcCr5r'r6r7rrrr9q&r:zInterruptCallback.cCr;r'r6r<rrrr9q&r>r?r@cOrBrCrDrErrrrHs&rIzInterruptCallback.__init__cCrJr')rÚ InterruptCallback_want_interruptrLrrrÚwant_interruptw&rMz InterruptCallback.want_interruptcCrÜr'©rÚ InterruptCallback_clear_instancerrrrÚclear_instance{&râz InterruptCallback.clear_instancecCrÜ)zÑ check if: - an interrupt callback is set - the callback returns true if this is the case, then throw an exception. Should not be called from multiple threads. ©rÚInterruptCallback_checkrrrrÚcheck&s zInterruptCallback.checkcCrÜ)z… same as check() but return true if is interrupted instead of throwing. Can be called from multiple threads. ©rÚ InterruptCallback_is_interruptedrrrrÚis_interruptedŠ&sz InterruptCallback.is_interruptedcCrJ)zŠ assuming each iteration takes a certain number of flops, what is a reasonable interval to check for interrupts? ©rÚ!InterruptCallback_get_period_hint©ÚflopsrrrÚget_period_hint’&r÷z!InterruptCallback.get_period_hintN)rrr1rrrHrr r¬rÚdelete_InterruptCallbackrvr5r¯r²rµrºrrrrrªp&s   rªcCrÜr'r­rrrrr®&rIr®cCrÜ)z¹ check if: - an interrupt callback is set - the callback returns true if this is the case, then throw an exception. Should not be called from multiple threads. r°rrrrr± &sr±cCrÜ)zy same as check() but return true if is interrupted instead of throwing. Can be called from multiple threads. r³rrrrr´ª&sr´cCrJ)z~ assuming each iteration takes a certain number of flops, what is a reasonable interval to check for interrupts? r¶r¸rrrr·±&r†r·c@sleZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZdd„Zd d „Zd d „Zd d„ZejZdS)Ú VisitedTablez. set implementation optimized for fast access.cCr5r'r6r7rrrr9»&r:zVisitedTable.cCr;r'r6r<rrrr9»&r>r?r@cCrhr')rÚVisitedTable_swiginitÚnew_VisitedTabler rrrrHÀ&r.zVisitedTable.__init__cCrN)z set flag #no to true)rÚVisitedTable_set©rrŸ rrrr!Ã&r zVisitedTable.setcCrN)z get flag #no)rÚVisitedTable_getrÀrrrrsÇ&r zVisitedTable.getcCrJ)z reset all flags to false)rÚVisitedTable_advancerLrrrrcË&r`zVisitedTable.advanceN)rrr1r2rrrr rÚVisitedTable_visited_getÚVisitedTable_visited_setÚvisitedÚVisitedTable_visno_getÚVisitedTable_visno_setÚvisnorHr!rsrcÚdelete_VisitedTablervrrrrr¼¸&s r¼c@s@eZdZdZedd„dd„ddZdd„ZeZd d „Z e j Z d S) Ú IDSelectorz% Encapsulates a set of ids to handle.cCr5r'r6r7rrrr9Ö&r:zIDSelector.cCr;r'r6r<rrrr9Ö&r>r?r@cOrBrCrDrErrrrHØ&rIzIDSelector.__init__cCrNr')rÚIDSelector_is_memberr rrrÚ is_memberÜ&rSzIDSelector.is_memberN) rrr1r2rrrHrr rÌrÚdelete_IDSelectorrvrrrrrÊÓ&s rÊc@sxeZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZeejejddZdd d „Zd d „Zd d„ZejZdS)ÚIDSelectorRangez ids between [imin, imax)cCr5r'r6r7rrrr9æ&r:zIDSelectorRange.cCr;r'r6r<rrrr9æ&r>r?r@zb Assume that the ids to handle are sorted. In some cases this can speed up processing FcCr+r')rÚIDSelectorRange_swiginitÚnew_IDSelectorRange)rÚiminÚimaxÚ assume_sortedrrrrHï&r/zIDSelectorRange.__init__cCrNr')rÚIDSelectorRange_is_memberr rrrrÌò&rSzIDSelectorRange.is_membercCrm)zg for sorted ids, find the range of list indices where the valid ids are stored )rÚ&IDSelectorRange_find_sorted_ids_bounds)rr¥rAÚjminÚjmaxrrrÚfind_sorted_ids_boundsõ&r¿z&IDSelectorRange.find_sorted_ids_boundsNrH )rrr1r2rrrr rÚIDSelectorRange_imin_getÚIDSelectorRange_imin_setrÑÚIDSelectorRange_imax_getÚIDSelectorRange_imax_setrÒÚ!IDSelectorRange_assume_sorted_getÚ!IDSelectorRange_assume_sorted_setrÓrHrÌrØÚdelete_IDSelectorRangervrrrrrÎã&s  rÎc@ó\eZdZdZedd„dd„ddZeZeej ej ƒZ eej ej ƒZdd„Zd d „ZejZd S) ÚIDSelectorArrayz€ Simple array of elements is_member calls are very inefficient, but some operations can use the ids directly. cCr5r'r6r7rrrr9'r:zIDSelectorArray.cCr;r'r6r<rrrr9'r>r?r@cCr@)a Construct with an array of ids to process :type n: int :param n: number of ids to store :type ids: int :param ids: elements to store. The pointer should remain valid during IDSelectorArray's lifetime N)rÚIDSelectorArray_swiginitÚnew_IDSelectorArray)rrQrArrrrH 'ó zIDSelectorArray.__init__cCrNr')rÚIDSelectorArray_is_memberr rrrrÌ'rSzIDSelectorArray.is_memberN)rrr1r2rrrr rÚIDSelectorArray_n_getÚIDSelectorArray_n_setrQÚIDSelectorArray_ids_getÚIDSelectorArray_ids_setrArHrÌÚdelete_IDSelectorArrayrvrrrrrá's rác@rà) ÚIDSelectorBatchaŠ Ids from a set. Repetitions of ids in the indices set passed to the constructor does not hurt performance. The hash function used for the bloom filter and GCC's implementation of unordered_set are just the least significant bits of the id. This works fine for random ids or ids in sequences but will produce many hash collisions if lsb's are always the same cCr5r'r6r7rrrr9-'r:zIDSelectorBatch.cCr;r'r6r<rrrr9-'r>r?r@cCr@)zè Construct with an array of ids to process :type n: int :param n: number of ids to store :param ids: elements to store. The pointer can be released after construction N)rÚIDSelectorBatch_swiginitÚnew_IDSelectorBatch)rrQrv rrrrH2's zIDSelectorBatch.__init__cCrNr')rÚIDSelectorBatch_is_memberr rrrrÌ='rSzIDSelectorBatch.is_memberN)rrr1r2rrrr rÚIDSelectorBatch_nbits_getÚIDSelectorBatch_nbits_setrÚIDSelectorBatch_mask_getÚIDSelectorBatch_mask_setrVrHrÌÚdelete_IDSelectorBatchrvrrrrrë 's  rëc@rà) ÚIDSelectorBitmapzB One bit per element. Constructed with a bitmap, size ceil(n / 8).cCr5r'r6r7rrrr9G'r:zIDSelectorBitmap.cCr;r'r6r<rrrr9G'r>r?r@cCr@)a Construct with a binary mask :type n: int :param n: size of the bitmap array :type bitmap: uint8_t :param bitmap: id will be selected iff id / 8 < n and bit number (i%8) of bitmap[floor(i / 8)] is 1. N)rÚIDSelectorBitmap_swiginitÚnew_IDSelectorBitmap)rrQÚbitmaprrrrHL'räzIDSelectorBitmap.__init__cCrNr')rÚIDSelectorBitmap_is_memberr rrrrÌX'rSzIDSelectorBitmap.is_memberN)rrr1r2rrrr rÚIDSelectorBitmap_n_getÚIDSelectorBitmap_n_setrQÚIDSelectorBitmap_bitmap_getÚIDSelectorBitmap_bitmap_setr÷rHrÌÚdelete_IDSelectorBitmaprvrrrrrôD's rôc@sNeZdZdZedd„dd„ddZeZeej ej ƒZ dd„Z d d „Z ejZd S) Ú IDSelectorNotz0 reverts the membership test of another selectorcCr5r'r6r7rrrr9b'r:zIDSelectorNot.cCr;r'r6r<rrrr9b'r>r?r@cCrhr')rÚIDSelectorNot_swiginitÚnew_IDSelectorNotr­rrrrHf'r.zIDSelectorNot.__init__cCrNr')rÚIDSelectorNot_is_memberr rrrrÌi'rSzIDSelectorNot.is_memberN)rrr1r2rrrr rÚIDSelectorNot_sel_getÚIDSelectorNot_sel_setrUrHrÌÚdelete_IDSelectorNotrvrrrrrþ_'s rþc@r¤) Ú IDSelectorAllz. selects all entries (useful for benchmarking)cCr5r'r6r7rrrr9s'r:zIDSelectorAll.cCr;r'r6r<rrrr9s'r>r?r@cCrNr')rÚIDSelectorAll_is_memberr rrrrÌv'rSzIDSelectorAll.is_membercCryr')rÚIDSelectorAll_swiginitÚnew_IDSelectorAllrLrrrrHz'r|zIDSelectorAll.__init__N) rrr1r2rrrr rÌrÚdelete_IDSelectorAllrvrHrrrrrp's rc@rà) Ú IDSelectorAndz\ does an AND operation on the the two given IDSelector's is_membership results. cCr5r'r6r7rrrr9†'r:zIDSelectorAnd.cCr;r'r6r<rrrr9†'r>r?r@cCr—r')rÚIDSelectorAnd_swiginitÚnew_IDSelectorAnd©rÚlhsÚrhsrrrrH‹'rzIDSelectorAnd.__init__cCrNr')rÚIDSelectorAnd_is_memberr rrrrÌŽ'rSzIDSelectorAnd.is_memberN)rrr1r2rrrr rÚIDSelectorAnd_lhs_getÚIDSelectorAnd_lhs_setrÚIDSelectorAnd_rhs_getÚIDSelectorAnd_rhs_setrrHrÌÚdelete_IDSelectorAndrvrrrrr €'ó r c@rà) Ú IDSelectorOrz[ does an OR operation on the the two given IDSelector's is_membership results. cCr5r'r6r7rrrr9›'r:zIDSelectorOr.cCr;r'r6r<rrrr9›'r>r?r@cCr—r')rÚIDSelectorOr_swiginitÚnew_IDSelectorOrr rrrrH 'rzIDSelectorOr.__init__cCrNr')rÚIDSelectorOr_is_memberr rrrrÌ£'rSzIDSelectorOr.is_memberN)rrr1r2rrrr rÚIDSelectorOr_lhs_getÚIDSelectorOr_lhs_setrÚIDSelectorOr_rhs_getÚIDSelectorOr_rhs_setrrHrÌÚdelete_IDSelectorOrrvrrrrr•'rrc@rà) Ú IDSelectorXOrz\ does an XOR operation on the the two given IDSelector's is_membership results. cCr5r'r6r7rrrr9°'r:zIDSelectorXOr.cCr;r'r6r<rrrr9°'r>r?r@cCr—r')rÚIDSelectorXOr_swiginitÚnew_IDSelectorXOrr rrrrHµ'rzIDSelectorXOr.__init__cCrNr')rÚIDSelectorXOr_is_memberr rrrr̸'rSzIDSelectorXOr.is_memberN)rrr1r2rrrr rÚIDSelectorXOr_lhs_getÚIDSelectorXOr_lhs_setrÚIDSelectorXOr_rhs_getÚIDSelectorXOr_rhs_setrrHrÌÚdelete_IDSelectorXOrrvrrrrr ª'rr cCrJr')rÚdowncast_index©r€rrrr)Å'rMr)cCrJr')rÚdowncast_VectorTransform)ràrrrr+È'rMr+cCrJr')rÚdowncast_IndexBinaryr*rrrr,Ë'rMr,cCrJr')rÚdowncast_InvertedLists)r rrrr-Î'rMr-cCrJr')rÚdowncast_AdditiveQuantizer©rÞrrrr.Ñ'rMr.cCrJr')rÚdowncast_Quantizerr/rrrr0Ô'rMr0cGr¼r')rÚ write_indexr¾rrrr1×'rMr1cGr¼r')rÚwrite_index_binaryr¾rrrr2Ú'rMr2cGr¼r')rÚ read_indexr¾rrrr3Ý'rMr3cGr¼r')rÚread_index_binaryr¾rrrr4à'rMr4cGr¼r')rÚwrite_VectorTransformr¾rrrr5ã'rMr5cGr¼r')rÚread_VectorTransformr¾rrrr6æ'rMr6cGr¼r')rÚread_ProductQuantizerr¾rrrr7é'rMr7cGr¼r')rÚwrite_ProductQuantizerr¾rrrr8ì'rMr8cCrNr')rÚwrite_InvertedLists)r rVrrrr9ï'rSr9cCrNr')rÚread_InvertedLists)rmr_ rrrr:ò'rSr:cCrJr')rÚ clone_indexre rrrr;õ'rMr;c@sPeZdZdZedd„dd„ddZeZdd„Zd d „Z d d „Z e j Z d d„ZdS)ÚClonerz” Cloner class, useful to override classes with other cloning functions. The cloning function above just calls Cloner::clone_Index. cCr5r'r6r7rrrr9þ'r:zCloner.cCr;r'r6r<rrrr9þ'r>r?r@cCrNr')rÚCloner_clone_VectorTransformr~rrrÚclone_VectorTransform(rSzCloner.clone_VectorTransformcCrNr')rÚCloner_clone_Indexr~rrrÚ clone_Index(rSzCloner.clone_IndexcCrNr')rÚCloner_clone_IndexIVFr~rrrÚclone_IndexIVF(rSzCloner.clone_IndexIVFcCryr')rÚCloner_swiginitÚ new_ClonerrLrrrrH (r|zCloner.__init__N)rrr1r2rrrr r>r@rBrÚ delete_ClonerrvrHrrrrr<÷'s r<cCrJr')rÚclone_Quantizer)ÚquantrrrrF(rMrFc@s¢eZdZdZedd„dd„ddZdd„ZeZee j e j d dZ ee j e jd dZee je jd dZee je jd dZee je jd dZdd„Zdd„Ze jZdS)ÚAutoTuneCriterionz] Evaluation criterion. Returns a performance measure in [0,1], higher is better. cCr5r'r6r7rrrr9(r:zAutoTuneCriterion.cCr;r'r6r<rrrr9(r>r?r@cOrBrCrDrErrrrH!(rIzAutoTuneCriterion.__init__z- nb of queries this criterion is evaluated onz( nb of NNs that the query should requestz, nb of GT NNs required to evaluate criterionz* Ground-truth distances (size nq * gt_nnn)z( Ground-truth indexes (size nq * gt_nnn)cCr‡)zè Intitializes the gt_D and gt_I vectors. Must be called before evaluating :type gt_D_in: float :param gt_D_in: size nq * gt_nnn :type gt_I_in: int :param gt_I_in: size nq * gt_nnn )rÚ!AutoTuneCriterion_set_groundtruth)rÚgt_nnnÚgt_D_inÚgt_I_inrrrÚset_groundtruth*(rz!AutoTuneCriterion.set_groundtruthcCr‹)zò Evaluate the criterion. :type D: float :param D: size nq * nnn :type I: int :param I: size nq * nnn :rtype: float :return: the criterion, between 0 and 1. Larger is better. )rÚAutoTuneCriterion_evaluate©rr‰ rˆ rrrr<5(rzAutoTuneCriterion.evaluateN)rrr1r2rrrHrr rÚAutoTuneCriterion_nq_getÚAutoTuneCriterion_nq_setr#ÚAutoTuneCriterion_nnn_getÚAutoTuneCriterion_nnn_setÚnnnÚAutoTuneCriterion_gt_nnn_getÚAutoTuneCriterion_gt_nnn_setrJÚAutoTuneCriterion_gt_D_getÚAutoTuneCriterion_gt_D_setÚgt_DÚAutoTuneCriterion_gt_I_getÚAutoTuneCriterion_gt_I_setÚgt_IrMr<Údelete_AutoTuneCriterionrvrrrrrH(s rHc@r;) ÚOneRecallAtRCriterioncCr5r'r6r7rrrr9G(r:zOneRecallAtRCriterion.cCr;r'r6r<rrrr9G(r>r?r@cCr—r')rÚOneRecallAtRCriterion_swiginitÚnew_OneRecallAtRCriterion©rr#r’ rrrrHK(rzOneRecallAtRCriterion.__init__cCr‹r')rÚOneRecallAtRCriterion_evaluaterOrrrr<N(rzOneRecallAtRCriterion.evaluateN)rrr1rrrr rÚOneRecallAtRCriterion_R_getÚOneRecallAtRCriterion_R_setr’ rHr<Údelete_OneRecallAtRCriterionrvrrrrr^F(rDr^c@r;) ÚIntersectionCriterioncCr5r'r6r7rrrr9V(r:zIntersectionCriterion.cCr;r'r6r<rrrr9V(r>r?r@cCr—r')rÚIntersectionCriterion_swiginitÚnew_IntersectionCriterionrarrrrHZ(rzIntersectionCriterion.__init__cCr‹r')rÚIntersectionCriterion_evaluaterOrrrr<](rzIntersectionCriterion.evaluateN)rrr1rrrr rÚIntersectionCriterion_R_getÚIntersectionCriterion_R_setr’ rHr<Údelete_IntersectionCriterionrvrrrrrfU(rDrfc@s€eZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d „ZejZd S)ÚOperatingPointa< Maintains a list of experimental results. Each operating point is a (perf, t, key) triplet, where higher perf and lower t is better. The key field is an arbitrary identifier for the operating point. Includes primitives to extract the Pareto-optimal operating points in the (perf, t) space. cCr5r'r6r7rrrr9n(r:zOperatingPoint.cCr;r'r6r<rrrr9n(r>r?r@z, performance measure (output of a Criterion)z" corresponding execution time (ms)z key that identifies this op ptz integer identifercCryr')rÚOperatingPoint_swiginitÚnew_OperatingPointrLrrrrHu(r|zOperatingPoint.__init__N)rrr1r2rrrr rÚOperatingPoint_perf_getÚOperatingPoint_perf_setÚperfÚOperatingPoint_t_getÚOperatingPoint_t_setr‚ÚOperatingPoint_key_getÚOperatingPoint_key_setr²ÚOperatingPoint_cno_getÚOperatingPoint_cno_setÚcnorHÚdelete_OperatingPointrvrrrrrmd(s  rmc@s”eZdZedd„dd„ddZeZeejej ddZ eej ej ddZ dd „Zd d „Zd d „Zddd„Zdd„Zddd„Zdd„Zdd„ZejZdS)ÚOperatingPointscCr5r'r6r7rrrr9}(r:zOperatingPoints.cCr;r'r6r<rrrr9}(r>r?r@z all operating pointsz) optimal operating points, sorted by perfcCryr')rÚOperatingPoints_swiginitÚnew_OperatingPointsrLrrrrH‚(r|zOperatingPoints.__init__cGrn)zC add operating points from other to this, with a prefix to the keys)rÚOperatingPoints_merge_withrprrrÚ merge_with…(ruzOperatingPoints.merge_withcCrJr')rÚOperatingPoints_clearrLrrrr‚‰(rMzOperatingPoints.clearrcCrm)zA add a performance measure. Return whether it is an optimal point)rÚOperatingPoints_add)rrrr‚r²ryrrrr—Œ(ruzOperatingPoints.addcCrN)z8 get time required to obtain a given performance measure)rÚOperatingPoints_t_for_perf)rrrrrrÚ t_for_perf(r zOperatingPoints.t_for_perfTcCrN)z easy-to-read output)rÚOperatingPoints_display)rÚ only_optimalrrrr­”(r zOperatingPoints.displaycCrN)z- output to a format easy to digest by gnuplot)rÚOperatingPoints_all_to_gnuplot©rÚfnamerrrÚall_to_gnuplot˜(r zOperatingPoints.all_to_gnuplotcCrNr')rÚ"OperatingPoints_optimal_to_gnuplotr‡rrrÚoptimal_to_gnuplotœ(rSz"OperatingPoints.optimal_to_gnuplotNrár>)rrr1rrrr rÚOperatingPoints_all_pts_getÚOperatingPoints_all_pts_setÚall_ptsÚOperatingPoints_optimal_pts_getÚOperatingPoints_optimal_pts_setÚ optimal_ptsrHrr‚r—rƒr­r‰r‹Údelete_OperatingPointsrvrrrrr{|(s   r{c@r§) ÚParameterRangezM possible values of a parameter, sorted from least to most expensive/accuratecCr5r'r6r7rrrr9¦(r:zParameterRange.cCr;r'r6r<rrrr9¦(r>r?r@cCryr')rÚParameterRange_swiginitÚnew_ParameterRangerLrrrrH«(r|zParameterRange.__init__N)rrr1r2rrrr rÚParameterRange_name_getÚParameterRange_name_setrÚParameterRange_values_getÚParameterRange_values_setÚvaluesrHÚdelete_ParameterRangervrrrrr“£(r°r“c@sôeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZd d„Zdd„Zdd„Zdd„Zdd„Zdd„Z dd„Z!dd„Z"dd„Z#dd „Z$d!d"„Z%ej&Z'd#S)$ÚParameterSpacezL Uses a-priori knowledge on the Faiss indexes to extract tunable parameters.cCr5r'r6r7rrrr9µ(r:zParameterSpace.cCr;r'r6r<rrrr9µ(r>r?r@z all tunable parametersz verbosity during explorationzA nb of experiments during optimization (0 = try all combinations)z/ maximum number of queries to submit at a time.z_ use multithreading over batches (useful to benchmark independent single-searches) zm run tests several times until they reach at least this duration (to avoid jittering in MT mode) cCryr')rÚParameterSpace_swiginitÚnew_ParameterSpacerLrrrrHÄ(r|zParameterSpace.__init__cCrJ)z. nb of combinations, = product of values sizes)rÚParameterSpace_n_combinationsrLrrrÚn_combinationsÇ(r`zParameterSpace.n_combinationscCr‹)z9 returns whether combinations c1 >= c2 in the tuple sense)rÚParameterSpace_combination_ge)rÚc1Úc2rrrÚcombination_geË(rózParameterSpace.combination_gecCrN)z- get string representation of the combination)rÚParameterSpace_combination_name)rryrrrÚcombination_nameÏ(r zParameterSpace.combination_namecCrJ)z print a description on stdout)rÚParameterSpace_displayrLrrrr­Ó(r`zParameterSpace.displaycCrN)z0 add a new parameter (or return it if it exists))rÚParameterSpace_add_ranger|rrrÚ add_range×(r zParameterSpace.add_rangecCrN)z4 initialize with reasonable parameters for the index)rÚParameterSpace_initializer£ rrrÚ initializeÛ(r zParameterSpace.initializecGrn)z³ *Overload 1:* set a combination of parameters on an index | *Overload 2:* set a combination of parameters described by a string )rÚ#ParameterSpace_set_index_parametersrprrrÚset_index_parametersß(rcz#ParameterSpace.set_index_parameterscCr‡)zB set one of the parameters, returns whether setting was successful)rÚ"ParameterSpace_set_index_parameter)rr€rr© rrrÚset_index_parameterë(rz"ParameterSpace.set_index_parametercCrm)z find an upper bound on the performance and a lower bound on t for configuration cno given another operating point op )rÚParameterSpace_update_bounds)rryÚopÚupper_bound_perfÚ lower_bound_trrrÚ update_boundsï(r¿zParameterSpace.update_boundscCrŽ)aŒ explore operating points :type index: :py:class:`Index` :param index: index to run on :type xq: float :param xq: query vectors (size nq * index.d) :type crit: :py:class:`AutoTuneCriterion` :param crit: selection criterion :type ops: :py:class:`OperatingPoints` :param ops: resulting operating points )rÚParameterSpace_explore)rr€r#r$ÚcritÚopsrrrÚexploreö(s zParameterSpace.exploreN)(rrr1r2rrrr rÚ#ParameterSpace_parameter_ranges_getÚ#ParameterSpace_parameter_ranges_setÚparameter_rangesÚParameterSpace_verbose_getÚParameterSpace_verbose_setrÚ ParameterSpace_n_experiments_getÚ ParameterSpace_n_experiments_setÚ n_experimentsÚParameterSpace_batchsize_getÚParameterSpace_batchsize_setÚ batchsizeÚ&ParameterSpace_thread_over_batches_getÚ&ParameterSpace_thread_over_batches_setÚthread_over_batchesÚ$ParameterSpace_min_test_duration_getÚ$ParameterSpace_min_test_duration_setÚmin_test_durationrHr r¤r¦r­r©r«r­r¯r´r¸Údelete_ParameterSpacervrrrrrœ²(s,  rœcGr¼)z\ Build and index with the sequence of processing steps described in the string. )rÚ index_factoryr¾rrrrË )r†rËcCrNr')rÚindex_binary_factory)r†Ú descriptionrrrrÌ)rSrÌc@sèeZdZdZedd„dd„ddZeZdd„Zee j e j ƒZ ee j e jƒZee je jƒZee je jƒZee je jƒZee je jƒZee je jƒZee je j ƒZ!ee j"e j#ƒZ$ee j%e j&ƒZ'ee j(e j)ƒZ*ee j+e j,ƒZ-d d „Z.e j/Z0d S) Ú MatrixStatsz¤ Reports some statistics on a dataset and comments on them. It is a class rather than a function so that all stats can also be accessed from code cCr5r'r6r7rrrr9)r:zMatrixStats.cCr;r'r6r<rrrr9)r>r?r@cCr+r')rÚMatrixStats_swiginitÚnew_MatrixStats)rrQr†r8rrrrH)r/zMatrixStats.__init__cCrNr')rÚMatrixStats_do_comment)rÚfmtrrrÚ do_comment,)rSzMatrixStats.do_commentN)1rrr1r2rrrr rHrÚMatrixStats_comments_getÚMatrixStats_comments_setÚcommentsÚMatrixStats_n_getÚMatrixStats_n_setrQÚMatrixStats_d_getÚMatrixStats_d_setr†ÚMatrixStats_n_collision_getÚMatrixStats_n_collision_setÚ n_collisionÚMatrixStats_n_valid_getÚMatrixStats_n_valid_setÚn_validÚMatrixStats_n0_getÚMatrixStats_n0_setrë ÚMatrixStats_min_norm2_getÚMatrixStats_min_norm2_setÚ min_norm2ÚMatrixStats_max_norm2_getÚMatrixStats_max_norm2_setÚ max_norm2ÚMatrixStats_per_dim_stats_getÚMatrixStats_per_dim_stats_setÚ per_dim_statsÚMatrixStats_occurrences_getÚMatrixStats_occurrences_setÚ occurrencesÚMatrixStats_buf_getÚMatrixStats_buf_setÚbufÚMatrixStats_nbuf_getÚMatrixStats_nbuf_setÚnbufrÓÚdelete_MatrixStatsrvrrrrrÎ)s& rÎc@rà) ÚPyCallbackIOWriterrôcCr5r'r6r7rrrr9;)r:zPyCallbackIOWriter.cCr;r'r6r<rrrr9;)r>r?r@cGr—)zƒ Callback: Python function that takes a bytes object and returns the number of bytes successfully written. N)rÚPyCallbackIOWriter_swiginitÚnew_PyCallbackIOWriterrprrrrH@)ózPyCallbackIOWriter.__init__cCr‡r')rÚPyCallbackIOWriter___call__©rÚptrvr†r1rrrrùG)r‰zPyCallbackIOWriter.__call__N)rrr1r2rrrr rÚPyCallbackIOWriter_callback_getÚPyCallbackIOWriter_callback_setÚcallbackÚPyCallbackIOWriter_bs_getÚPyCallbackIOWriter_bs_setÚbsrHrùÚdelete_PyCallbackIOWriterrvrrrrrö3)s röc@rv) ÚPyCallbackIOReadercCr5r'r6r7rrrr9O)r:zPyCallbackIOReader.cCr;r'r6r<rrrr9O)r>r?r@cGr—)zy Callback: Python function that takes a size and returns a bytes object with the resulting read N)rÚPyCallbackIOReader_swiginitÚnew_PyCallbackIOReaderrprrrrHT)rùzPyCallbackIOReader.__init__cCr‡r')rÚPyCallbackIOReader___call__rûrrrrù[)r‰zPyCallbackIOReader.__call__N)rrr1rrrr rÚPyCallbackIOReader_callback_getÚPyCallbackIOReader_callback_setrÿÚPyCallbackIOReader_bs_getÚPyCallbackIOReader_bs_setrrHrùÚdelete_PyCallbackIOReaderrvrrrrrN)s rc@r;) ÚPyCallbackIDSelectorcCr5r'r6r7rrrr9c)r:zPyCallbackIDSelector.cCr;r'r6r<rrrr9c)r>r?r@cCrhr')rÚPyCallbackIDSelector_swiginitÚnew_PyCallbackIDSelector)rrÿrrrrHg)r.zPyCallbackIDSelector.__init__cCrNr')rÚPyCallbackIDSelector_is_memberr rrrrÌj)rSzPyCallbackIDSelector.is_memberN)rrr1rrrr rÚ!PyCallbackIDSelector_callback_getÚ!PyCallbackIDSelector_callback_setrÿrHrÌÚdelete_PyCallbackIDSelectorrvrrrrr b)rDr cCrJr')rÚswig_ptr)r“rrrrr)rMrcGr¼r')rÚ rev_swig_ptrr¾rrrru)rMrc@óÆeZdZdZedd„dd„ddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d „Zd d„Zdd„Zd dd„Zd!dd„Zd"dd„Zdd„Zdd„Zdd„ZejZdS)#Úfloat_minheap_array_tú™ a template structure for a set of [min|max]-heaps it is tailored so that the actual data of the heaps can just live in compact arrays. cCr5r'r6r7rrrr9~)r:zfloat_minheap_array_t.cCr;r'r6r<rrrr9~)r>r?r@ú number of heapsú allocated size per heapú identifiers (size nh * k)ú0 values (distances or similarities), size nh * kcCrN©z% Return the list of values for a heap)rÚfloat_minheap_array_t_get_val©rr²rrrÚget_val…)r zfloat_minheap_array_t.get_valcCrN©z Correspponding identifiers)rÚfloat_minheap_array_t_get_idsrrrrr«‰)r zfloat_minheap_array_t.get_idscCrJ©z$ prepare all the heaps before adding)rÚfloat_minheap_array_t_heapifyrLrrrÚheapify)r`zfloat_minheap_array_t.heapifyrr cCrŽ©aç add nj elements to heaps i0:i0+ni, with sequential ids :type nj: int :param nj: nb of elements to add to each heap :type vin: float :param vin: elements to add, size ni * nj :type j0: int, optional :param j0: add this to the ids that are added :type i0: int, optional :param i0: first heap to update :type ni: int, optional :param ni: nb of elements to update (-1 = use nh) )rÚfloat_minheap_array_t_addn©rÚnjÚvinÚj0r»r¼rrrÚaddn‘)r§zfloat_minheap_array_t.addnNc CrÈ©zØ same as addn :type id_in: int, optional :param id_in: ids of the elements to add, size ni * nj :type id_stride: int, optional :param id_stride: stride for id_in )rÚ#float_minheap_array_t_addn_with_ids©rr)r*Úid_inÚ id_strider»r¼rrrÚ addn_with_ids¢)ó z#float_minheap_array_t.addn_with_idsc CrÈ©a  same as addn_with_ids, but for just a subset of queries :type nsubset: int :param nsubset: number of query entries to update :type subset: int :param subset: indexes of queries to update, in 0..nh-1, size nsubset )rÚ0float_minheap_array_t_addn_query_subset_with_ids©rrMrLr)r*r0r1rrrÚaddn_query_subset_with_ids­)r3z0float_minheap_array_t.addn_query_subset_with_idscCrJ©z reorder all the heaps)rÚfloat_minheap_array_t_reorderrLrrrÚreorder¸)r`zfloat_minheap_array_t.reordercCr‹©aC this is not really a heap function. It just finds the per-line extrema of each line of array D :type vals_out: float :param vals_out: extreme value of each line (size nh, or NULL) :type idx_out: int :param idx_out: index of extreme value (size nh or NULL) )rÚ&float_minheap_array_t_per_line_extrema©rÚvals_outÚidx_outrrrÚper_line_extrema¼)r•z&float_minheap_array_t.per_line_extremacCryr')rÚfloat_minheap_array_t_swiginitÚnew_float_minheap_array_trLrrrrHÇ)r|zfloat_minheap_array_t.__init__©rrr ©Nrrr ©Nr) rrr1r2rrrr rÚfloat_minheap_array_t_nh_getÚfloat_minheap_array_t_nh_setÚnhÚfloat_minheap_array_t_k_getÚfloat_minheap_array_t_k_setrÅÚfloat_minheap_array_t_ids_getÚfloat_minheap_array_t_ids_setrAÚfloat_minheap_array_t_val_getÚfloat_minheap_array_t_val_setr© r r«r%r,r2r7r:r@rHÚdelete_float_minheap_array_trvrrrrrw)ó$     rc@r)#Úint_minheap_array_trcCr5r'r6r7rrrr9Õ)r:zint_minheap_array_t.cCr;r'r6r<rrrr9Õ)r>r?r@rrrrcCrNr)rÚint_minheap_array_t_get_valrrrrr Ü)r zint_minheap_array_t.get_valcCrNr!)rÚint_minheap_array_t_get_idsrrrrr«à)r zint_minheap_array_t.get_idscCrJr#)rÚint_minheap_array_t_heapifyrLrrrr%ä)r`zint_minheap_array_t.heapifyrr cCrŽ©aå add nj elements to heaps i0:i0+ni, with sequential ids :type nj: int :param nj: nb of elements to add to each heap :type vin: int :param vin: elements to add, size ni * nj :type j0: int, optional :param j0: add this to the ids that are added :type i0: int, optional :param i0: first heap to update :type ni: int, optional :param ni: nb of elements to update (-1 = use nh) )rÚint_minheap_array_t_addnr(rrrr,è)r§zint_minheap_array_t.addnNc CrÈr-)rÚ!int_minheap_array_t_addn_with_idsr/rrrr2ù)r3z!int_minheap_array_t.addn_with_idsc CrÈr4)rÚ.int_minheap_array_t_addn_query_subset_with_idsr6rrrr7*r3z.int_minheap_array_t.addn_query_subset_with_idscCrJr8)rÚint_minheap_array_t_reorderrLrrrr:*r`zint_minheap_array_t.reordercCr‹©aA this is not really a heap function. It just finds the per-line extrema of each line of array D :type vals_out: int :param vals_out: extreme value of each line (size nh, or NULL) :type idx_out: int :param idx_out: index of extreme value (size nh or NULL) )rÚ$int_minheap_array_t_per_line_extremar=rrrr@*r•z$int_minheap_array_t.per_line_extremacCryr')rÚint_minheap_array_t_swiginitÚnew_int_minheap_array_trLrrrrH*r|zint_minheap_array_t.__init__rCrDrE) rrr1r2rrrr rÚint_minheap_array_t_nh_getÚint_minheap_array_t_nh_setrHÚint_minheap_array_t_k_getÚint_minheap_array_t_k_setrÅÚint_minheap_array_t_ids_getÚint_minheap_array_t_ids_setrAÚint_minheap_array_t_val_getÚint_minheap_array_t_val_setr© r r«r%r,r2r7r:r@rHÚdelete_int_minheap_array_trvrrrrrQÎ)rPrQc@r)#Úfloat_maxheap_array_trcCr5r'r6r7rrrr9,*r:zfloat_maxheap_array_t.cCr;r'r6r<rrrr9,*r>r?r@rrrrcCrNr)rÚfloat_maxheap_array_t_get_valrrrrr 3*r zfloat_maxheap_array_t.get_valcCrNr!)rÚfloat_maxheap_array_t_get_idsrrrrr«7*r zfloat_maxheap_array_t.get_idscCrJr#)rÚfloat_maxheap_array_t_heapifyrLrrrr%;*r`zfloat_maxheap_array_t.heapifyrr cCrŽr&)rÚfloat_maxheap_array_t_addnr(rrrr,?*r§zfloat_maxheap_array_t.addnNc CrÈr-)rÚ#float_maxheap_array_t_addn_with_idsr/rrrr2P*r3z#float_maxheap_array_t.addn_with_idsc CrÈr4)rÚ0float_maxheap_array_t_addn_query_subset_with_idsr6rrrr7[*r3z0float_maxheap_array_t.addn_query_subset_with_idscCrJr8)rÚfloat_maxheap_array_t_reorderrLrrrr:f*r`zfloat_maxheap_array_t.reordercCr‹r;)rÚ&float_maxheap_array_t_per_line_extremar=rrrr@j*r•z&float_maxheap_array_t.per_line_extremacCryr')rÚfloat_maxheap_array_t_swiginitÚnew_float_maxheap_array_trLrrrrHu*r|zfloat_maxheap_array_t.__init__rCrDrE) rrr1r2rrrr rÚfloat_maxheap_array_t_nh_getÚfloat_maxheap_array_t_nh_setrHÚfloat_maxheap_array_t_k_getÚfloat_maxheap_array_t_k_setrÅÚfloat_maxheap_array_t_ids_getÚfloat_maxheap_array_t_ids_setrAÚfloat_maxheap_array_t_val_getÚfloat_maxheap_array_t_val_setr© r r«r%r,r2r7r:r@rHÚdelete_float_maxheap_array_trvrrrrrg%*rPrgc@r)#Úint_maxheap_array_trcCr5r'r6r7rrrr9ƒ*r:zint_maxheap_array_t.cCr;r'r6r<rrrr9ƒ*r>r?r@rrrrcCrNr)rÚint_maxheap_array_t_get_valrrrrr Š*r zint_maxheap_array_t.get_valcCrNr!)rÚint_maxheap_array_t_get_idsrrrrr«Ž*r zint_maxheap_array_t.get_idscCrJr#)rÚint_maxheap_array_t_heapifyrLrrrr%’*r`zint_maxheap_array_t.heapifyrr cCrŽrU)rÚint_maxheap_array_t_addnr(rrrr,–*r§zint_maxheap_array_t.addnNc CrÈr-)rÚ!int_maxheap_array_t_addn_with_idsr/rrrr2§*r3z!int_maxheap_array_t.addn_with_idsc CrÈr4)rÚ.int_maxheap_array_t_addn_query_subset_with_idsr6rrrr7²*r3z.int_maxheap_array_t.addn_query_subset_with_idscCrJr8)rÚint_maxheap_array_t_reorderrLrrrr:½*r`zint_maxheap_array_t.reordercCr‹rZ)rÚ$int_maxheap_array_t_per_line_extremar=rrrr@Á*r•z$int_maxheap_array_t.per_line_extremacCryr')rÚint_maxheap_array_t_swiginitÚnew_int_maxheap_array_trLrrrrHÌ*r|zint_maxheap_array_t.__init__rCrDrE) rrr1r2rrrr rÚint_maxheap_array_t_nh_getÚint_maxheap_array_t_nh_setrHÚint_maxheap_array_t_k_getÚint_maxheap_array_t_k_setrÅÚint_maxheap_array_t_ids_getÚint_maxheap_array_t_ids_setrAÚint_maxheap_array_t_val_getÚint_maxheap_array_t_val_setr© r r«r%r,r2r7r:r@rHÚdelete_int_maxheap_array_trvrrrrr{|*rPr{cCrŽ©zí partitions the table into 0:q and q:n where all elements above q are >= all elements below q (for C = CMax, for CMin comparisons are reversed) Returns the partition threshold. The elements q:n are destroyed on output. )rÚCMin_float_partition_fuzzy©rNrArQÚq_minÚq_maxÚq_outrrrrÔ*rl rcCrŽr)rÚCMax_float_partition_fuzzyr‘rrrr•Ý*rl r•c@ó”eZdZedd„dd„ddZeZeejej ƒZ eej ej ƒZ edd„ƒZdd „Zd d „Zd d „Zdd„Zdd„Zdd„Zdd„Zdd„ZejZdS)ÚAlignedTableUint8cCr5r'r6r7rrrr9æ*r:zAlignedTableUint8.cCr;r'r6r<rrrr9æ*r>r?r@cCrJr'©rÚ AlignedTableUint8_round_capacity©rQrrrÚround_capacityë*r`z AlignedTableUint8.round_capacitycGr$r')rÚAlignedTableUint8_swiginitÚnew_AlignedTableUint8rprrrrHï*r.zAlignedTableUint8.__init__cCrJr')rÚAlignedTableUint8_itemsizerLrrrÚitemsizeò*rMzAlignedTableUint8.itemsizecCrNr')rÚAlignedTableUint8_resizerPrrrrŠõ*rSzAlignedTableUint8.resizecCrJr')rÚAlignedTableUint8_clearrLrrrr‚ø*rMzAlignedTableUint8.clearcCrJr')rÚAlignedTableUint8_sizerLrrrr†û*rMzAlignedTableUint8.sizecCrJr')rÚAlignedTableUint8_nbytesrLrrrÚnbytesþ*rMzAlignedTableUint8.nbytescGrnr')rÚAlignedTableUint8_getrprrrrs+rrzAlignedTableUint8.getcGrnr')rÚAlignedTableUint8_datarprrrr„+rrzAlignedTableUint8.dataN)rrr1rrrr rÚAlignedTableUint8_tab_getÚAlignedTableUint8_tab_setràÚAlignedTableUint8_numel_getÚAlignedTableUint8_numel_setÚnumelr5r›rHrŸrŠr‚r†r¤rsr„Údelete_AlignedTableUint8rvrrrrr—å*ó   r—cCrJr'r˜ršrrrr™ +rMr™c@r–)ÚAlignedTableUint16cCr5r'r6r7rrrr9+r:zAlignedTableUint16.cCr;r'r6r<rrrr9+r>r?r@cCrJr'©rÚ!AlignedTableUint16_round_capacityršrrrr›+r`z!AlignedTableUint16.round_capacitycGr$r')rÚAlignedTableUint16_swiginitÚnew_AlignedTableUint16rprrrrH+r.zAlignedTableUint16.__init__cCrJr')rÚAlignedTableUint16_itemsizerLrrrrŸ+rMzAlignedTableUint16.itemsizecCrNr')rÚAlignedTableUint16_resizerPrrrrŠ+rSzAlignedTableUint16.resizecCrJr')rÚAlignedTableUint16_clearrLrrrr‚!+rMzAlignedTableUint16.clearcCrJr')rÚAlignedTableUint16_sizerLrrrr†$+rMzAlignedTableUint16.sizecCrJr')rÚAlignedTableUint16_nbytesrLrrrr¤'+rMzAlignedTableUint16.nbytescGrnr')rÚAlignedTableUint16_getrprrrrs*+rrzAlignedTableUint16.getcGrnr')rÚAlignedTableUint16_datarprrrr„-+rrzAlignedTableUint16.dataN)rrr1rrrr rÚAlignedTableUint16_tab_getÚAlignedTableUint16_tab_setràÚAlignedTableUint16_numel_getÚAlignedTableUint16_numel_setr«r5r›rHrŸrŠr‚r†r¤rsr„Údelete_AlignedTableUint16rvrrrrr®+r­r®cCrJr'r¯ršrrrr°4+rMr°c@r–)ÚAlignedTableFloat32cCr5r'r6r7rrrr98+r:zAlignedTableFloat32.cCr;r'r6r<rrrr98+r>r?r@cCrJr'©rÚ"AlignedTableFloat32_round_capacityršrrrr›=+r`z"AlignedTableFloat32.round_capacitycGr$r')rÚAlignedTableFloat32_swiginitÚnew_AlignedTableFloat32rprrrrHA+r.zAlignedTableFloat32.__init__cCrJr')rÚAlignedTableFloat32_itemsizerLrrrrŸD+rMzAlignedTableFloat32.itemsizecCrNr')rÚAlignedTableFloat32_resizerPrrrrŠG+rSzAlignedTableFloat32.resizecCrJr')rÚAlignedTableFloat32_clearrLrrrr‚J+rMzAlignedTableFloat32.clearcCrJr')rÚAlignedTableFloat32_sizerLrrrr†M+rMzAlignedTableFloat32.sizecCrJr')rÚAlignedTableFloat32_nbytesrLrrrr¤P+rMzAlignedTableFloat32.nbytescGrnr')rÚAlignedTableFloat32_getrprrrrsS+rrzAlignedTableFloat32.getcGrnr')rÚAlignedTableFloat32_datarprrrr„V+rrzAlignedTableFloat32.dataN)rrr1rrrr rÚAlignedTableFloat32_tab_getÚAlignedTableFloat32_tab_setràÚAlignedTableFloat32_numel_getÚAlignedTableFloat32_numel_setr«r5r›rHrŸrŠr‚r†r¤rsr„Údelete_AlignedTableFloat32rvrrrrr¿7+r­r¿cCrJr'rÀršrrrrÁ]+rMrÁcGr¼r')rÚCMin_uint16_partition_fuzzyr¾rrrrÐa+rMrÐcGr¼r')rÚCMax_uint16_partition_fuzzyr¾rrrrÑd+rMrÑcGr¼r')rÚmerge_knn_results_CMinr¾rrrrÒg+rMrÒcGr¼r')rÚmerge_knn_results_CMaxr¾rrrrÓj+rMrÓcCrJr')rÚomp_set_num_threads)Ú num_threadsrrrrÔm+rMrÔcCrÜr')rÚomp_get_max_threadsrrrrrÖp+rIrÖcCr‹r')rÚmemcpy)Údestr¶ rQrrrr×s+rr×cCrJr')rÚcast_integer_to_uint8_ptrr7rrrrÙv+rMrÙcCrJr')rÚcast_integer_to_float_ptrr7rrrrÚy+rMrÚcCrJr')rÚcast_integer_to_idx_t_ptrr7rrrrÛ|+rMrÛcCrJr')rÚcast_integer_to_int_ptrr7rrrrÜ+rMrÜcCrJr')rÚcast_integer_to_void_ptrr7rrrrÝ‚+rMrÝc@sZeZdZedd„dd„ddZeZeejej ƒZ dd„Z dd „Z d d „Z d d „ZejZdS)Ú MapLong2LongcCr5r'r6r7rrrr9…+r:zMapLong2Long.cCr;r'r6r<rrrr9…+r>r?r@cCr‡r')rÚMapLong2Long_add©rrQr¶rNrrrr—‰+r‰zMapLong2Long.addcCrNr')rÚMapLong2Long_searchrrrrr¢Œ+rSzMapLong2Long.searchcCr‡r')rÚMapLong2Long_search_multipleràrrrÚsearch_multiple+r‰zMapLong2Long.search_multiplecCryr')rÚMapLong2Long_swiginitÚnew_MapLong2LongrLrrrrH’+r|zMapLong2Long.__init__N)rrr1rrrr rÚMapLong2Long_map_getÚMapLong2Long_map_setrxr—r¢rãrHÚdelete_MapLong2LongrvrrrrrÞ„+s rÞcCrÜr')rÚwaitrrrrréš+rIrér>)Tr)Fr )r r r ršr'rárø(½ÚsysrÚ_swig_python_version_infoÚ RuntimeErrorÚ __package__rrrÚbuiltinsr Ú ImportErrorrr#r&r/rr0Úobjectr4ÚSwigPyIterator_swigregisterÚSHARED_PTR_DISOWNrxÚFloat32Vector_swigregisterr‘ÚFloat64Vector_swigregisterrœÚInt8Vector_swigregisterr§ÚInt16Vector_swigregisterr²ÚInt32Vector_swigregisterr½ÚInt64Vector_swigregisterrÈÚUInt8Vector_swigregisterrÓÚUInt16Vector_swigregisterrÞÚUInt32Vector_swigregisterréÚUInt64Vector_swigregisterrôÚ Float32VectorVector_swigregisterrÿÚUInt8VectorVector_swigregisterr ÚInt32VectorVector_swigregisterrÚInt64VectorVector_swigregisterr Ú"VectorTransformVector_swigregisterr+Ú!OperatingPointVector_swigregisterr6Ú#InvertedListsPtrVector_swigregisterrAÚRepeatVector_swigregisterrLÚ+ClusteringIterationStatsVector_swigregisterrWÚ!ParameterRangeVector_swigregisterrbÚ OnDiskOneListVector_swigregisterrnrtrwÚPartitionStats_swigregisterr„rˆrŠrŒrr–ÚBitstringWriter_swigregisterÚcvarrªÚBitstringReader_swigregisterr¶r½r¿rÄrÉrÍrÔrÖrØrÚrÛrÝrÞrßràrárãrärårærërìrïròrôrúrrrr r rrrrrrrrr"r)r,r-r0r2r3r4r8r9r:r=r>r@rBrCrGrHrIrKrQrSrVrXr]ÚRandomGenerator_swigregisterÚhamdis_tab_ham_bytesrprrrsrtrurwryrzr|r}rƒÚMETRIC_INNER_PRODUCTÚ METRIC_L2Ú METRIC_L1Ú METRIC_LinfÚ METRIC_LpÚMETRIC_CanberraÚMETRIC_BrayCurtisÚMETRIC_JensenShannonÚMETRIC_Jaccardr„ÚFAISS_VERSION_MAJORÚFAISS_VERSION_MINORÚFAISS_VERSION_PATCHr‡ÚSearchParameters_swigregisterrÚIndex_swigregisterróÚDistanceComputer_swigregisterrÿÚ&FlatCodesDistanceComputer_swigregisterr ÚIndexFlatCodes_swigregisterrÚIndexFlat_swigregisterr,ÚIndexFlatIP_swigregisterr1ÚIndexFlatL2_swigregisterr5ÚIndexFlat1D_swigregisterrDÚ!ClusteringParameters_swigregisterrgÚ%ClusteringIterationStats_swigregisterryÚClustering_swigregisterr”ÚClustering1D_swigregisterršÚ/ProgressiveDimClusteringParameters_swigregisterr¥Ú'ProgressiveDimIndexFactory_swigregisterr«Ú%ProgressiveDimClustering_swigregisterr¹r¼r¾rÀÚQuantizer_swigregisterrÎÚProductQuantizer_swigregisterr*ÚPQEncoderGeneric_swigregisterr<ÚPQEncoder8_swigregisterrEÚPQEncoder16_swigregisterrLÚPQDecoderGeneric_swigregisterr[ÚPQDecoder8_swigregisterrdÚPQDecoder16_swigregisterrlÚAdditiveQuantizer_swigregisterrÝÚResidualQuantizer_swigregisterrrrÚ!LocalSearchQuantizer_swigregisterrbÚIcmEncoder_swigregisterrqÚIcmEncoderFactory_swigregisterrxÚLSQTimer_swigregisterr…ÚLSQTimerScope_swigregisterr—Ú%ProductAdditiveQuantizer_swigregisterr®Ú(ProductLocalSearchQuantizer_swigregisterr³Ú%ProductResidualQuantizer_swigregisterr·ÚCodePacker_swigregisterrÐÚCodePackerFlat_swigregisterrØÚVectorTransform_swigregisterrîÚLinearTransform_swigregisterr Ú!RandomRotationMatrix_swigregisterrÚPCAMatrix_swigregisterr5ÚITQMatrix_swigregisterrCÚITQTransform_swigregisterrXÚOPQMatrix_swigregisterrpÚ%RemapDimensionsTransform_swigregisterrzÚ#NormalizationTransform_swigregisterrƒÚCenteringTransform_swigregisterrŽÚ)SearchParametersPreTransform_swigregisterr•ÚIndexPreTransform_swigregisterr»ÚIndexRefine_swigregisterrÕÚIndexRefineFlat_swigregisterrÚÚIndexLSH_swigregisterrõÚ)SimulatedAnnealingParameters_swigregisterrÚ!PermutationObjective_swigregisterrÚ(ReproduceDistancesObjective_swigregisterrr,r?Ú(SimulatedAnnealingOptimizer_swigregisterrVÚPolysemousTraining_swigregisterryÚIndexPQ_swigregisterr¨ÚSearchParametersPQ_swigregisterr²ÚIndexPQStats_swigregisterr¿Ú MultiIndexQuantizer_swigregisterrÊÚ!MultiIndexQuantizer2_swigregisterrÕÚ#IndexAdditiveQuantizer_swigregisterráÚ#IndexResidualQuantizer_swigregisterrëÚ&IndexLocalSearchQuantizer_swigregisterròÚ*IndexProductResidualQuantizer_swigregisterrüÚ-IndexProductLocalSearchQuantizer_swigregisterrÚ$AdditiveCoarseQuantizer_swigregisterrÚ4SearchParametersResidualCoarseQuantizer_swigregisterrÚ$ResidualCoarseQuantizer_swigregisterr'Ú'LocalSearchCoarseQuantizer_swigregisterr-ÚIOReader_swigregisterr7ÚIOWriter_swigregisterr=ÚVectorIOReader_swigregisterrGÚVectorIOWriter_swigregisterrOÚFileIOReader_swigregisterr\ÚFileIOWriter_swigregisterrfÚBufferedIOReader_swigregisterrÚBufferedIOWriter_swigregisterr“r”r•r–Ú"InvertedListsIterator_swigregisterrÚInvertedLists_swigregisterrîÚArrayInvertedLists_swigregisterrüÚ"ReadOnlyInvertedLists_swigregisterr Ú HStackInvertedLists_swigregisterr ÚSliceInvertedLists_swigregisterr' Ú VStackInvertedLists_swigregisterr9 Ú MaskedInvertedLists_swigregisterrK Ú#StopWordsInvertedLists_swigregisterr\ Ú InvertedListsIOHook_swigregisterrd ri rl rq rx ÚBlockInvertedLists_swigregisterr r‘ r” r• ÚDirectMap_swigregisterr· ÚDirectMapAdd_swigregisterrÊ ÚLevel1Quantizer_swigregisterrê Ú SearchParametersIVF_swigregisterrù ÚIndexIVFInterface_swigregisterr ÚIndexIVF_swigregisterrX Ú InvertedListScanner_swigregisterr{ ÚIndexIVFStats_swigregisterrßr“ r” r• r™ r› rŸ ÚSlidingIndexWindow_swigregisterr´ rµ r· rº r» r½ r¿ ÚScalarQuantizer_swigregisterrô Ú!IndexScalarQuantizer_swigregisterr Ú$IndexIVFScalarQuantizer_swigregisterr Ú!IndexIVFSpectralHash_swigregisterr/ Ú&IndexIVFAdditiveQuantizer_swigregisterr? Ú&IndexIVFResidualQuantizer_swigregisterrG Ú)IndexIVFLocalSearchQuantizer_swigregisterrM Ú-IndexIVFProductResidualQuantizer_swigregisterrS Ú0IndexIVFProductLocalSearchQuantizer_swigregisterrY Ú!SearchParametersHNSW_swigregisterrc ÚHNSW_swigregisterr› rÈ ÚHNSWStats_swigregisterrÛ Ú%ReconstructFromNeighbors_swigregisterr ÚIndexHNSW_swigregisterr. ÚIndexHNSWFlat_swigregisterr3 ÚIndexHNSWPQ_swigregisterr9 ÚIndexHNSWSQ_swigregisterr= ÚIndexHNSW2Level_swigregisterrD rH rJ ÚNeighbor_swigregisterrW ÚNhood_swigregisterro ÚNNDescent_swigregisterrª ÚIndexNNDescent_swigregisterr¹ ÚIndexNNDescentFlat_swigregisterr½ ÚIndexIVFFlat_swigregisterrÆ ÚIndexIVFFlatDedup_swigregisterrÔ rÕ ÚNSG_swigregisterr ÚIndexNSG_swigregisterr- ÚIndexNSGFlat_swigregisterr1 ÚIndexNSGPQ_swigregisterr6 ÚIndexNSGSQ_swigregisterr: ÚOnDiskOneList_swigregisterrE Ú OnDiskInvertedLists_swigregisterr~ ÚZnSphereSearch_swigregisterr” ÚEnumeratedVectors_swigregisterr¤ ÚRepeat_swigregisterr­ ÚRepeats_swigregisterrº ÚZnSphereCodec_swigregisterrÉ ÚZnSphereCodecRec_swigregisterrí ÚZnSphereCodecAlt_swigregisterrù ÚIndexLattice_swigregisterrÚ"IVFPQSearchParameters_swigregisterr!ÚIndexIVFPQ_swigregisterrMrNÚIndexIVFPQStats_swigregisterr^ÚIndexIVFPQR_swigregisterrrÚIndex2Layer_swigregisterrˆÚIndexFastScan_swigregisterr½ÚFastScanStats_swigregisterrÍÚ+IndexAdditiveQuantizerFastScan_swigregisterrãÚ+IndexResidualQuantizerFastScan_swigregisterrêÚ.IndexLocalSearchQuantizerFastScan_swigregisterrðÚ2IndexProductResidualQuantizerFastScan_swigregisterröÚ5IndexProductLocalSearchQuantizerFastScan_swigregisterrüÚIndexPQFastScan_swigregisterrÚIndexIVFFastScan_swigregisterr2ÚIVFFastScanStats_swigregisterrVÚ.IndexIVFAdditiveQuantizerFastScan_swigregisterrkÚ1IndexIVFLocalSearchQuantizerFastScan_swigregisterrrÚ.IndexIVFResidualQuantizerFastScan_swigregisterrxÚ8IndexIVFProductLocalSearchQuantizerFastScan_swigregisterr~Ú5IndexIVFProductResidualQuantizerFastScan_swigregisterr„ÚIndexIVFPQFastScan_swigregisterr”r—r˜rrŸr ÚIndexBinary_swigregisterr½ÚIndexBinaryFlat_swigregisterrÒÚIndexBinaryIVF_swigregisterrÚ&BinaryInvertedListScanner_swigregisterr Ú!IndexBinaryFromFloat_swigregisterrÚIndexBinaryHNSW_swigregisterr'ÚIndexBinaryHash_swigregisterr;Ú!IndexBinaryHashStats_swigregisterrHÚ!IndexBinaryMultiHash_swigregisterr`ÚThreadedIndexBase_swigregisterrvÚ$ThreadedIndexBaseBinary_swigregisterrÚIndexShards_swigregisterr›ÚIndexBinaryShards_swigregisterr¨ÚIndexShardsIVF_swigregisterr²ÚIndexReplicas_swigregisterrÆÚ IndexBinaryReplicas_swigregisterrÑÚIndexSplitVectors_swigregisterrçÚIndexRandom_swigregisterròÚIndexIDMap_swigregisterr ÚIndexBinaryIDMap_swigregisterr ÚIndexIDMap2_swigregisterr3ÚIndexBinaryIDMap2_swigregisterr?Ú#IndexRowwiseMinMaxBase_swigregisterrKÚ#IndexRowwiseMinMaxFP16_swigregisterrUÚIndexRowwiseMinMax_swigregisterr^ÚRangeSearchResult_swigregisterrpÚBufferList_swigregisterrƒÚRangeQueryResult_swigregisterr‘Ú%RangeSearchPartialResult_swigregisterrŸrªÚInterruptCallback_swigregisterr®r±r´r·r¼ÚVisitedTable_swigregisterrÊÚIDSelector_swigregisterrÎÚIDSelectorRange_swigregisterráÚIDSelectorArray_swigregisterrëÚIDSelectorBatch_swigregisterrôÚIDSelectorBitmap_swigregisterrþÚIDSelectorNot_swigregisterrÚIDSelectorAll_swigregisterr ÚIDSelectorAnd_swigregisterrÚIDSelectorOr_swigregisterr ÚIDSelectorXOr_swigregisterÚ EXACT_TOPKÚAPPROX_TOPK_BUCKETS_B32_D2ÚAPPROX_TOPK_BUCKETS_B8_D3ÚAPPROX_TOPK_BUCKETS_B16_D2ÚAPPROX_TOPK_BUCKETS_B8_D2r)r+r,r-r.r0r1r2r3r4r5r6r7r8r9r:r;r<ÚCloner_swigregisterÚIO_FLAG_READ_ONLYÚIO_FLAG_ONDISK_SAME_DIRÚIO_FLAG_SKIP_IVF_DATAÚIO_FLAG_SKIP_PRECOMPUTE_TABLEÚ IO_FLAG_MMAPrFrHÚAutoTuneCriterion_swigregisterr^Ú"OneRecallAtRCriterion_swigregisterrfÚ"IntersectionCriterion_swigregisterrmÚOperatingPoint_swigregisterr{ÚOperatingPoints_swigregisterr“ÚParameterRange_swigregisterrœÚParameterSpace_swigregisterrËrÌrÎÚMatrixStats_swigregisterröÚPyCallbackIOWriter_swigregisterrÚPyCallbackIOReader_swigregisterr Ú!PyCallbackIDSelector_swigregisterrrrÚ"float_minheap_array_t_swigregisterrQÚ int_minheap_array_t_swigregisterrgÚ"float_maxheap_array_t_swigregisterr{Ú int_maxheap_array_t_swigregisterrr•r—ÚAlignedTableUint8_swigregisterr™r®ÚAlignedTableUint16_swigregisterr°r¿Ú AlignedTableFloat32_swigregisterrÁrÐrÑrÒrÓrÔrÖr×rÙrÚrÛrÜrÝrÞÚMapLong2Long_swigregisterrérrrrÚs˜     ÿ   ;                               - H    #      9 /      ?       +        3 ~  "      S     ? 0  +   \20$/I  " "  %&$+(909( CsG Q$@ g-?6"(33 c* .(j()HE9G:    4/)., %# ::tt^^%//##0 %+ "          +  % T UUUU $$$