chunk_uid stringlengths 40 40 | chunk_type stringclasses 2
values | chunk_index int64 0 6.71k | total_chunks int64 1 6.71k | section_title stringlengths 1 157 | embed_text stringlengths 1 83.3k | spans dict | paper_doi stringlengths 0 63 | paper_id_arxiv stringlengths 9 16 | title stringlengths 7 245 | authors listlengths 1 768 | categories listlengths 1 7 | year int64 2k 2.02k | language stringclasses 2
values | discipline stringclasses 8
values | dense_vector listlengths 1.02k 1.02k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
10047b9f02a872c0ac700394d679d01ac72f783f | subsection | 70 | 78 | Spectral sum representation | In this appendix, we include further details of the derivation of the spectral sum representation of the Green's functions.
We begin by writing the Green's function for the Fubini-Lipatov case in the form&G^{\rm FL}(x,x^{\prime })\ =\ \frac{1}{2\pi ^2}\sum _{j\,=\,0}^{\infty }(j+1)U_j(\cos \theta )\\&\qquad \times \:\l... | {
"cite_spans": []
} | 10.1103/PhysRevD.98.016001 | 1804.04944 | Fluctuations about the Fubini-Lipatov instanton for false vacuum decay
in classically scale invariant models | [
"Bjorn Garbrecht",
"Peter Millington"
] | [
"hep-th",
"hep-ph"
] | 2,018 | en | Physics | [
-0.049242474138736725,
-0.011578388512134552,
-0.019480371847748756,
-0.029182421043515205,
-0.03115028887987137,
-0.006460404954850674,
0.0007327068015001714,
0.015155637636780739,
0.015384459868073463,
0.046740688383579254,
-0.01146397739648819,
0.026238245889544487,
0.010968197137117386,
... |
5c30765c9bae35b793003dc34734c32229887df0 | subsection | 71 | 78 | Spectral sum representation | In terms of the thin-wall eigenbasis, viz. the f_{\lambda ^{\rm TW}j}^{\pm } of Sec. REF , we can write\tilde{\phi }_{\lambda ^{\rm FL} j}^{\pm }(u)\ &=\ \left[\sum _{\bar{\lambda }^{\rm TW}\,\in \, \bar{L}^{\rm TW}_{{\rm d}j}}\right.\\&\qquad \left.+\!\!\int \limits _{\bar{\lambda }^{\rm TW}\, \in \, \bar{L}^{\rm TW}_... | {
"cite_spans": []
} | 10.1103/PhysRevD.98.016001 | 1804.04944 | Fluctuations about the Fubini-Lipatov instanton for false vacuum decay
in classically scale invariant models | [
"Bjorn Garbrecht",
"Peter Millington"
] | [
"hep-th",
"hep-ph"
] | 2,018 | en | Physics | [
0.008954831399023533,
0.054979920387268066,
-0.030846115201711655,
-0.003241740632802248,
0.010434591211378574,
-0.006060148123651743,
0.0037470709066838026,
0.01995386742055416,
0.002177686896175146,
0.05052538961172104,
-0.005537655670195818,
0.04039590060710907,
-0.028481552377343178,
0... |
17d8581d71b1ba96ebb8f577c13d1d140bc30806 | subsection | 72 | 78 | Spectral sum representation | Now, by virtue of the completeness of the thin-wall basis, we can also write&G^{\rm FL}(x,x^{\prime })\ =\ \frac{1}{2\pi ^2R^2}\sum _{j\,=\,0}^{\infty }(j+1)U_j(\cos \theta )\\&\times \left[\sum _{\bar{\lambda }^{\rm TW}\,\in \, \bar{L}_{{\rm d}j}^{\rm TW}}\:+\!\!\int \limits _{\bar{\lambda }^{\rm TW} \,\in \, \bar{L}_... | {
"cite_spans": []
} | 10.1103/PhysRevD.98.016001 | 1804.04944 | Fluctuations about the Fubini-Lipatov instanton for false vacuum decay
in classically scale invariant models | [
"Bjorn Garbrecht",
"Peter Millington"
] | [
"hep-th",
"hep-ph"
] | 2,018 | en | Physics | [
-0.02575487457215786,
0.0539814829826355,
-0.021681087091565132,
-0.02802826091647148,
-0.002054058015346527,
-0.01271723210811615,
-0.019941717386245728,
0.00772035913541913,
-0.02004852145910263,
0.03207153081893921,
-0.01779039204120636,
0.014441343955695629,
-0.010451474227011204,
0.02... |
db8c31641c84025947c6804f60af3d0dd5ce06e3 | subsection | 73 | 78 | Spectral sum representation | \end{array}\right.}In the thin-wall case, the two bases, of course, coincide, and Eq. (REF ) is trivially satisfied. For the Fubini-Lipatov case, only the zero modes of the two bases coincide, as described further in Sec. REF . On the other hand, the nonzero modes in the Fubini-Lipatov case are a linear combination of ... | {
"cite_spans": []
} | 10.1103/PhysRevD.98.016001 | 1804.04944 | Fluctuations about the Fubini-Lipatov instanton for false vacuum decay
in classically scale invariant models | [
"Bjorn Garbrecht",
"Peter Millington"
] | [
"hep-th",
"hep-ph"
] | 2,018 | en | Physics | [
-0.03839345648884773,
-0.003284654812887311,
-0.053775254637002945,
0.001389588345773518,
0.008713300339877605,
0.0024644448421895504,
0.031190868467092514,
0.016526278108358383,
0.00914820283651352,
0.0437038391828537,
-0.005619392264634371,
0.027681132778525352,
-0.00406290078535676,
0.0... |
34ca1416267ce91ec94acb85f1ff1d22d6e40b1d | subsection | 74 | 78 | Spectral sum representation | (REF ); namely, the Jacobi polynomials of degree 2:P_2^{(\mp \varpi ,\pm \varpi )}(u)\ =\ \frac{1}{2}\big (3u^2-1\mp 3\varpi u+\varpi ^2\big )\;.The discrete modes correspond to \varpi =n\in \lbrace 1,2\rbrace and the continuum modes to \varpi =i\xi (\xi \in \mathbb {R}).The normalization of the eigenfunctions follows ... | {
"cite_spans": []
} | 10.1103/PhysRevD.98.016001 | 1804.04944 | Fluctuations about the Fubini-Lipatov instanton for false vacuum decay
in classically scale invariant models | [
"Bjorn Garbrecht",
"Peter Millington"
] | [
"hep-th",
"hep-ph"
] | 2,018 | en | Physics | [
-0.041437700390815735,
-0.018872765824198723,
-0.03185637667775154,
-0.013242975808680058,
-0.03820323944091797,
0.040278177708387375,
0.06475021690130234,
-0.013914278708398342,
0.012205507606267929,
0.0046876780688762665,
-0.019864464178681374,
0.017942097038030624,
-0.02717251144349575,
... |
0a5f27caa85209f3a25d21753d3287620e450bd2 | subsection | 75 | 78 | Spectral sum representation | We find that the contribution from the discrete modes isG_{\rm d}(x,x^{\prime })\ &=\ \frac{1}{2\pi ^2R^2}\begin{Bmatrix} \frac{1}{\gamma R}\\ \Big (\frac{1+u}{1-u}\Big )\Big (\frac{1+u^{\prime }}{1-u^{\prime }}\Big )\end{Bmatrix}\\&\quad \times \:\sum _{j\,=\,0}^{\infty }(j+1)U_j(\cos \theta )\\&\quad \times \bigg [-\... | {
"cite_spans": []
} | 10.1103/PhysRevD.98.016001 | 1804.04944 | Fluctuations about the Fubini-Lipatov instanton for false vacuum decay
in classically scale invariant models | [
"Bjorn Garbrecht",
"Peter Millington"
] | [
"hep-th",
"hep-ph"
] | 2,018 | en | Physics | [
-0.0387994684278965,
-0.004796511493623257,
-0.04307320713996887,
-0.039165787398815155,
-0.020651329308748245,
0.012348060496151447,
0.054917577654123306,
0.013958345167338848,
-0.02191818878054619,
0.0015206125099211931,
-0.03599100932478905,
-0.011432258412241936,
-0.0003038363065570593,
... |
bef1d8aae2cec5ba1c96902cf0ab7f492d74ce3a | subsection | 76 | 78 | Spectral sum representation | (REF ) can be written&I(u,u^{\prime })\ =\ \int _{-\infty }^{+\infty }\frac{{\rm d}\xi }{2\pi }\;\frac{e^{i\xi L/2}}{(1+\xi ^2)(4+\xi ^2)(\omega ^2+\xi ^2)}\\&\ \times \:\big (1\:-\:3u^2\:+\:3iu\xi \:+\:\xi ^2\big )\big (1\:-\:3u^{\prime 2}\:-\:3iu^{\prime }\xi \:+\:\xi ^2\big )\;.After partial fractioning, we can deco... | {
"cite_spans": []
} | 10.1103/PhysRevD.98.016001 | 1804.04944 | Fluctuations about the Fubini-Lipatov instanton for false vacuum decay
in classically scale invariant models | [
"Bjorn Garbrecht",
"Peter Millington"
] | [
"hep-th",
"hep-ph"
] | 2,018 | en | Physics | [
-0.025384165346622467,
0.03224887326359749,
-0.018504202365875244,
-0.016338005661964417,
-0.024880751967430115,
0.03063185140490532,
0.04262220859527588,
0.039052560925483704,
0.022317927330732346,
0.016246475279331207,
-0.03456761687994003,
0.013561611995100975,
-0.004660374019294977,
0.... |
d355354663351b843f72f760b40d6ed669679de6 | subsection | 77 | 78 | Spectral sum representation | (REF ). Notice, in particular, that there are no unit step functions in I_1 and I_2. Putting everything together, and taking the coincident limit, we quickly arrive at the results presented in Sec. REF . | {
"cite_spans": []
} | 10.1103/PhysRevD.98.016001 | 1804.04944 | Fluctuations about the Fubini-Lipatov instanton for false vacuum decay
in classically scale invariant models | [
"Bjorn Garbrecht",
"Peter Millington"
] | [
"hep-th",
"hep-ph"
] | 2,018 | en | Physics | [
-0.019893832504749298,
0.031671468168497086,
-0.04500522091984749,
-0.02617930807173252,
-0.016003550961613655,
0.02906269207596779,
-0.00358516164124012,
0.03328860551118851,
-0.0025229621678590775,
0.0016066482057794929,
-0.020504072308540344,
-0.015637407079339027,
0.010511388070881367,
... |
e7e24ca1f0a3bbd06e4fc034d8d6880561e2db96 | abstract | 0 | 91 | Abstract | The reversible object-oriented programming language (ROOPL) was presented in
late 2016 and proved that object-oriented programming paradigms works in the
reversible setting. The language featured simple statically scoped objects
which made non-trivial programs tedious, if not impossible to write using the
limited tools... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.09940791130065918,
-0.00359278148971498,
0.015576347708702087,
0.03460054472088814,
-0.03161037340760231,
-0.021816039457917213,
0.04839194193482399,
0.022655118256807327,
0.034051328897476196,
-0.0071817487478256226,
-0.021190544590353966,
0.014310101978480816,
0.016110306605696678,
0.... | |
a1224012f60501e989208454897cc6c8bae2d89f | subsection | 1 | 91 | Abstract | The reversible object-oriented programming language (Roopl) was presented in late 2016 and proved that object-oriented programming paradigms works in the reversible setting. The language featured simple statically scoped objects which made non-trivial programs tedious, if not impossible to write using the limited tools... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.09726302325725555,
0.001204156200401485,
0.024376774206757545,
0.024208974093198776,
-0.03294983133673668,
-0.015384215861558914,
0.052902787923812866,
0.0113341324031353,
0.030631139874458313,
0.004336106590926647,
-0.019907189533114433,
0.022012319415807724,
0.03200405091047287,
0.005... | |
4eeae76ea6c61fa22dbe0c1f0c1493c9df88f86c | subsection | 2 | 91 | Preface | This Master's Thesis is submitted as the last part for the degree of Master of Science in Computer Science at the University of Copenhagen, Department of Computer Science, presenting a 30 ECTS workload.The thesis consists of LastPage pages and a ZIP archive containing source code and test programs developed as part of ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.07386035472154617,
0.010140538215637207,
0.0006466595805250108,
-0.006096531171351671,
-0.006939668674021959,
0.020036909729242325,
0.0389140285551548,
-0.01788519322872162,
0.021623991429805756,
-0.0016452622367069125,
0.007004525046795607,
0.04394996166229248,
-0.017015349119901657,
0... | |
3117ec5042ac5728116370b964e65a95d80b43b8 | subsection | 3 | 91 | Introduction | In recent years, technologies such as cloud-based services, deep learning, cryptocurrency mining and other services requiring large computational power and availability have been on the rise. Most of these services are hosted on massive server parks, consuming immense amounts of electricity in order to power the machin... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.014215424656867981,
0.051459379494190216,
-0.036168068647384644,
0.03131513670086861,
-0.025928080081939697,
-0.02254018373787403,
-0.024264654144644737,
-0.000890371622517705,
0.021410886198282242,
0.02716420404613018,
0.01339897233992815,
0.008492629043757915,
-0.022998008877038956,
0... | |
f828c6821bf67e4a091aafb75cdaee32a9790768 | subsection | 4 | 91 | Reversible Computing | Reversible computing is a two-directional computational model in which all processes are time-invertible. This means, that at any time during execution, the computation can return to a former state. In order to maintain reversibility, the reversible computational model cannot compute many-to-one functions, as the model... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.032540880143642426,
0.01340861339122057,
-0.004685764666646719,
0.03773032873868942,
0.016316229477524757,
-0.0025909075047820807,
0.020620418712496758,
0.03827979788184166,
0.015980442985892296,
0.02983931638300419,
-0.06224283203482628,
0.005979310721158981,
0.022955669090151787,
-0.0... | |
99bf247d9a1ab5cef384d8a9b1bdf0fe1e0f8b8a | subsection | 5 | 91 | Object-Oriented Programming | Object-oriented programming (OOP) has for many years been the most widely used programming paradigm as reflected in the popular usage of object-oriented programming languages, such as the C-family languages, Java, PHP and in recent years Javascript and Python. The OOP core concepts such as inheritance, encapsulation an... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.038960110396146774,
0.015651164576411247,
-0.04484836757183075,
0.023842856287956238,
-0.03465833142399788,
-0.05903509631752968,
0.0060751233249902725,
-0.0018191046547144651,
0.005167477764189243,
-0.03040231205523014,
-0.04518396779894829,
-0.005613673012703657,
0.003426552517339587,
... | |
f41144840d497dd36fe481b9380ab67d1202d37d | subsection | 6 | 91 | Reversible Object-Oriented Programming | The high-level reversible language Roopl (Reversible Object-Oriented Programming Language) was introduced in late 2016 , . The language extends the design of previously existing reversible imperative languages with object-oriented programming language features such as user-defined data types, class inheritance and subt... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.06867877393960953,
0.012797144241631031,
0.0016988457646220922,
0.040932547301054,
-0.02655579149723053,
0.013171061873435974,
0.05576716363430023,
0.0015204716473817825,
-0.02422071434557438,
-0.009805802255868912,
-0.023411830887198448,
-0.01228586956858635,
0.0020451012533158064,
0.0... | |
10911dab9005cc4d50982ee60e950ffec8c5ea35 | subsection | 7 | 91 | Motivation | The block defined objects of Roopl and lack of multiple references are problematic when writing complex, reversible programs using OOP methodologies as they pose severe limitations on the expressiveness. It has therefore been proposed to extend and partially redesign the language with dynamic memory management in mind,... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.05728916823863983,
0.02389846369624138,
0.006985646206885576,
0.029972275719046593,
-0.03632078319787979,
-0.002634401200339198,
0.0524362213909626,
0.01500902883708477,
-0.0011455162893980742,
-0.005158161744475365,
-0.03781634569168091,
0.0020697505678981543,
-0.013231142424046993,
0.... | |
ae2eb07a2aba47485dbbbf7d42b1ac9e6c354f6c | subsection | 8 | 91 | Thesis Statement | An extension of the reversible object-oriented programming language with dynamic memory management is feasible and effective. The resulting expressiveness allows non-trivial reversible programming previously unseen, such as reversible data structures, including linked lists, doubly linked lists and trees. | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.06538759171962738,
0.0002616209676489234,
0.003731854958459735,
0.027702726423740387,
-0.04499594494700432,
-0.045453839004039764,
0.04591173678636551,
0.0284200981259346,
0.020864808931946754,
0.022635340690612793,
-0.04475173354148865,
-0.013622415252029896,
0.009592927992343903,
0.00... | |
7c6b04551f6ebec5f3b8e8c85585cfebe3528e0b | subsection | 9 | 91 | Outline | This Master's thesis consists of four chapters, besides the introductory chapter. The following summary describes the following chapters.Chapter 2 formally defines the Roopl extension exemplified by the new language , a superset of Roopl.
Chapter 3 serves as a brief description of dynamic memory management along with ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.048695337027311325,
-0.01827600784599781,
0.032951731234788895,
0.04674264416098595,
-0.024729054421186447,
-0.014858790673315525,
0.035941798239946365,
0.03270764648914337,
0.01661316491663456,
0.002852765843272209,
-0.03003794513642788,
0.03279917687177658,
-0.011464457027614117,
0.00... | |
6f1a89aa61499ea443869fcf7f7549f20f3a0c06 | subsection | 10 | 91 | The | With the design and implementation of the Reversible Object-Oriented Programming Language (Roopl) and the work-in-progress report of Joule, the first steps into the uncharted lands of Object-Oriented Programming (OOP) and reversibility were taken. In this chapter, we present , the natural successor to Roopl, improving ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.07999593764543533,
0.017603987827897072,
-0.009076579473912716,
0.04292688146233559,
-0.019892200827598572,
0.002215753309428692,
0.050798337906599045,
-0.019648125395178795,
0.008275704458355904,
-0.004298027604818344,
-0.03578765690326691,
0.004107343032956123,
0.03462829440832138,
0.... | |
a788aae083219c0e9fa885ae3bcc18cb86d7db11 | subsection | 11 | 91 | Syntax | A program consists, analogously to a Roopl program, of one or more class definitions, each with a varying number of fields and class methods. The entry point of the program is a nullary main method, which is defined exactly once and is instantiated during program start-up. Fields of the main object will serve as output... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.019474193453788757,
-0.013804394751787186,
-0.03189738467335701,
0.06507676839828491,
-0.014178311452269554,
-0.02348807454109192,
0.0651988610625267,
0.026158908382058144,
-0.017017025500535965,
0.0112709179520607,
-0.020313598215579987,
-0.00048695021541789174,
-0.011125929653644562,
... | |
313548e2f973d09dd289541bf919584431fa83fc | subsection | 12 | 91 | Object Instantiation | Object instantiation through the new statement follows the pattern of the mechanics known from the construct/destruct blocks from Roopl, but providing improved scoping and lifetime options objects. The mechanisms of the statement\textbf {construct}\ c\ x\ \quad s\ \quad \textbf {destruct}\ xare as follows:Memory for an... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.008865978568792343,
-0.014924143441021442,
-0.034273646771907806,
0.044680871069431305,
-0.014817324467003345,
-0.029039515182375908,
0.04696984961628914,
0.007587965577840805,
0.03998083621263504,
0.0003340478870086372,
0.00664185406640172,
-0.04593218117952347,
-0.0024873572401702404,
... | |
dd5c3237920bb8b8de846c8becb5d22d0b8a99fb | subsection | 13 | 91 | Array Model | Besides asymmetric object lifetimes, also introduces reversible, fixed-sized arrays of either integer or object types. While Roopl only featured integers and custom data types in form of classes, one of its main inspirations, Janus, implemented static, reversible arrays .While Roopl by design did not include any data s... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.06592124700546265,
-0.0008063717395998538,
-0.015885189175605774,
0.0630524531006813,
-0.039705343544483185,
0.00011003565305145457,
0.049349378794431686,
0.02620064467191696,
-0.011978745460510254,
0.013985375873744488,
-0.016220899298787117,
0.015160361304879189,
-0.010368863120675087,
... | |
38fbad49b1175816890850b7111e36c40284dade | subsection | 14 | 91 | Array Instantiation | Array instantiation uses the new and delete keywords to reversibly construct and destruct array types. The mechanisms of the statement\textbf {new}\ \textbf {int}[e]\ xin which we reserve memory for an integer array are as followsThe expression e is evaluated
Memory equal to the integer value that e evaluates to and a... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
0.0032039140351116657,
-0.0018298545619472861,
-0.030666034668684006,
0.05803661420941353,
-0.011480691842734814,
-0.058555345982313156,
0.05623631924390793,
0.05416140705347061,
0.029186131432652473,
0.0341445691883564,
-0.01580597646534443,
-0.015172821469604969,
-0.018033459782600403,
0... | |
88d208f8712591bdc999e05b9f4f7e59e9afc102 | subsection | 15 | 91 | Array Instantiation | As with regular assignment, we still prohibit the left side reference to occur in the ride side, meaning the following statements are also prohibitedx\ \texttt {+=}\ y[x]\\
y[x]\ \texttt {+=}\ x | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.026014994829893112,
0.029646413400769234,
-0.026106543838977814,
0.025099510326981544,
-0.01718057692050934,
-0.027113575488328934,
0.01370173878967762,
0.0708584412932396,
0.01493764203041792,
0.000684705504681915,
-0.01375514268875122,
-0.010756933130323887,
-0.010322079062461853,
0.0... | |
18c053e9dc4027b1447a5760d93d8065f07a2780 | subsection | 16 | 91 | Referencing | Besides the addition of dynamically lifetimed objects and arrays, also increases program flexibility by allowing multiple references to objects and arrays through the usage of the copy statement. Once instantiated through either a new or construct/destruct block, an object or array reference can be copied into another ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.033666063100099564,
0.010049456730484962,
-0.04157133027911186,
0.056649331003427505,
-0.0035138761159032583,
-0.021472414955496788,
0.050178609788417816,
0.04444042220711708,
0.029667643830180168,
0.004856856074184179,
-0.022632261738181114,
-0.0018628122052177787,
0.00004453151268535293... | |
cb27067e9076e1ff033b8c61b246fe9e3bfec717 | subsection | 17 | 91 | Local Blocks | The local block presented in the extended Janus in consisted of a local variable allocation, a statement and a local variable deallocation. These local variable blocks add immense programmer usability as the introduce a form of reversible temporary variable. The Roopl compiler features support for local integer blocks... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.02258840762078762,
0.01813177578151226,
-0.017460228875279427,
0.060744501650333405,
-0.02867812104523182,
0.00684138759970665,
0.05589104816317558,
0.03223427012562752,
0.023321004584431648,
0.006055372301489115,
-0.007200055290013552,
0.011759708635509014,
-0.012934915721416473,
0.016... | |
40807b15d7c912c287475193c140455fc12dcc31 | subsection | 18 | 91 | Expressiveness | By introducing dynamic lifetime objects and by allowing objects to be referenced multiple times, we can express non-trivial reversible programs. To demonstrate the capacities, expressiveness and possibilities of , the following section presents previously unseen reversible data structures, which now are feasible, writt... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.03960252180695534,
0.014538213610649109,
0.023965932428836823,
0.06999089568853378,
-0.017802828922867775,
-0.03392758220434189,
0.06950272619724274,
0.031013838946819305,
-0.003954912535846233,
0.044819802045822144,
-0.01305845845490694,
0.018138442188501358,
0.003617391223087907,
0.01... | |
2a0ea7443752a0e1cbb41b040e7c9499a75c98bd | subsection | 19 | 91 | Linked List | presented a linked list implemented in Roopl in . The implementation featured a ListBuilder and a Sum class, required to determine and retain the sum of a constructed linked list as the statically scoped object blocks of Roopl would deallocate automatically after building the full list. In , we do not face the same cha... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.04757961630821228,
-0.012856262736022472,
-0.020615799352526665,
0.01741127111017704,
-0.028718678280711174,
0.008507260121405125,
0.06921780854463577,
0.03787447139620781,
-0.021500859409570694,
0.020280085504055023,
-0.04071277007460594,
0.013008859008550644,
-0.002115370240062475,
0.... | |
4d3e2ee4e9936b598be863c9abf2b894d83a7381 | subsection | 20 | 91 | Binary Tree | Figures REF , REF and REF shows the implementation of a binary tree in form of a rooted, unbalanced, min-heap. The Tree class shown in figure REF has a single root node field and the three methods insertNode, sum and mirror. For insertion, the insertNode method is called from the root, if it is initialized and if not, ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.055918797850608826,
-0.02632639929652214,
-0.03345360606908798,
0.007180620916187763,
0.01675732620060444,
0.039558276534080505,
0.058085955679416656,
0.053476929664611816,
0.006734216585755348,
0.020145418122410774,
-0.033178895711898804,
0.01660470850765705,
0.00040705763967707753,
0.... | |
7caf900cd11430754d145e0c2df30be88e567c55 | subsection | 21 | 91 | Doubly Linked List | Finally, we present the reversible doubly linked list, shown in figures REF -REF . A cell in a doubly linked list contains a reference to itself named self, a reference to its left and right neighbours, a data and an index field. As with the linked list and binary tree implementation the DoubleLinkedList class has a fi... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.06602296978235245,
-0.006426103413105011,
-0.03719131276011467,
0.02771805226802826,
-0.012958990409970284,
-0.011677583679556847,
0.07560300827026367,
0.025445081293582916,
-0.010640254244208336,
0.02060929499566555,
-0.04826632887125015,
0.02799263969063759,
-0.01321069523692131,
0.01... | |
b43e5e39487dc087ed2e9bf1cda103dd48c910c1 | subsection | 22 | 91 | Type System | The type system of expands on the type system of Roopl presented by and is analogously described by syntax-directed inference typing rules in the style of . As introduces two new types in form of references and arrays, a few Roopl typing rules must be modified to accommodate these added types. For completeness all ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.04708652198314667,
-0.00504280487075448,
0.002868524519726634,
0.05303718522191048,
-0.035002101212739944,
-0.007590909022837877,
0.04690342769026756,
0.04003727808594704,
-0.008872590027749538,
-0.020354317501187325,
-0.017226405441761017,
-0.008895477280020714,
-0.011046870611608028,
... | |
452ceed3a70bcebc261a86128fe7745812191781 | subsection | 23 | 91 | Preliminaries | The types in are given by the following grammar:\tau ::= \textbf {int}\ |\ c \in \text{ClassIDs}\ |\ r \in \text{ReferenceIDs}\ |\ i \in \text{IntegerArrayIDs}\ |\ o \in \text{ClassArrayIDs}The type environment \Pi is a finite map pairing variables to types, which can be applied to an identifier x using the \Pi (x) not... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.037836767733097076,
-0.009779583662748337,
-0.05080501362681389,
0.030742373317480087,
-0.012647855095565319,
-0.049279339611530304,
0.03588390350341797,
0.06902159005403519,
0.018216572701931,
0.012426631525158882,
-0.0019366551423445344,
-0.008307306095957756,
0.02003212831914425,
0.0... | |
f6b0d060dc6436e098c088b294802a8f2ed50060 | subsection | 24 | 91 | Preliminaries | We define a location for integer variables to bind to a single location in program memory and a vector of memory locations for object and array variables, where the vector is the size of the object or array. A memory location is in the set of non-negative integers, \mathbb {N}_0. An environment \gamma is a partial func... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.019776249304413795,
-0.0194100234657526,
-0.033753909170627594,
0.012123635038733482,
-0.009880495257675648,
-0.04001028463244438,
-0.0008740804623812437,
0.039247311651706696,
0.03854537755250931,
-0.009911013767123222,
0.011505627073347569,
0.0152747118845582,
-0.005836740601807833,
-... | |
4c70aeba5acff270f443864762bc96110eaee0f8 | subsection | 25 | 91 | Expressions | The type judgment\Pi \vdash _{expr}\ e : \taudefines the type of expressions. The judgment reads as: under type environment \Pi , expression e has type \tau .
[Figure: Typing rules for expressions in Roopl, originally from]The original expression typing rules from Roopl are shown in figure REF . The type rules T-Con, T... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.07074909657239914,
-0.009896633215248585,
0.004536274820566177,
0.05829628184437752,
-0.001173174474388361,
0.005039881449192762,
-0.002668733475729823,
0.06751380860805511,
0.03241395205259323,
0.010301044210791588,
-0.015428675338625908,
-0.011766081675887108,
0.006756721995770931,
-0... | |
36285e93243e1dd5a251a800e0e8ffeba0763df1 | subsection | 26 | 91 | Statements | The type judgment\langle \Pi ,\ c\rangle \ \vdash _{stmt}^\Gamma \ sdefines well-typed statements. The judgment reads as under type environment \Pi within class c, statement s is well-typed with class map \Gamma .
[Figure: Typing rules for statements in Roopl, originally from]Typing rule T-AssVar defines variable assig... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.04252132773399353,
-0.01249235775321722,
-0.03656895458698273,
0.07973130792379379,
0.0013230681652203202,
-0.02370266430079937,
-0.007677038200199604,
0.018543940037488937,
0.013118119910359383,
0.019841251894831657,
-0.006780366413295269,
-0.0021577361039817333,
0.0006658266065642238,
... | |
d405b815f2f571eb84ea5e4c7795ba4e0860e9ef | subsection | 27 | 91 | Statements | A well-typed copy or uncopy statement requires that the types of x and x^{\prime } both are c^{\prime } under type environment \PiThe rule T-LocalBlock defines well-typed local blocks. A local block is well-typed if its two expression e_1 and e_2 are well-typed and its body statement s is well-typed.The judgment
\gamm... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.0385834276676178,
0.022466300055384636,
-0.03369944915175438,
0.03885815292596817,
0.014957183972001076,
-0.049572382122278214,
-0.012973067350685596,
0.008707217872142792,
0.007657925598323345,
0.019245928153395653,
-0.019612226635217667,
0.0026442164089530706,
-0.01816229522228241,
0.... | |
65eb23aeb50d61da6840eac7d8a32455150e2c88 | subsection | 28 | 91 | Statements | If any of these conditions fail, the object block statement is undefined.Figure REF shows the extensions to the semantics of Roopl with rules for new/delete and copy/uncopy statements, array element assignment and local blocks.Rule AssArrElemVar defines reversible assignment to array elements. After evaluating expressi... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.018295299261808395,
0.014564523473381996,
-0.011688239872455597,
0.04776003956794739,
-0.008216863498091698,
-0.018219005316495895,
0.022247329354286194,
0.01538849901407957,
0.0032062551472336054,
0.010353094898164272,
0.00020837796910200268,
-0.011108405888080597,
-0.018264781683683395,... | |
6f43a2b51df1f7de06dcd16df536876161aafdbc | subsection | 29 | 91 | Programs | As with Roopl, a program is well-typed if all of its classes and their respective methods are well-typed and if there exists a nullary main method. Figure REF shows the typing rules for class methods, classes and programs.
[Figure: Typing rules for class methods, classes and programs, originally from]The judgment
\vda... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.03371356055140495,
-0.03136428818106651,
0.008718235418200493,
0.010525953024625778,
-0.020777316763997078,
-0.03073883429169655,
0.02462157793343067,
0.04308013245463371,
-0.004648962523788214,
0.014400724321603775,
0.006407102104276419,
-0.022424856200814247,
-0.007333843503147364,
-0... | |
3ae414d3ddf62243ddbc803df0bbb04c2bdc4b86 | subsection | 30 | 91 | Language Semantics | The following sections contain the operational semantics of , as specified by syntax-directed inference rules. | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.02659589797258377,
0.02265915647149086,
-0.011421130038797855,
0.03048686496913433,
-0.024658044800162315,
-0.020233023911714554,
0.005371059291064739,
0.02249130979180336,
0.0195158664137125,
0.016189470887184143,
0.0003321149561088532,
-0.009933407418429852,
-0.023513643071055412,
0.0... | |
db099bd3f983831d7e091a00ce52907b55aeefaf | subsection | 31 | 91 | Program Inversion | In order to truly show that in fact is a reversible language, we must demonstrate and prove local inversion of statements is possible, such that any program written in , regardless of context, can be executed in reverse. presented a statement inverter for Roopl in , which maps statements to their inverse counterparts. ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.029082894325256348,
0.024749452248215675,
-0.0033683362416923046,
0.04321236163377762,
-0.0149381710216403,
-0.02351350523531437,
0.016708169132471085,
0.03213461488485336,
0.022460661828517914,
-0.008170980960130692,
-0.0390620194375515,
0.019042734056711197,
-0.018264546990394592,
-0.... | |
74562ec48e2cc412ca5d4b3abfd8e39672d637b2 | subsection | 32 | 91 | Invertibility of Statements | While the invertibility of statements remains untouched by the extensions made in , the following proof, originally presented in , has been included for completeness.If execution of a statement s in store \mu yields \mu ^{\prime }, then execution of the inverse statement, \mathcal {I} \llbracket s \rrbracket in store \... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.0072758132591843605,
0.04538703337311745,
0.005925190635025501,
0.028614891692996025,
-0.007523809093981981,
-0.03586399927735329,
-0.021518399938941002,
0.042853664606809616,
0.027165072038769722,
0.014307445846498013,
-0.04373881593346596,
-0.002153747482225299,
-0.02513532154262066,
... | |
9ac2920d3f5da510e3e03316e55e195c663a45a7 | subsection | 33 | 91 | Type-Safe Statement Inversion | Given a well-typed statement, the statement inverter \mathcal {I} should always produce a well-typed, inverse statement in order to correctly support backwards determinism of injective functions. Theorem REF describes this.(Inversion of well-typed statements, originally from )\overbrace{\langle \Pi ,\ c\rangle \ \vdash... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.007596564944833517,
0.04368787631392479,
-0.010060110129415989,
0.050582751631736755,
0.014750760048627853,
-0.06870467960834503,
-0.014987198635935783,
0.03000490553677082,
-0.0027857886161655188,
0.030935408547520638,
-0.05317595601081848,
0.014903301373124123,
-0.02577950805425644,
0... | |
859c72fb716b756454b287ad02f6cf595bab4718 | subsection | 34 | 91 | Type-Safe Statement Inversion | \mathcal {E}_2 in construction of \mathcal {T}^{\prime }
{\overbrace{\Pi (x) = \textbf {int}[\ ]}^{\mathcal {C}_1}}
\\
{\overbrace{\Pi \vdash _{expr} e_1\ :\ \textbf {int}}^{\mathcal {E}_1}}
{\overbrace{\Big ( {\ x\ } \cup \text{vars}(e_1) \Big ) \cap \text{vars}(e_2) = \emptyset }^{\mathcal {C}_2}}
{\overbrace{\Pi \v... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.030371718108654022,
0.04670223966240883,
-0.022160669788718224,
0.045084450393915176,
0.026327243074774742,
-0.04886946827173233,
-0.003527469001710415,
0.04447396099567413,
-0.008165260776877403,
0.035713475197553635,
-0.03195898234844208,
-0.026311980560421944,
0.003317614085972309,
0... | |
b3505572a12d94ee4732575749dec1dde2c3481d | subsection | 35 | 91 | Type-Safe Statement Inversion | Using \mathcal {C}_1 and \mathcal {E}, \mathcal {T}^{\prime } must be of the form:
\mathcal {T}^{\prime } = {\overbrace{\text{arrayType}(a) \in \Big \lbrace \text{classIDs}, \textbf {int} \Big \rbrace }^{\mathcal {C}_1}}
{\overbrace{\Pi \vdash _{expr}\ e = \textbf {int}}^{\mathcal {E}}}
{\overbrace{\Pi (x) = a[\ ]}^{\... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.013641800731420517,
0.04153577238321304,
-0.021866554394364357,
0.020462701097130775,
0.016617361456155777,
-0.03860599175095558,
0.028550121933221817,
0.029221531003713608,
0.0034905613865703344,
0.02919101156294346,
-0.022797372192144394,
-0.0260933768004179,
0.01643425039947033,
0.00... | |
6793d52f2f93377099640052763c8d71cad7beca | subsection | 36 | 91 | Type-Safe Statement Inversion | Using \mathcal {C}_1, \mathcal {T}^{\prime } must as such be of the form
\mathcal {T}^{\prime } = {\overbrace{\Pi (x) = c^{\prime }}^{\mathcal {C}_1}}
{\overbrace{\Pi (x^{\prime }) = c^{\prime }}^{\mathcal {C}_3}}
{\langle \Pi , c \rangle \vdash ^{\Gamma }_{stmt}\ \textbf {uncopy}\ c^{\prime }\ x\ x^{\prime }}
Case ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.01965307630598545,
0.06787025183439255,
-0.030410390347242355,
0.011405803263187408,
0.011817785911262035,
-0.04067942872643471,
0.0397333949804306,
0.018951181322336197,
0.010421623475849628,
0.03329426422715187,
-0.04327338933944702,
0.0098952017724514,
0.018050923943519592,
0.0024661... | |
e29e7a6f532105326b7c45fd722b6e8ce54a1388 | subsection | 37 | 91 | Type-Safe Statement Inversion | By the induction hypothesis on \mathcal {S}, we obtain \mathcal {S^{\prime }} of \langle \Pi [x \mapsto c^{\prime }], c \rangle \vdash ^{\Gamma }_{stmt}\ \mathcal {I} \llbracket s \rrbracket . Using \mathcal {E}_1, \mathcal {S^{\prime }} and \mathcal {E}_2 we construct \mathcal {T}^{\prime }
\mathcal {T}^{\prime } = {... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.036957692354917526,
0.034150008112192154,
-0.0067598093301057816,
0.032288387417793274,
0.005134708248078823,
-0.06262360513210297,
0.01332887914031744,
0.028916113078594208,
0.0036488473415374756,
0.02862618863582611,
-0.042878247797489166,
0.03549281135201454,
0.006588143762201071,
0.... | |
81d7e3ccf3e34a529933fa00a44925053b0f84dc | subsection | 38 | 91 | Computational Strength | Traditional, non-reversible programming languages have their computational strength measured in terms of their abilities to simulate the Turing machine (TM). If any arbitrary Turing machine can be implemented in some programming language, the language is said to be computationally universal or Turing-complete. In essen... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.01865636371076107,
0.027671827003359795,
0.008771389722824097,
0.04179757833480835,
0.0027668012771755457,
-0.026542987674474716,
0.02913626655936241,
0.018961455672979355,
-0.020181823521852493,
0.04646548256278038,
-0.02588704042136669,
0.023171722888946533,
0.0055602979846298695,
0.0... | |
2e4e774f08322a9d221d76e4fb8af2bc5692b5d5 | subsection | 39 | 91 | Reversible Turing Machines | Before we show that in fact is r-Turing complete, we present the formalized reversible Turing machine definition, as defined in .(Quadruple Turing Machine)A TM T is a tuple (Q,\ \Gamma ,\ b,\ \delta ,\ q_s,\ q_f) where[label = , itemsep = 1pt]
Q is the finite non-empty set of states
\Gamma is the finite non-empty set ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.0109344981610775,
0.01537544559687376,
-0.012903166003525257,
0.025577416643500328,
-0.0007950020954012871,
-0.009385507553815842,
0.011476263403892517,
0.050666481256484985,
-0.026279421523213387,
0.05243675783276558,
-0.013643323443830013,
0.012994731776416302,
0.024768583476543427,
0... | |
5b0a2d00e1d5cffdd9ac8cb1c55faebce49efa05 | subsection | 40 | 91 | Reversible Turing Machines | As Roopl contains no array or stack primitives, the transition table \delta was suggested to be represented as a linked list of objects containing four integers {\textbf {q1}}, {\textbf {s1}}, {\textbf {s2}} and {\textbf {q2}} each, where {\textbf {s1}} equals SLASH for shift rules. In , we do, however, have an array p... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.054133735597133636,
0.002055953023955226,
-0.03310885280370712,
0.01595938205718994,
-0.03777765855193138,
0.03417687863111496,
0.04327037185430527,
0.052028197795152664,
0.021940337494015694,
-0.016050927340984344,
-0.005519413389265537,
0.0034825324546545744,
-0.0064005362801253796,
0... | |
af7cf884e1401b426893111fc1c149cd79fd10a1 | subsection | 41 | 91 | Tape Representation | As with regular Turing machines, the Reversible Turing machines also have tapes of infinite length. Therefore, we must simulate tape growth in either direction.
represented the tape using two stack primitives in the Janus RTM interpreter and used list of objects. In , we could implement a stack, as objects are not sta... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.027477312833070755,
0.013715771026909351,
-0.008223360404372215,
0.06957054138183594,
-0.021984901279211044,
0.016126329079270363,
-0.0028720733243972063,
0.020077813416719437,
-0.010725458152592182,
0.06694638729095459,
-0.043878260999917984,
0.00812419131398201,
-0.009077735245227814,
... | |
62536fb2728c23e6a953ca5e2f45fd9253a42e77 | subsection | 42 | 91 | Reversible Turing Machine Simulation | Figure REF shows the modified method inst from , which executes a single instruction given the tape head, the current state, symbol, program counter and the four arrays representing the transition rules. As described above, we call moveRight to move the tape head right and uncall to move the tape head left.
[Figure: Me... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.02136613242328167,
0.00839383713901043,
0.0020641209557652473,
0.017092905938625336,
-0.024586312472820282,
0.026967110112309456,
-0.014383984729647636,
0.05311010032892227,
-0.019229518249630928,
0.014483184553682804,
-0.03156082704663277,
-0.012026079930365086,
0.0038497191853821278,
... | |
dac80ce156d66f47936a2bff1a8a1067175bb279 | subsection | 43 | 91 | Dynamic Memory Management | In order to allow objects to live outside of static scopes, we need to utilize a different memory management technique, such that objects are not allocated on the stack. Dynamic memory management presents a method of storing objects in different memory structures, most commonly, a memory heap. Most irreversible, modern... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.04898035526275635,
-0.03417943790555,
0.0027751720044761896,
0.037872038781642914,
0.0070037334226071835,
-0.02970864623785019,
0.028838900849223137,
0.015960577875375748,
0.0160521287471056,
0.018203603103756905,
-0.06018022820353508,
-0.0046500819735229015,
-0.011192240752279758,
0.01... | |
8d03ea886b629130f2942150788591517e33ad11 | subsection | 44 | 91 | Fragmentation | Efficient memory usage is an important matter to consider when designing a heap layout for a dynamic memory manager. In a stack allocating memory layout, the stack discipline is in effect, meaning only the most recently allocated data can be freed. This is not the case with heap allocation, where data can be freed rega... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.03149082139134407,
-0.017530500888824463,
-0.03283345326781273,
0.006720788311213255,
-0.020612452179193497,
-0.026532238349318504,
0.004096553195267916,
0.028149498626589775,
0.038295526057481766,
0.00906276609748602,
-0.025616807863116264,
-0.00817784946411848,
-0.017362672835588455,
... | |
389f55b203806bcf726cef47b79a02e4a162b742 | subsection | 45 | 91 | Internal Fragmentation | Internal fragmentation occurs in the memory heap when part of an allocated memory block is unused. This type of fragmentation can arise from a number of different scenarios, but mostly it originates from cases of over-allocation, which occurs when the memory manager delegates memory larger than required to fit an objec... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
0.001595972920767963,
0.0014089969918131828,
-0.04206576198339462,
0.009776168502867222,
-0.013996481895446777,
-0.013759899884462357,
-0.00995169673115015,
0.024192392826080322,
0.018560219556093216,
-0.013355421833693981,
-0.013218051753938198,
-0.0015311036258935928,
-0.038799408823251724... | |
56fcfdcf1556e1bc57c12218ce6004705f529b69 | subsection | 46 | 91 | External Fragmentation | External fragmentation materializes in the memory heap when a freed block becomes partly or completely unusable for future allocation if, say, it is surrounded by allocated blocks but the size of the freed block is too small to contain objects on its own.This type of fragmentation is generally a more substantial cause ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.001735163270495832,
-0.0056662289425730705,
-0.01768931746482849,
0.009134647436439991,
-0.025946367532014847,
-0.0024286562111228704,
-0.0010035139275714755,
0.023611193522810936,
0.02593110501766205,
0.01471311692148447,
-0.014033932238817215,
0.00716196047142148,
-0.03400500491261482,
... | |
88955862a9391212850137c2a36b0ab30694afdf | subsection | 47 | 91 | Memory Garbage | A reversible computation should be garbage-free and as such it should be our goal to return the memory to its original state after program termination.Traditionally, in non-reversible programming languages, freed memory blocks are simply re-added to the free list during deallocation and no modification of the actual da... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.0264916829764843,
-0.0011359300697222352,
-0.01750343292951584,
0.04846635088324547,
0.04794750362634659,
-0.023897452279925346,
0.03351137042045593,
0.025621851906180382,
0.017106669023633003,
0.034762702882289886,
-0.04843582957983017,
0.0014716541627421975,
-0.003181748790666461,
0.0... | |
0131d20f8db6f93d82e478a902cf3165dd683143 | subsection | 48 | 91 | Linearity and Reference Counting | Programming languages use different approaches for storing and synchronizing variables and objects in memory. Typing linearity is a distinction, which can reduce storage management and synchronization costs .Reversible programming languages such as Janus and Roopl are linear in the sense that object and variable pointe... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.044501468539237976,
0.00858438853174448,
-0.027225865051150322,
0.05344449356198311,
-0.020236264914274216,
0.019808953627943993,
0.04270065575838089,
0.004215888679027557,
0.006764498073607683,
0.018176011741161346,
-0.030766448006033897,
-0.016817770898342133,
-0.01197236031293869,
0.... | |
704d1e068c8ba14e120af785ccf66f961f6008bb | subsection | 49 | 91 | Heap Manager Layouts | Heap managers can be implemented in numerous ways. Different layouts yield different advantages when allocating memory, finding a free block or when collecting garbage. As our goal is to construct a garbage-free heap manager, our finalized design should emphasize and reflect this objective in particular. Furthermore, w... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.05629310756921768,
-0.006895524449646473,
-0.012570601888000965,
0.06474470347166061,
-0.010183102451264858,
-0.0027841441333293915,
0.022334175184369087,
0.007902393117547035,
0.0118154501542449,
0.009283022955060005,
-0.02965685725212097,
-0.010739931836724281,
0.0060755363665521145,
... | |
18cb1515fa9014d69208fa4d84aff23681568b2d | subsection | 50 | 91 | Memory Pools | The simplest heap layout we can design uses fixed-sized blocks. This design is also known as memory pools, as memory is allocated from "pools" of fixed-sized blocks regardless of the record size.
To model these pools of fixed-sized blocks, we simply use a linked list of identically sized free block cells, which we main... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.011369657702744007,
-0.011514640413224697,
-0.03391057625412941,
0.027485575526952744,
-0.001116935396566987,
-0.01983967237174511,
0.03610820323228836,
0.030583616346120834,
0.017535217106342316,
0.020343294367194176,
-0.009431474842131138,
-0.007912976667284966,
-0.008012175559997559,
... | |
115eae59da558c13d961846be372f137e2b1339e | subsection | 51 | 91 | One Heap Per Record Size | Instead of allocating space for objects from a single free list and heap, we could design an approach which uses one heap per record size, known as a multi-heap layout. The respective classes and their sizes are easily identified during compile time from which the amount of heaps and free list will be initialized. This... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.014112562872469425,
-0.012625022791326046,
-0.06542126834392548,
0.04494660720229149,
-0.010145788080990314,
0.004420665092766285,
0.023571794852614403,
0.012213088572025299,
0.006854128558188677,
-0.0041765556670725346,
-0.02822512574493885,
0.0007833425770513713,
-0.026775727048516273,
... | |
8a9af27ac86368c38951295a920e5f05f99ebd05 | subsection | 52 | 91 | One Heap Per Record Size | In real world object-oriented programming, most classes feature a small number of fields, very rarely more than 16.Additionally, helper classes of other sizes would spawn additional heaps and bookkeeping work, making the encapsulation concept of OOP rather unattractive, for the optimization-oriented reversible programm... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.02883194386959076,
-0.013370451517403126,
-0.020834093913435936,
0.02486354485154152,
-0.014912021346390247,
-0.03302928805351257,
0.03002246282994747,
0.026084590703248978,
0.0075781154446303844,
-0.005769441369920969,
-0.05421443283557892,
-0.009394421242177486,
-0.009203632362186909,
... | |
c692704e68808e25dead5159d368d858c2342201 | subsection | 53 | 91 | One Heap Per Power-Of-Two | To address the issues of the previous heap manager layout, we can optimize the amounts of heaps required by introducing a relatively small amount of internal fragmentation. Instead of having a heap per record size, we could have a heap per power-of-two. Records would be stored in the heap closest to their respective si... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.01165783405303955,
-0.002000829204916954,
-0.044006794691085815,
0.0482182651758194,
0.004356428515166044,
-0.02166770212352276,
0.003498113015666604,
0.012199526652693748,
0.006610937882214785,
0.0073433672077953815,
-0.034851428121328354,
0.00651175482198596,
-0.01687639206647873,
-0.... | |
2ff56ee8dd341f693f8377624fd155813e886321 | subsection | 54 | 91 | Shared Heap, Record Size-Specific Free Lists | A natural proposal, considering the disadvantages of the previously presented designs, would be using a shared heap instead of record-specific heaps.
This way, we ensure minimal fragmentation when allocating and freeing as the different free lists ensure that allocation of an object wastes as little memory as possible.... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.013906163163483143,
-0.024776313453912735,
-0.03988010063767433,
0.05226825550198555,
-0.002116818679496646,
-0.015370773151516914,
0.01623275689780712,
0.05089518427848816,
0.021633503958582878,
0.005888951011002064,
-0.008749516680836678,
-0.0027156302239745855,
-0.016873523592948914,
... | |
7f90f9e3d6a7fadf31210b5da3217cc28425dcee | subsection | 55 | 91 | Buddy Memory | The Buddy Memory layout utilizes blocks of variable-sizes of the power-of-two, typically with one free list per power-of-two using a shared heap. When allocating an object of size m, we simply check the free lists for a free block of size n, where n \ge m. Is such a block found and if n > m, we split the block into two... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.022585704922676086,
0.013139385730028152,
-0.06223277002573013,
0.039647068828344345,
0.003181837499141693,
0.008683287538588047,
0.03271875157952309,
0.005886780563741922,
0.02232627384364605,
0.007073292974382639,
-0.05017688870429993,
-0.006749005056917667,
-0.007920256815850735,
0.0... | |
7ff83630bc4e1999c8645accdbe608dee789dd92 | subsection | 56 | 91 | Buddy Memory | The body of the allocation function is still executed recursively until a free list for a 2^n larger than the size of the object has been found. Once found, we continue searching until we have found a non-empty free list. If the non-empty free list for a 2^n larger than the object is found, the head of the list is popp... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.010866883210837841,
0.016895560547709465,
-0.01683451049029827,
0.05482281371951103,
-0.010950827039778233,
-0.008264631032943726,
0.0305707398802042,
-0.012744167819619179,
-0.016910823062062263,
0.02666354551911354,
-0.005376207176595926,
-0.00811963714659214,
-0.006001968868076801,
0... | |
70876f28244b6ce945e7b65428fc81c71bc8b143 | subsection | 57 | 91 | Compilation | The following chapter presents the considerations and translation schemas used in the process of translating to the reversible low-level machine language Pisa. As is an extension of Roopl, many techniques are carried directly over, and have as such been left out.Before presenting the compiler, a brief overview of the m... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.06559302657842636,
0.013812670484185219,
0.001875312183983624,
0.0731591060757637,
-0.022774508222937584,
-0.02176773175597191,
0.04548799991607666,
0.052230354398489,
0.009388955309987068,
0.016459273174405098,
-0.026786360889673233,
0.03944734111428261,
0.00936607364565134,
0.03055414... | |
059b23e78553f33ee76c4458fd7be7642ff418eb | subsection | 58 | 91 | Memory Layout | builds upon the memory layout of its predecessor with dynamic memory management. The reversible Buddy Memory heap layout presented in section REF is utilized in as it is an interesting layout, addressing a number of disadvantages found in other considered layouts, naturally translates into a reversible setting with one... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.046081043779850006,
-0.021606210619211197,
-0.007240216713398695,
0.04177810996770859,
0.0070380400866270065,
-0.0070609282702207565,
0.04989570006728172,
0.025191986933350563,
0.04061845690011978,
0.014015045948326588,
-0.041717078536748886,
0.012939312495291233,
-0.0019149573054164648,
... | |
9b058bd24e22dabfaf588f6c1b6c3928d6ea5a11 | subsection | 59 | 91 | Inherited | As mentioned, a number of features from Roopl carries over to .The dynamic dispatching mechanism presented in is inherited. As such, the invocation of a method implementation is based on the type of the object at run time. Virtual function tables are still the implementation strategy used in the dynamic dispatching im... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.05212017148733139,
-0.013731895014643669,
-0.005847498774528503,
0.04366742819547653,
-0.027952035889029503,
-0.039181675761938095,
0.06731680035591125,
0.007205430418252945,
-0.01609683223068714,
0.009886964224278927,
0.010039540939033031,
0.02915739081799984,
-0.008605320937931538,
0.... | |
d24ae2d24527fb00faea59c49d73327babaf8015 | subsection | 60 | 91 | Program Structure | The program structure of a translated is analogous to the program structure of a Roopl program with the addition of free lists and heap initialization. The full structure is shown in figure REF .
[Figure: Overall layout of a translated program]The following Pisa code block initializes the free lists pointer, the heap p... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
0.019669830799102783,
-0.017670800909399986,
-0.013642225414514542,
0.04977733641862869,
0.0248123686760664,
0.01373378373682499,
0.05905526876449585,
0.03930914029479027,
0.03775264695286751,
0.01256641186773777,
-0.015557324513792992,
0.012627450749278069,
-0.021562039852142334,
0.022309... | |
8cf911bb50fd255f380edf2056a353050bc93e4a | subsection | 61 | 91 | Buddy Memory Translation | As briefly mentioned in section , the Buddy Memory layout was selected as the memory manager layout as it addressed a number of problems related to fragmentation and initialization. The Buddy Memory layout could be converted to a reversible section with only a few restrictions and side effects, which will be described ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.051143843680620193,
0.01270204409956932,
-0.03667953610420227,
0.019606158137321472,
0.0014361320063471794,
0.004985456820577383,
0.052944254130125046,
0.03228531405329704,
0.030561193823814392,
0.03979210928082466,
-0.058406516909599304,
0.011420396156609058,
0.0011128592304885387,
0.0... | |
e502b11ee53489611256b7f9fa88302d21fe2961 | subsection | 62 | 91 | Buddy Memory Translation | This statement translates easily using the exch instructions to swap with memory locations as simulated in the Janus code.
[Figure: Pisa translation of the inner else statement for the Buddy Memory algorithm]The last statement translation is the inner else statement shown in figure REF . This statement is almost identi... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.024386215955018997,
0.010033752769231796,
-0.01526045985519886,
0.02078474685549736,
-0.010377112776041031,
-0.003723552217707038,
0.022677043452858925,
0.007065592799335718,
0.03702187538146973,
0.04092855378985405,
-0.04217991232872009,
0.0030253862496465445,
0.012658551335334778,
0.0... | |
74e7de87693860520f94886bdcdf3ee7bb626e21 | subsection | 63 | 91 | Object Allocation and Deallocation | Now that we have the main allocation mechanism in place and a method of accessing it through a label and a swapbr instruction, we can continue translating the malloc procedure entry point from listing on page .
[Figure: Pisa translation of the malloc procedure entry point of Buddy Memory algorithm]Figure REF shows the... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.032470207661390305,
0.00862871389836073,
-0.010352930054068565,
0.05697545036673546,
-0.008315913379192352,
0.0077017564326524734,
0.01121503859758377,
-0.006938828621059656,
0.04464653506875038,
0.023193005472421646,
-0.0317988321185112,
0.00047611462650820613,
0.033873993903398514,
0.... | |
b530c607890fa805f8d8d1d599607c560a4dac4b | subsection | 64 | 91 | Arrays | The fixed-sized arrays in are also heap allocated to allow dynamic lifetime. The array memory layout is presented in figure REF . As shown, the arrays feature two additional fields to store the size of the array and the reference count. Additionally, integer arrays store their values directly in the array, while object... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.026842039078474045,
-0.01567184366285801,
-0.0356774777173996,
0.038912564516067505,
-0.026765739545226097,
-0.02813912369310856,
0.035524882376194,
0.05121198669075966,
0.018342314288020134,
0.007912221364676952,
-0.009903628379106522,
0.014985151588916779,
-0.01779296062886715,
0.0307... | |
8ead39472016e7882960bdd22985bd33ee5e07b8 | subsection | 65 | 91 | Construction and Destruction | As arrays also are heap allocated, the buddy allocation implementation is also used for allocating arrays. The only difference between object and array allocation is that no virtual table is stored in the allocated space while the offsets for the reference counter are shared for both types. Due to this fact, copy and u... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.018950358033180237,
-0.005870491731911898,
-0.04592639207839966,
0.07421460747718811,
-0.03002762235701084,
0.001793761271983385,
0.05602714791893959,
0.03985373303294182,
0.04821508377790451,
0.02567910961806774,
-0.01193170715123415,
-0.007537421304732561,
0.0004992206813767552,
0.039... | |
9ee05128b1e7e0defa49f4c67f8a66fcd8cf735e | subsection | 66 | 91 | Array Element Access | Array elements are simply passed as any other variable to methods or statements. Based on the variable type, compilation of various statements individually determines whether the address or the value of the passed variable should be used for the compiling the statement. For arrays, this is no different. If an integer a... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
0.025592846795916557,
-0.013445019721984863,
-0.051796138286590576,
0.07105563580989838,
-0.021945446729660034,
-0.06977370381355286,
0.03931256756186485,
0.04856078699231148,
0.011026137508451939,
-0.010408063419163227,
-0.00005001583485864103,
-0.0042502135038375854,
0.001528016640804708,
... | |
61b32296157893236ad59e5f3a0610606b4a693e | subsection | 67 | 91 | Error Handling | While a program written in might be syntactically valid and well-typed, this is not a guarantee that it executes successfully. A number of conditions exist, which cannot be determined at compile time, which in turn results in erroneous executed code. describes the following conditions:If the entry expression of a condi... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.047593362629413605,
0.01795429177582264,
-0.01713055931031704,
0.045305218547582626,
-0.02256108447909355,
-0.009381383657455444,
0.027259403839707375,
0.020394977182149887,
-0.0002750537823885679,
0.02115769125521183,
0.0008723543141968548,
-0.020455993711948395,
-0.009991555474698544,
... | |
f82b51870aab1104a8ac42221870f06d5ff2defd | subsection | 68 | 91 | Implementation | The compiler (Rooplppc) was implemented using techniques and translation schemes presented in this chapter, expanding upon the work of the original Roopl compiler (Rooplc). The compiler serves as a proof-of-concept and simply performs one-to-one translations of code to Pisa code without any optimizations along the way.... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.059462908655405045,
-0.002812589518725872,
0.00656334450468421,
0.019144676625728607,
-0.019648082554340363,
0.009541829116642475,
0.02361431159079075,
0.007017172407358885,
-0.00352002726867795,
0.009457928128540516,
-0.022576989606022835,
0.022592244669795036,
-0.008237550035119057,
-... | |
bfa1099b328d912a7f08d3fb07b4d351400a9883 | subsection | 69 | 91 | Evaluation | For evaluating the results of the implemented compiler, it was tested against example code provided throughout this thesis. Tests programs utilizing the linked list, doubly-linked list and binary tree data structures and the RTM implementation are found in appendix .
[Figure: Lines of code comparison between target and... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.04911227524280548,
0.012751182541251183,
-0.020603345707058907,
0.03058452345430851,
-0.005429363343864679,
-0.01266724243760109,
0.021458003669977188,
0.028783638030290604,
-0.013926336541771889,
0.05945973098278046,
-0.04361804947257042,
0.0053835781291127205,
-0.007226433139294386,
0... | |
321408a979423080eb48d1a2c1fca4067ed7e401 | subsection | 70 | 91 | Conclusions | We formally presented a dynamic memory management extension for the reversible object-oriented programing language, Roopl, in the form of the superset language . The extension expands upon the previously presented static typing system defining well-typedness. The language successfully extends the expressiveness of its ... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.08895324170589447,
-0.022619888186454773,
0.0003369802434463054,
0.031029846519231796,
-0.039653487503528595,
-0.012950724922120571,
0.057480767369270325,
-0.00847864244133234,
0.02669513039290905,
0.011905204504728317,
-0.023138832300901413,
0.0022722913417965174,
0.018361488357186317,
... | |
514a0d28f58208702e368d68987d7f94f82c5b5b | subsection | 71 | 91 | Future Work | Naturally with the discovery of feasibility of non-trivial, reversible data structures with the introduction of , further study of design and implementation of reversible algorithms working with these data structures are an obvious contender for future research. Data structures such as lists, graphs and trees could pot... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.06028026342391968,
0.003944923635572195,
-0.010293427854776382,
0.04883464425802231,
-0.008332411758601665,
-0.014734327793121338,
0.02319645695388317,
-0.010323949158191681,
0.043645963072776794,
0.020617377012968063,
-0.051093246787786484,
0.004128053784370422,
0.00046950887190178037,
... | |
ba0f20b9559ad539bb7d0f44646cb9d8640f57c7 | subsection | 72 | 91 | Pisa Translated Buddy Memory | &\textbf {(1)}\quad &&malloc1_{top}\ \texttt {:}\quad &&{bra}\quad &&malloc1_{bot} \quad \quad &&\text{; Receive jump}\\
&\textbf {(2)}\quad && &&{pop}\quad &&r_{ro}&& && &&\text{; Pop return offset from the stack}\\
&\textbf {(3)}\quad && &&\cdots \cdots && && && &&\text{; Inverse of \textbf {(7)}}\\
&\textbf {(4)}\qu... | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.034145746380090714,
0.021466964855790138,
-0.04149974510073662,
0.029904227703809738,
0.020429469645023346,
0.022992689162492752,
0.004985309671610594,
0.00433687586337328,
0.00250981911085546,
-0.010184220969676971,
-0.028820963576436043,
0.013807820156216621,
-0.03509169816970825,
0.0... | |
d4bc3b2b77f00953df81882befe896b80ad88210 | subsection | 73 | 91 | README.md | [style = basic]code/ROOPLPPC/README.md | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.03440256416797638,
0.010638237930834293,
-0.0315331406891346,
-0.020681222900748253,
-0.03428046032786369,
-0.012011897750198841,
0.035959381610155106,
0.026160601526498795,
-0.004346109461039305,
-0.031288933008909225,
-0.026420069858431816,
-0.005342013202607632,
-0.011279279366135597,
... | |
92ae4b0719ff8a61955f80310a3fb4eb2ca748a7 | subsection | 74 | 91 | AST.hs | [style = basic, language = haskell]code/ROOPLPPC/src/AST.hs | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.008141630329191685,
-0.010980136692523956,
-0.019762719050049782,
0.0006128160166554153,
-0.03748049587011337,
0.001155050820671022,
0.034306250512599945,
-0.014825855381786823,
-0.022982746362686157,
-0.02832402102649212,
-0.028751322999596596,
-0.0015737686771899462,
0.01745834015309810... | |
48924851f06457adc5446ed862b2e21cda099744 | subsection | 75 | 91 | PISA.hs | [style = basic, language = haskell]code/ROOPLPPC/src/PISA.hs | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.03679290786385536,
-0.00273429905064404,
-0.003527512541040778,
-0.02092863619327545,
-0.03322344645857811,
0.0020021016243845224,
0.052535150200128555,
0.013804968446493149,
-0.013400734402239323,
-0.009755002334713936,
-0.019860848784446716,
0.028753994032740593,
0.02045575901865959,
... | |
d48a5ff1494e25ff30d045f0df08777e5b783db2 | subsection | 76 | 91 | Parser.hs | [style = basic, language = haskell]code/ROOPLPPC/src/Parser.hs | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.031915005296468735,
-0.014523463323712349,
-0.010610366240143776,
-0.003600354539230466,
-0.028253629803657532,
0.013440306298434734,
0.037864744663238525,
-0.027765445411205292,
-0.018200097605586052,
-0.04372294992208481,
-0.03261677175760269,
0.018566234037280083,
0.012517333962023258,... | |
6fd30f58cd83cc6d9d58eb3fcea4b78c51299f1a | subsection | 77 | 91 | ClassAnalyzer.hs | [style = basic, language = haskell]code/ROOPLPPC/src/ClassAnalyzer.hs | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.0531265065073967,
-0.023557530716061592,
-0.02071964181959629,
0.0070375073701143265,
-0.02486967295408249,
0.010550539940595627,
0.018644627183675766,
0.0031735533848404884,
-0.020643355324864388,
-0.04516210779547691,
-0.023115064948797226,
0.0018308962462469935,
0.025968210771679878,
... | |
9903dc2bfedccfe44530e32c81b58f12a2949bd4 | subsection | 78 | 91 | ScopeAnalyzer.hs | [style = basic, language = haskell]code/ROOPLPPC/src/ScopeAnalyzer.hs | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.06861089915037155,
-0.010186337865889072,
-0.029101643711328506,
-0.0033668328542262316,
-0.013146862387657166,
0.01012529619038105,
0.012254126369953156,
-0.0006328310118988156,
-0.004410265013575554,
-0.03235211595892906,
-0.023806273937225342,
0.016359182074666023,
0.0202811136841774,
... | |
95b989433010de72841d8eae49682d5381f785e1 | subsection | 79 | 91 | TypeChecker.hs | [style = basic, language = haskell]code/ROOPLPPC/src/TypeChecker.hs | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.035330452024936676,
-0.026772428303956985,
-0.013889627531170845,
0.0028240715619176626,
-0.01816863939166069,
0.017055029049515724,
0.03429311513900757,
-0.004934974480420351,
-0.018275422975420952,
-0.03142518550157547,
-0.013271802105009556,
0.007711374666541815,
0.01826016791164875,
... | |
7be4a110b27951b773020b567b1345710f48af33 | subsection | 80 | 91 | CodeGenerator.hs | [style = basic, language = haskell]code/ROOPLPPC/src/CodeGenerator.hs | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.02397599257528782,
-0.012690030969679356,
-0.013323388062417507,
-0.010568667203187943,
-0.03207990899682045,
-0.013254710473120213,
0.007844468578696251,
-0.011957473121583462,
-0.03101159632205963,
-0.04895925521850586,
-0.03287351503968239,
0.018817568197846413,
0.004349559545516968,
... | |
98302f3aa9c27eb9a4e7c39fbb846d9b9ea96cb3 | subsection | 81 | 91 | MacroExpander.hs | [style = basic, language = haskell]code/ROOPLPPC/src/MacroExpander.hs | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.03745673969388008,
-0.03150395676493645,
-0.029718123376369476,
-0.0013880286132916808,
-0.04521062225103378,
0.020712630823254585,
0.047988586127758026,
-0.01488195639103651,
-0.005231580231338739,
-0.047133829444646835,
-0.02309374324977398,
-0.0007302652229554951,
-0.001190556562505662... | |
6702c5c75a4f69d902cdeda2d48cb416f52e4df3 | subsection | 82 | 91 | ROOPLPPC.hs | [style = basic, language = haskell]code/ROOPLPPC/src/ROOPLPPC.hs | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.03864407166838646,
-0.0019507091492414474,
-0.01889469288289547,
-0.0014709015376865864,
-0.03382119536399841,
-0.0037755046505481005,
0.03641578182578087,
-0.009752592071890831,
-0.02821994200348854,
-0.03955981135368347,
-0.032844409346580505,
0.019718855619430542,
0.017215842381119728,... | |
a9cd84443934969786f78bfffdb442aac635c354 | subsection | 83 | 91 | LinkedList.rplpp | [
style = basic,
frame = leftline,
language = roopl]code/ROOPLPPC/test/LinkedList.rplpp | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.04829102009534836,
-0.007577904965728521,
-0.008264724165201187,
-0.002424853155389428,
-0.029853738844394684,
0.02663332037627697,
0.053114015609025955,
0.028709040954709053,
-0.0402323417365551,
-0.025732824578881264,
-0.025442834943532944,
0.03843134641647339,
-0.0009563002968207002,
... | |
aa0273ba4a32f4ed8ead0e1b24d9253ac54f2ca5 | subsection | 84 | 91 | LinkedList.pal | [
style = basic,
frame = leftline,
multicols=2,
language = pisa]code/ROOPLPPC/test/LinkedList.pal | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.06032043322920799,
-0.007360710762441158,
-0.001119942287914455,
0.02022382989525795,
-0.01758328452706337,
0.027534935623407364,
0.06721942871809006,
0.03260233998298645,
-0.04392768442630768,
-0.0011609622742980719,
-0.029931267723441124,
0.056565672159194946,
0.0032300890889018774,
0... | |
8bc5c531d28c6eec97acfd679cc3018e22996c4a | subsection | 85 | 91 | BinaryTree.rplpp | [
style = basic,
frame = leftline,
language = roopl]code/ROOPLPPC/test/BinaryTree.rplpp | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.047357793897390366,
0.015447733923792839,
-0.028530629351735115,
-0.030590327456593513,
-0.041316013783216476,
-0.019300131127238274,
0.045893121510744095,
0.02422815002501011,
-0.04622877389192581,
-0.016981065273284912,
-0.03158203512430191,
0.01647758297622204,
-0.0017431146698072553,
... | |
6737260f3b18ae76c99024bffac8ea53a51d82db | subsection | 86 | 91 | BinaryTree.pal | [
style = basic,
frame = leftline,
multicols=2,
language = pisa]code/ROOPLPPC/test/BinaryTree.pal | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.06384707242250443,
0.0052760811522603035,
-0.016419561579823494,
-0.0020638902205973864,
-0.02951248362660408,
-0.012039994820952415,
0.05926912650465965,
0.03134366124868393,
-0.0466950349509716,
-0.00018180640472564846,
-0.034365106374025345,
0.03311379998922348,
0.007099629379808903,
... | |
5e7dccf2a3d67f42f755a60b129641297ec2cea0 | subsection | 87 | 91 | DoublyLinkedList.rplpp | [
style = basic,
frame = leftline,
language = roopl]code/ROOPLPPC/test/DoublyLinkedList.rplpp | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.05963960662484169,
-0.016878558322787285,
-0.004143334925174713,
0.00542906578630209,
-0.029957151040434837,
0.022815048694610596,
0.0402277372777462,
0.028019016608595848,
-0.046087924391031265,
-0.019823912531137466,
-0.027423841878771782,
0.04001408442854881,
0.0018026940524578094,
-... | |
c7bee483afaa85709bda7c259b54de129308550f | subsection | 88 | 91 | DoublyLinkedList.pal | [
style = basic,
frame = leftline,
multicols=2,
language = pisa]code/ROOPLPPC/test/DoublyLinkedList.pal | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.07240433990955353,
-0.015643853694200516,
0.0015500769950449467,
0.026113789528608322,
-0.017337968572974205,
0.018726838752627373,
0.057905156165361404,
0.0347675122320652,
-0.04868672788143158,
0.004826701246201992,
-0.030539855360984802,
0.05607368052005768,
0.00648266077041626,
-0.0... | |
f23ef4086bcfd9e8b7e62948256d4e64f70f1fb1 | subsection | 89 | 91 | RTM.rplpp | [
style = basic,
frame = leftline,
language = roopl]code/ROOPLPPC/test/RTM.rplpp | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.03357337787747383,
0.0008617485291324556,
-0.01097239088267088,
-0.01707664132118225,
-0.041356299072504044,
0.006840575952082872,
0.022616248577833176,
0.031467411667108536,
-0.031024852767586708,
-0.026034628972411156,
-0.02476799674332142,
0.02817111648619175,
-0.004528590943664312,
... | |
2f0d2eef4ca8e70d26885e1345193f7e6c623931 | subsection | 90 | 91 | RTM.pal | [
style = basic,
frame = leftline,
multicols=2,
language = pisa]code/ROOPLPPC/test/RTM.pal | {
"cite_spans": []
} | 1804.05097 | Design and Implementation of Dynamic Memory Management in a Reversible
Object-Oriented Programming Language | [
"Martin Holm Cservenka"
] | [
"cs.PL",
"cs.DS"
] | 2,018 | en | Computer Science | [
-0.053183965384960175,
-0.000711331726051867,
0.0047218697145581245,
0.012655220925807953,
-0.02254902571439743,
0.012342464178800583,
0.04778318479657173,
0.033045459538698196,
-0.03228263556957245,
0.00301696197129786,
-0.029750067740678787,
0.05437396839261055,
0.0006870167562738061,
0.... | |
2d904925df7990704422b62db197fe869d47f9fd | abstract | 0 | 60 | Abstract | We prove Szeg\H{o}-type trace asymptotics for translation-invariant operators
on polygons. More precisely, consider a Fourier multiplier $A=\mathcal{F}^\ast
\sigma \mathcal{F}$ on $\mathsf{L}^2(\mathbb{R}^2)$ with a sufficiently
decaying, smooth symbol $\sigma:\mathbb{C}\to\mathbb{C}$. Let $P\subset
\mathbb{R}^2$ be th... | {
"cite_spans": []
} | 1807.04714 | A Szeg\H{o} limit theorem for translation-invariant operators on
polygons | [
"Bernhard Pfirsch"
] | [
"math.SP",
"math-ph",
"math.MP"
] | 2,018 | en | Mathematics | [
-0.022756826132535934,
-0.02742724120616913,
-0.032448697835206985,
0.013324419036507607,
0.013095476664602757,
-0.07637502253055573,
0.037882253527641296,
-0.026725152507424355,
0.022131050005555153,
-0.001022607204504311,
-0.016819598153233528,
0.038920123130083084,
0.01976531744003296,
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.