![\"Download](\"https://zzxzzk115.github.io/blog/images/posts/phd-life/openxr-simulator/download_meta_xr_simulator.png\")
These are the steps I used for repeated permission prompts with a locally installed GodotSteam build on macOS.
\nFirst, reset the relevant privacy permissions. Use the bundle identifier of your build; the command below uses Godot's identifier:
\ntccutil reset All org.godotengine.godotThen open System Settings → Privacy & Security → Full Disk Access, click +, and add GodotSteam (or your custom Godot build).
\nFinally, apply an ad-hoc signature to the app bundle. Replace the path with the location of your app; mine is in /Applications:
codesign --force --deep --sign - /Applications/GodotSteam.appA checklist to read before preparing a submission.
\n\n\n\nThis is an AI-generated summary of general IEEE Computer Society journal submission procedures, with a focus on IEEE Transactions on Visualization and Computer Graphics (TVCG), based on the author resources.
\nIt is a personal reference, not the journal's official instructions. Figures and procedural details quoted below come from the original March 2026 summary and have not been independently verified for every TVCG article type. Check the journal's current instructions for page limits, fees, abstract length, file requirements, and the submission system before submitting.
\n
IEEE Computer Society publishes journals and magazines:
\nTVCG covers computer graphics, visualisation, and VR/AR. Important aspects of a submission include technical completeness, thorough experimental validation, and reproducibility. The original summary cited an acceptance rate of approximately 25%; treat that as an unverified contextual figure, not a current official statistic.
\nThe original summary lists LaTeX, Microsoft Word, and plain text among general IEEE preparation formats. Use the journal's official templates and confirm which submission files its current portal accepts. The IEEE LaTeX Analyzer can be useful for checking a LaTeX manuscript.
\nThe original summary gives a general journal abstract length of 100–200 words. Confirm the requirement for your article type. A useful abstract states:
\nKeep the abstract self-contained, without references or mathematical notation that requires explanation elsewhere.
\nThe original summary quotes a standard length of 12 formatted pages, including the abstract and references, and an excess-page charge of USD 220 per page. These figures must be checked against the current TVCG instructions and your article type; they are not a quotation of a verified current fee schedule.
\nIt also suggests submitting appendices as supplemental material. Confirm the journal's current rules before separating material essential to understanding or evaluating the work.
\nPrepare figures at an appropriate resolution; the original checklist gives 300 dpi as a general reference. Place them near the relevant discussion, make labels and legends legible, and follow the publisher's requirements for final figure files.
\nThe original checklist suggests filenames such as lastname-fig1 and lastname-fig2a. A good figure should communicate a method or result clearly without overcrowding the image.
Use IEEE reference formatting, numbered in citation order. A schematic entry is:
\n[1] Author(s), Title, Journal/Conference, Year, pages.Supply the bibliographic information appropriate to the source: authors, full title, venue, year, volume and issue where applicable, and page range or article number.
\nConsult the IEEE Editorial Style Manual. Prefer clear sentences and active voice where appropriate, avoid repetition, and define abbreviations on first use.
\nA common research-paper structure is:
\nUseful supplements can include videos, animations, additional figures and tables, code, and extended experiments.
\nUpload them as separate files when requested by the portal. The original summary quotes a 350 MB limit; check the current upload limits rather than assuming that value applies to every submission. Follow the journal's rules for appendices and ensure the main paper remains understandable on its own.
\nThe original checklist highlights IEEE DataPort for data, and Code Ocean or GitHub for code. Well-documented data and code can support reproducibility and make the work easier to use and evaluate. Choose a suitable repository, licence, and release format for the material you can share.
\nA submission must follow the journal's policies on originality and simultaneous submission. Disclose relevant previously published work rather than presenting it as new.
\nWhere a journal extension is allowed:
\nEditors and reviewers assess whether the extension contains sufficient new material.
\nDo not submit the same manuscript to multiple publications at the same time. Undisclosed overlap with published work can also lead to rejection.
\nFollow the submission link on the journal's official website. The original summary mentions ScholarOne and IEEE Author Portal; the current journal page determines which system to use.
\nThe usual steps are:
\nKeywords help route the manuscript to appropriate editors and reviewers. The original summary recommends at least three terms from an ACM taxonomy; use the classification and number requested by the actual portal.
\nIf the portal allows it, suggest reviewers without conflicts of interest. Requests to exclude reviewers should include an appropriate reason and follow the journal's policy.
\nThe original summary describes single-anonymous review, in which reviewers know the authors' identities but authors do not know the reviewers'. Review models differ between journals and submission tracks; do not assume a double-anonymous option exists without checking.
\nA typical workflow is:
\nThe original checklist describes three or more reviewers and two to four months per round as general expectations, not guarantees for an individual manuscript.
\nPossible outcomes include acceptance, minor revision, major revision, and rejection.
\nAttribute all sources, obtain any required permissions for reused images or other material, and make sure every author agrees to the submission. Follow IEEE's policies on plagiarism and publication ethics.
\nFor research involving human participants or animals, provide the applicable ethics approval and explain it in the manuscript as required by the journal and your institution.
\nDistinguish traditional publication from open access. Open access may involve an article processing charge; excess-page charges or other fees may be separate. Traditional publication does not necessarily mean that every possible charge is waived.
\nThe original summary quotes USD 220 per excess page. Check the current journal fee schedule, applicable article type, and any institutional agreement before relying on that figure.
\nThe requested package may include:
\nEarly Access can make an accepted article available and citable before assignment to a regular issue. Follow the publisher's instructions for proofs and corrections; do not assume that a posted article can simply be replaced.
\nComplete the publisher's production and proof stages, then check the published version and its metadata.
\nCommon weaknesses include insufficient evaluation, confusing figures, unclear contributions, and incomplete coverage of related work.
\nThe checklist centres on originality, technical completeness, convincing evaluation, clear writing, and compliance with the journal's format and submission requirements. Acceptance depends on the research itself, the evidence supporting it, and how clearly the manuscript communicates those contributions.
\n", "date_published": "2026-03-30T00:00:00.000Z", "date_modified": "2026-10-17T16:08:05.000Z", "authors": [ { "name": "Lazy_V" } ], "tags": [ "PhD-Life" ] }, { "title": "Develop OpenXR native PC apps without a headset by using Meta XR Simulator", "url": "https://zzxzzk115.github.io/blog/posts/phd-life/openxr-simulator.html", "id": "https://zzxzzk115.github.io/blog/posts/phd-life/openxr-simulator.html", "summary": "If you don't have an XR headset but you want to develop OpenXR apps, you can use Meta XR Simulator! It's great.", "content_html": "If you don't have an XR headset but you want to develop OpenXR apps, you can use Meta XR Simulator! It's great.
\n\nDownload it from here
\nYou will get a compressed file, and you have to extract it and get the necessary files.
\nWe only need the MetaXRSimulator folder. Copy it to somewhere on your machine, for example, C:\\MetaXRSimulator.
There are two options to configure the currently active OpenXR runtime on Windows:
\nI recommend you to use an temporary environment variable (XR_RUNTIME_JSON) in the IDE or the terminal to set the currently active OpenXR runtime, which will not replace the system default OpenXR runtime.
After configuring the environment variable, just run your OpenXR apps in the same terminal!
\nHave fun!
\n", "image": "https://zzxzzk115.github.io/blog/images/posts/phd-life/openxr-simulator/download_meta_xr_simulator.png", "date_published": "2025-02-11T00:00:00.000Z", "date_modified": "2025-02-12T00:09:03.000Z", "authors": [ { "name": "Lazy_V" } ], "tags": [ "PhD-Life" ] }, { "title": "Drawing a Simple Sprite with GBDK", "url": "https://zzxzzk115.github.io/blog/game-dev/retro/gameboy/gbdk/003-gbdk-simple-sprites.html", "id": "https://zzxzzk115.github.io/blog/game-dev/retro/gameboy/gbdk/003-gbdk-simple-sprites.html", "summary": "The Game Boy has a screen resolution of 160 × 144 pixels. That may seem tiny today, but it was enough to bring many memorable characters to life. A sprite is a bitmap image used...", "content_html": "The Game Boy has a screen resolution of 160 × 144 pixels. That may seem tiny today, but it was enough to bring many memorable characters to life.
\nA sprite is a bitmap image used to represent a character or other object in a 2D game. Mario's character graphics are a familiar example.
\nHow can we use GBDK to display a sprite on the Game Boy screen?
\n\nWe will draw the graphics in a tile editor, export them as a C array, and load that array into the Game Boy's video memory. In this tutorial, we will use GBTD.
\nWriting your own tool
\nYou can also write an exporter yourself, as long as its C array uses the tile-data format expected by GBDK.
\nGame Boy backgrounds are commonly built from tile maps, and sprite graphics also use small tiles.
\nGBTD, the Game Boy Tile Designer, lets us draw tiles and export them as GBDK-compatible C arrays. Here is its interface:
\n![\"GBTD](\"https://zzxzzk115.github.io/blog/images/game-dev/retro/gameboy/gbdk/gbtd_interface_01.png\")
GBTD and GBMB on macOS or Linux
\nIf you have not set up the tools yet, follow the previous tutorial.
\nWith the aliases configured, you can launch them directly:
\n# Open GBTD\ngbtd\n\n# Open GBMB\ngbmbWe will draw an 8 × 8 smiley face and place it near the centre of the screen.
\nWhy 8 × 8?
\nThe Game Boy supports two hardware sprite sizes, selected globally:
\nEach tile is 8 × 8 pixels. A smaller visible shape still occupies a complete tile, with the unused pixels transparent. Larger characters can be assembled from multiple hardware sprites. For this example, one 8 × 8 tile is enough.
\nAt the bottom of GBTD is a colour selector. The L and R indicators show the colour indices assigned to the left and right mouse buttons.
\nThe four swatches on the right represent indices 0 to 3. A palette determines the actual colours; the default palette displays four shades from white to black.
\n![\"GBTD](\"https://zzxzzk115.github.io/blog/images/game-dev/retro/gameboy/gbdk/gbtd_color_picker.png\")
The left toolbar starts with the pencil and fill tools. Below them are four movement tools, followed by vertical flip, horizontal flip, rotation, and automatic updating.
\n![\"GBTD](\"https://zzxzzk115.github.io/blog/images/game-dev/retro/gameboy/gbdk/gbtd_left_toolbar.png\")
There is no separate eraser
\nGBTD edits indexed colours rather than RGBA pixels. To replace a pixel, paint it with another colour index. For Game Boy sprites, index 0 is transparent when displayed as a sprite.
\nClick a swatch with the left mouse button to assign that index to the left drawing button; do the same with the right mouse button for the right drawing button. This lets you draw with two indices without repeatedly changing the selection.
\nSelect the pencil tool, assign the black swatch at index 3 to the left button, and draw a smiley face. You can use your own design as long as it fits inside 8 × 8 pixels.
\nThen select the fill tool, choose the light-grey swatch at index 1, and fill the face. Mine looks roughly like this:
\n![\"The](\"https://zzxzzk115.github.io/blog/images/game-dev/retro/gameboy/gbdk/first_sprite_smile_face.png\"){kind=icon}
Before exporting, save your work. GBTD stores the editable source in a .gbr file, which you can reopen later.
Choose Files → ExportTo from the menu and use these settings:
\n![\"Exporting](\"https://zzxzzk115.github.io/blog/images/game-dev/retro/gameboy/gbdk/export_smile_face_as_gbdk_c_array.png\")
Important settings
\nSmile.c, the output filename.GBDK C file, which exports a compatible C array.Smile, the array name we will use in our program.Gameboy 4 color.Click OK. GBTD creates Smile.h and Smile.c alongside the .gbr file. The header contains declarations; the C source contains the actual sprite data. We can now use that array in our program.
Info
\nThe Hello World program was a single file, so it did not need much project configuration. From this point on, we will use Visual Studio Code and a Makefile to organise the examples.
\nCreate a gb-dev directory, then a first-sprite directory inside it. Open gb-dev in Visual Studio Code.
To configure header lookup and IntelliSense, create .vscode/c_cpp_properties.json inside gb-dev:
{\n \"configurations\": [\n {\n \"name\": \"GBDK_VSC\",\n \"includePath\": [\n \"${GBDKDIR}/include/**\"\n ],\n \"defines\": [],\n \"macFrameworkPath\": [],\n \"compilerPath\": \"${GBDKDIR}/bin/lcc\",\n \"cStandard\": \"gnu99\"\n }\n ],\n \"version\": 4\n}Copy the exported Smile.h and Smile.c files into first-sprite. Then create the main program, FirstSprite.c, in that directory:
#include <gb/gb.h>\n#include <stdio.h>\n#include \"Smile.h\"\n\nvoid main()\n{\n // Copy one tile from Smile to sprite tile slot 0.\n set_sprite_data(0, 1, Smile);\n\n // Use tile 0 for hardware sprite 0.\n set_sprite_tile(0, 0);\n\n // Enable the sprite layer through bit 1 of LCDC.\n SHOW_SPRITES;\n\n // Move hardware sprite 0 near the centre of the screen.\n move_sprite(0, 84, 78);\n}The second argument of set_sprite_data is the number of tiles, so we pass 1 for this one-tile image.
Next, create a Makefile. Make describes how source files are compiled and linked, so we can repeat the build without typing the full compiler command each time:
# Path to the LCC compiler\nCC = $(GBDKDIR)/bin/lcc\n\n# Path to SameBoy\nEMU = /Applications/SameBoy.app/Contents/MacOS/SameBoy\n\n# Compile the sources and link FirstSprite.gb\nall:\n\t$(CC) -Wa-l -Wl-m -Wl-j -o FirstSprite.gb Smile.c FirstSprite.c\n\n# Build the ROM, then run it in SameBoy\nrun: all\n\t$(EMU) FirstSprite.gb\n\n# Remove intermediate files and generated output\nclean:\n\trm -f *.o *.lst *.map *.gb *.ihx *.sym *.cdb *.adb *.asm *.noiThe available commands are:
\nmake: runs the first target, all.make all: compiles and links the ROM, FirstSprite.gb.make run: builds the ROM and opens it in SameBoy.make clean: removes intermediate files and generated output.Run make run to build, link, and launch the program. The result should look like this:
![\"The](\"https://zzxzzk115.github.io/blog/images/game-dev/retro/gameboy/gbdk/successfully_showed_first_sprite.png\"){kind=icon}
Use make clean to return to the source files and Makefile.
Tips
\nThe example sources are in the gb-dev directory.
GBDK is open source, with release builds available on GitHub. I was using macOS when I wrote this tutorial, so I will start with setting up GBDK on macOS and compiling a Hello World program. The general process is similar on Linux and Windows, although the installation details differ. Feel free to leave a comment if you run into trouble.
\n\nVersions used in this tutorial
\nThis tutorial describes my December 2022 setup. The release links and versions below are retained from that setup; use the upstream release pages when choosing a version for a new installation.
\nAt the time of writing, the stable version was v4.1.1. Download the macOS archive, or find other versions on the releases page.
\nExtract the archive to get a directory named gbdk. Its contents include:
bin/: prebuilt executable toolsinclude/: header fileslib/: librariesexamples/: example programslicenses/: licencesgbdk_manual.pdf: the GBDK manualsdccman.pdf: the SDCC manualChangeLog: release changesREADME: introductory informationNext, move this directory to a suitable location and configure the environment.
\nFor example, copy the directory to /opt/gbdk:
sudo cp -r gbdk /opt/gbdkThen set the environment variable.
\nTips
\nTo make it persistent, add the setting to /etc/profile or your shell's configuration file. Choose the appropriate file; you do not need to update all three.
Info
\nThe commands in this tutorial use GBDKDIR. You can also add its bin directory to PATH to invoke the tools without their full paths.
GBTD (Game Boy Tile Designer) and GBMB (Game Boy Map Builder) are used for tile graphics and tile maps. GBTD draws the tiles; GBMB arranges those tiles into a map.
\nWe will use both tools later. Download the 2.4.5 archive, or choose a version from the releases page.
\nExtract it to get a GBTD_GBMB_release directory containing GBTD and GBMB. Create a tools directory inside gbdk, then copy the tool directories into it. On macOS or Linux:
sudo mkdir -p \"$GBDKDIR/tools\"\ncd GBTD_GBMB_release\nsudo cp -r GBTD \"$GBDKDIR/tools/\"\nsudo cp -r GBMB \"$GBDKDIR/tools/\"Configuration file permissions
\nIf the tools cannot save their .ini settings, check the files' ownership and give your account write access to those files. The original setup used a blanket chmod 777; that is unnecessary. A user-owned copy of the tools is another option when a system-wide installation is not needed.
Running the Windows tools
\nOn macOS and Linux, these tools need a compatible Wine installation. Wine runs Windows applications by providing compatible implementations of Windows APIs.
\nOnce Wine is configured, run:
\nwine \"$GBDKDIR/tools/GBTD/gbtd.exe\"\nwine \"$GBDKDIR/tools/GBMB/gbmb.exe\"For convenience, add aliases to your shell configuration. For example, in ~/.zshrc:
alias gbtd='wine \"$GBDKDIR/tools/GBTD/gbtd.exe\"'\nalias gbmb='wine \"$GBDKDIR/tools/GBMB/gbmb.exe\"'Use ~/.bashrc for Bash, or the appropriate configuration file for your shell. Open a new shell after editing it.
I chose SameBoy, an open-source, cross-platform emulator with debugging features that are useful during development.
\nChoose a build for your platform from the download page. For this tutorial, I used SameBoy v0.15.8 for macOS. Extract the app and drag it into Applications.
Let's write our first program: display a line of text on the Game Boy screen.
\nCreate helloworld.c:
#include <gb/gb.h>\n#include <stdio.h>\n\nvoid main()\n{\n printf(\"HELLO, WORLD!\");\n}Open a terminal in the directory containing helloworld.c and run:
$GBDKDIR/bin/lcc -Wa-l -Wl-m -Wl-j -o helloworld.gb helloworld.cThis produces helloworld.gb, a ROM file that can be opened in an emulator.
![\"Hello,](\"https://zzxzzk115.github.io/blog/images/game-dev/retro/gameboy/gbdk/helloworld_samboy.png\")
Tips
\nYou can also add an alias for SameBoy to your shell configuration:
\nalias sameboy=/Applications/SameBoy.app/Contents/MacOS/SameBoyThen open the ROM directly from the terminal:
\nsameboy helloworld.gbCongratulations — you have built and run your first Game Boy program! 🎉
\n", "image": "https://zzxzzk115.github.io/blog/images/game-dev/retro/gameboy/gbdk/helloworld_samboy.png", "date_published": "2022-12-18T19:10:00.000Z", "date_modified": "2026-10-17T16:08:05.000Z", "authors": [ { "name": "Lazy_V" } ], "tags": [ "Game Development" ] }, { "title": "An Introduction to GBDK", "url": "https://zzxzzk115.github.io/blog/game-dev/retro/gameboy/gbdk/001-gbdk-intro.html", "id": "https://zzxzzk115.github.io/blog/game-dev/retro/gameboy/gbdk/001-gbdk-intro.html", "summary": "Assembly language is a common choice for GB/GBC development. However, starting with it requires learning the hardware and instruction set together, which can be a substantial ba...", "content_html": "Assembly language is a common choice for GB/GBC development. However, starting with it requires learning the hardware and instruction set together, which can be a substantial barrier for a beginner.
\nFor this series, we will use a higher-level language: C. GBDK provides the tools and libraries needed to write C programs for the Game Boy and Game Boy Color.
\nGBDK, the Game Boy Development Kit, includes a toolchain based on SDCC, together with an assembler, linker, and libraries for the supported hardware. The Game Boy CPU is the Sharp SM83, with an instruction set related to the Intel 8080 and Z80; it is not a full Z80, so Z80 code and libraries are not generally interchangeable with Game Boy code.
\nGBDK bundles the tools we need to build a ROM. Next, let's set up the development environment.
\n", "date_published": "2022-12-18T19:05:00.000Z", "date_modified": "2026-10-17T16:08:05.000Z", "authors": [ { "name": "Lazy_V" } ], "tags": [ "Game Development" ] }, { "title": "GB/GBC Game Development — Introduction", "url": "https://zzxzzk115.github.io/blog/game-dev/retro/gameboy/intro.html", "id": "https://zzxzzk115.github.io/blog/game-dev/retro/gameboy/intro.html", "summary": "Before we begin Nintendo's Game Boy was popular around the world, but I never had one as a child. When I learned about it later, I became fascinated by it and wanted to make gam...", "content_html": "Before we begin
\nNintendo's Game Boy was popular around the world, but I never had one as a child. When I learned about it later, I became fascinated by it and wanted to make games that could run on the hardware.
\nIn 2018, I discovered GBDK. Using it and the C programming I already knew, I made a few small games and demos. They remained unfinished, so I do not plan to show them here.
\nIn 2020, I learned about GB Studio, a tool that makes GB/GBC game development accessible without requiring programming experience.
\nIn 2021, during the pandemic, I felt particularly motivated to create something. I used GB Studio to make my own GBC version of Cat Mario: CatMario-GB.
\nI would like to share what I have learned in a series of tutorials on modern GB/GBC development.
\nI will start with the more code-oriented GBDK toolchain. GB Studio is easier to get started with, so I can cover it later.
\nRather than beginning with a long explanation of all the hardware, I will introduce individual hardware features, their settings, and the underlying principles as we need them to produce something on screen.
\nStart here:
\n\n", "date_published": "2022-12-18T19:00:00.000Z", "date_modified": "2026-10-17T16:08:05.000Z", "authors": [ { "name": "Lazy_V" } ], "tags": [ "Game Development" ] }, { "title": "The algorithm framework for solving DP problems", "url": "https://zzxzzk115.github.io/blog/posts/algorithms/dynamic-programming/framework.html", "id": "https://zzxzzk115.github.io/blog/posts/algorithms/dynamic-programming/framework.html", "summary": "Dynamic Programming problems are the most complicated problems in algorithms. However, it is actually simple to solve if you understand the key concepts and the main algorithm f...", "content_html": "Dynamic Programming problems are the most complicated problems in algorithms. However, it is actually simple to solve if you understand the key concepts and the main algorithm framework of DP.
\n\nDynamic Programming (DP) is a method for solving complex problems by breaking them down into smaller subproblems. It is a bottom-up approach, meaning it starts with solving the smaller subproblems and then uses those solutions to build up to a solution for the larger problem.
\nTo solve a problem with DP, the problem must have the following properties:
\nOptimal substructure: The optimal solution to a problem can be constructed from optimal solutions to its subproblems.
\nOverlapping subproblems: A problem can be broken down into subproblems that are reused multiple times.
\nFor an instance, when we calculate the Fibonacci sequence, we can use DP.
\nTips
\nThe Fibonacci sequence is a series of numbers where each number is the sum of the two preceding numbers, starting with 0 and 1. The sequence goes as follows: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, and so on. The sequence is named after Leonardo of Pisa, who was known as Fibonacci. He introduced the sequence to Western European mathematics in his book "Liber Abaci" in the year 1202.
\nIn general, for calculating the Fibonacci sequence, we use recursion functions, like the following:
\nint Fibonacci(int n) {\n if (n == 0) {\n\t\treturn 0;\n\t}\n\tif (n == 1 || n == 2) {\n\t\treturn 1;\n\t}\n\treturn Fibonacci(n - 1) + Fibonacci(n - 2);\n}The technique we use is just Recursion, not DP.
\nThe function call tree has a lot of nodes, but many of them are duplicated.
\nI have an equation:
\nDP = Recursion + Memoization OR Tabulation + optional improvements.
\nWhat does it mean?
\nWell, Memoization and tabulation are two techniques used to improve the performance of algorithms that use Dynamic Programming.
\nMemoization is a technique that involves storing the results of intermediate calculations in a table, so that they can be reused later. This can help to reduce the overall time complexity of the algorithm by avoiding the need to recalculate the same subproblems multiple times. It's top-bottom.
\nTabulation, on the other hand, is a technique that involves storing the final results of all the subproblems in a table. This allows the algorithm to avoid recomputing the solutions to the subproblems and simply look up the pre-computed results in the table. It's bottom-up.
\nBoth memoization and tabulation can be used to speed up Dynamic Programming algorithms. The choice between the two techniques often depends on the specific problem being solved and the amount of available memory.
\nTo use Memoization, we could define a look-up table or a cache table for saving calculated results. To define that table, we generally use a hash table.
\nIn C++, we will use std::unordered_map.
\nFor example, we can use Memoization to solve the Fibonacci problem:
\nstd::unordered_map<int, int> memo;\n\nint Fibonacci(int n) {\n if (n == 0) {\n\t\treturn 0;\n\t}\n\tif (n == 1 || n == 2) {\n\t\treturn 1;\n\t}\n if (memo.count(n) > 0) {\n return memo[n];\n } else {\n memo[n] = Fibonacci(n - 1) + Fibonacci(n - 2);\n }\n\treturn memo[n];\n}Now, all the duplicated nodes are gone, we calculate Fibonacci(i) just one time.
We can also use Tabulation for solving the problem. To use Tabulation, we could define an array or a vector for saving results of sub-problems.
\nIn C++, we will use std::vector.
\nHere is the implementation of Fibonacci by using Tabulation:
\nint Fibonacci(int n) {\n if (n == 0) {\n\t\treturn 0;\n\t}\n\tif (n == 1 || n == 2) {\n\t\treturn 1;\n\t}\n std::vector<int> d(n + 1);\n for (int i = 3; i <= n; i++) {\n d[i] = d[i - 1] + d[i - 2];\n }\n return d[n];\n}There is an optional improvement called State Compression.
\nState compression is a technique used in Dynamic Programming to reduce the amount of memory needed to store the intermediate results of a calculation. It involves representing the state of a subproblem using a smaller data structure, such as a bit vector or a hash table, instead of a larger data structure like an array or a matrix. This can help to reduce the space complexity of the algorithm and make it possible to solve larger problems or problems with more complex subproblems.
\nIn this case, we replace d with two integers: pre and curr:
int Fibonacci(int n) {\n if (n == 0) {\n\t\treturn 0;\n\t}\n\tif (n == 1 || n == 2) {\n\t\treturn 1;\n\t}\n int pre = 1;\n int curr = 1;\n for (int i = 3; i <= n; i++) {\n int sum = pre + curr;\n pre = curr;\n curr = sum;\n }\n return curr;\n}Find all the base cases.
\nIn Fibonacci problem, base cases are n == 0 and n == 1 and n == 2;
Find all the states.
\nIn Fibonacci problem, states are all the non-negative numbers.
\nFind the state transition equation.
\nIn Fibonacci problem, the state transition equation is : dp[i] = dp[i - 1] + dp[i - 2]
\nTips
\nA state transition equation is a mathematical equation that describes how the state of a system changes over time. In the context of Dynamic Programming, a state transition equation is an equation that describes how the optimal solution to a problem can be constructed from the optimal solutions to its subproblems. By using a state transition equation, it is possible to solve a problem by breaking it down into smaller subproblems and then combining the solutions to those subproblems to find a solution to the larger problem.
\nStatic abstract interface method is a new feature in C# 11 (corresponding .NET 7.0). In this article, we are going to deeply dive into it, talk about why we need it, what it is and how to use it.
\n\nLet's recall our previous demands:
\nWe hope to perform mathematical operations in generics, but the compiler can't know the runtime type of T, so it can't know whether T supports mathematical operations such as addition, subtraction, multiplication and division, so it can't implement code like the following:
public T Add<T>(T a, T b)\n{\n return a + b;\n}We hope that in some cases, T, as a type that can be determined at compile time, can call the public static method of T. However, the static interface method cannot be declared in the interface to allow us to operate T.XXX(); If only the static interface method could be declared in the interface. We used to dream about implementing code like the following：
public interface ISomeInterface<T> where T : ISomeInterface<T>\n{\n static void SomeStaticMethod();\n}\n\npublic void Test<T>() where T : ISomeInterface<T>\n{\n T.SomeStaticMethod();\n}In order to meet these needs, Microsoft and community developers jointly launched the static abstract interface method, and everyone's previous fantasy has now been realized.
\nStatic abstract interface method is a new feature in C# 11 (corresponding .NET 7.0). Using the latest version of Visual Studio 2022 and then when NET 7.0 runs, you can taste it fresh.
\nIt supports declaring the static abstract method in the interface (officially, it supports declaring the static virtual method in the interface, but I still report an error after opening the language preview, and I don't know how to use static virtual for the time being).
\nFor an instance, we can use the feature mentioned above to declare the following interface:
\npublic interface IGetNext<T> where T : IGetNext<T>\n{\n static abstract T operator ++(T other);\n}\n\nMany operators force their parameters to match the type, or implement the type parameters containing the type according to the constraints. So, in this case we constrain
\nTimplementIGetNext<T>.
Then, define a structure named RepeatSequence to implement the above interface, which creates a string composed of 'A', and each ++ operation allows an 'A' to be added to the string.
public struct RepeatSequence : IGetNext<RepeatSequence>\n{\n private const char Ch = 'A';\n public string Text = new string(Ch, 1);\n\n public RepeatSequence() {}\n\n public static RepeatSequence operator ++(RepeatSequence other)\n => other with { Text = other.Text + Ch };\n\n public override string ToString() => Text;\n}Then we can write some testing codes, let them print to screen and we look at the output.
\nvar str = new RepeatSequence();\n\nfor (int i = 0; i < 10; i++)\n Console.WriteLine(str++);Output:
\nA\nAA\nAAA\nAAAA\nAAAAA\nAAAAAA\nAAAAAAA\nAAAAAAAA\nAAAAAAAAA\nAAAAAAAAAASuppose that we have declared the following interface:
\npublic interface IDeepInSourceCode<T> where T : IDeepInSourceCode<T>\n{\n void SomeMethod();\n static abstract void SomeStaticAbstractMethod();\n}The IL codes of it:
\n// Type: StaticAbstractInterfaceMethods.IDeepInSourceCode`1 \n// Assembly: StaticAbstractInterfaceMethods, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\n// MVID: 27A20D9E-C658-48F7-8AC2-47D46316D62D\n// Location: F:\\static_abstract\\StaticAbstractInterfaceMethods\\bin\\Debug\\net7.0\\StaticAbstractInterfaceMethods.dll\n// Sequence point data from f:\\static_abstract\\staticabstractinterfacemethods\\bin\\debug\\net7.0\\staticabstractinterfacemethods.pdb\n\n.class interface public abstract auto ansi\n StaticAbstractInterfaceMethods.IDeepInSourceCode`1<(class StaticAbstractInterfaceMethods.IDeepInSourceCode`1<!0/*T*/>) T>\n{\n .param constraint [1] /*T*/, class StaticAbstractInterfaceMethods.IDeepInSourceCode`1<!0/*T*/>\n .custom instance void System.Runtime.CompilerServices.NullableAttribute::.ctor([in] unsigned int8)\n = (01 00 01 00 00 ) // .....\n // unsigned int8(1) // 0x01\n\n .method public hidebysig virtual newslot abstract instance void\n SomeMethod() cil managed\n {\n // Can't find a body\n } // end of method IDeepInSourceCode`1::SomeMethod\n\n .method public hidebysig static virtual abstract void\n SomeStaticAbstractMethod() cil managed\n {\n // Can't find a body\n } // end of method IDeepInSourceCode`1::SomeStaticAbstractMethod\n} // end of class StaticAbstractInterfaceMethods.IDeepInSourceCode`1It is found that in fact, the difference between the static abstract method and the ordinary interface method is that the newslot and instance keywords become static.
It means that the specific implementation method of implementing the static abstract interface method must be a method starting with public static.
We define two types implementing the interface above:
\npublic class DeepInSourceCodeBase : IDeepInSourceCode<DeepInSourceCodeBase>\n{\n public virtual void SomeMethod()\n {\n Console.WriteLine(\"SomeMethodBase is invoked.\");\n }\n\n public static void SomeStaticAbstractMethod()\n {\n Console.WriteLine(\"SomeStaticAbstractMethodBase is invoked.\");\n }\n}\n\npublic class DeepInSourceCodeDerived : DeepInSourceCodeBase, IDeepInSourceCode<DeepInSourceCodeDerived>\n{\n public override void SomeMethod()\n {\n Console.WriteLine(\"SomeMethodDerived is invoked.\");\n }\n\n public new static void SomeStaticAbstractMethod()\n {\n Console.WriteLine(\"SomeStaticAbstractMethodDerived is invoked.\");\n }\n}DeepInSourceCodeBase implementes IDeepInSourceCode<DeepInSourceCodeBase>.
DeepInSourceCodeDerived derives from DeepInSourceCodeBase, overrides SomeMethod method, and covers SomeStaticAbstractMethod method.
Let's write some testing code:
\npublic class DeepInSourceCodeTester\n{\n public static void Test<T1, T2>() \n where T1 : IDeepInSourceCode<T1>, new()\n where T2 : T1, new()\n {\n T1 t1 = new T1();\n T2 t2 = new T2();\n t1.SomeMethod();\n t2.SomeMethod();\n T1.SomeStaticAbstractMethod();\n T2.SomeStaticAbstractMethod();\n }\n}Add testing codes to Main:
internal class Program\n{\n static void Main(string[] args)\n {\n DeepInSourceCodeTester.Test<DeepInSourceCodeBase, DeepInSourceCodeDerived>();\n }\n}Guess what the result is first?
\nSomeMethodBase is invoked.\nSomeMethodDerived is invoked.\nSomeStaticAbstractMethodBase is invoked.\nSomeStaticAbstractMethodDerived is invoked.Would you guess the result like this?
\nActually, the result is not like this, it's:
\nSomeMethodBase is invoked.\nSomeMethodDerived is invoked.\nSomeStaticAbstractMethodBase is invoked.\nSomeStaticAbstractMethodBase is invoked.Here is the official explanation: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/interface#static-abstract-and-virtual-members
\nWhen we change where T2 : T1, new() to where T2 : IDeepInSourceCode<T2>, new(), the result is what we expect.
In order to support generic math, . NET 7.0 has reimplemented all the base element types.
\nTake Int32 as an example, it now wants to implement more interfaces to perform some generic mathematical operations:
public readonly struct Int32\n : IComparable,\n IConvertible,\n ISpanFormattable,\n IComparable<int>,\n IEquatable<int>,\n IBinaryInteger<int>,\n IMinMaxValue<int>,\n ISignedNumber<int>In addition to some previously implemented interfaces, the following new interfaces have been implemented by Int32:
IBinaryInterger<int>
\npublic interface IBinaryInteger<TSelf>\n : IBinaryNumber<TSelf>,\n IShiftOperators<TSelf, int, TSelf>\n where TSelf : IBinaryInteger<TSelf>?IBinaryNumber<int>
\npublic interface IBinaryNumber<TSelf>\n : IBitwiseOperators<TSelf, TSelf, TSelf>,\n INumber<TSelf>\n where TSelf : IBinaryNumber<TSelf>?IBitwiseOperators<int, int, int>
\nDeclared the static abstract methods for overloading four operators: &, |, ~ and !.
INumber<int>
\npublic interface INumber<TSelf>\n : IComparable,\n IComparable<TSelf>,\n IComparisonOperators<TSelf, TSelf, bool>,\n IModulusOperators<TSelf, TSelf, TSelf>,\n INumberBase<TSelf>\n where TSelf : INumber<TSelf>?IComparisonOperators<int, int, int>
\nDeclared the static abstract methods for overloading four operators: >, <, >= and <=.
IModulusOperators<int, int, int>
\nDeclared the static abstract method for overloading the operator: %.
INumberBase<int>
\npublic interface INumberBase<TSelf>\n : IAdditionOperators<TSelf, TSelf, TSelf>,\n IAdditiveIdentity<TSelf, TSelf>,\n IDecrementOperators<TSelf>,\n IDivisionOperators<TSelf, TSelf, TSelf>,\n IEquatable<TSelf>,\n IEqualityOperators<TSelf, TSelf, bool>,\n IIncrementOperators<TSelf>,\n IMultiplicativeIdentity<TSelf, TSelf>,\n IMultiplyOperators<TSelf, TSelf, TSelf>,\n ISpanFormattable,\n ISpanParsable<TSelf>,\n ISubtractionOperators<TSelf, TSelf, TSelf>,\n IUnaryPlusOperators<TSelf, TSelf>,\n IUnaryNegationOperators<TSelf, TSelf>\n where TSelf : INumberBase<TSelf>?Mainly declared the static abstract methods for overloading four operators: +, -, *, /.
IShiftOperators<int, int, int>
\nDeclared the static abstract methods for overloading three operators: <<, >>, and >>>.
IMinMaxValue<int>
\nDeclared two static abstract properties: MinValue and MaxValue.
ISignedNumber<int>
\nDeclared a static abstract property: NegativeOne.
In this way, Int32 can be used as a generic parameter for generic math.
In addition to Int32, other element types such as Single, Double and Byte also implement many of these interfaces for generic mathematical operations.
Take a simple example:
\npublic static void MultiplyAndSub<T>(T t1, T t2, T t3)\n where T : IMultiplyOperators<T, T, T>, ISubtractionOperators<T, T, T>\n{\n Console.WriteLine(t1 * t2 - t3);\n}The above method constraints T support multiplication and subtraction operations.
The above method can be called like this:
\nMultiplyAndSub(1, 2, 3);\nMultiplyAndSub(0.1f, 0.2f, 0.3f);\nMultiplyAndSub(0.1d, 0.2d, 0.3d);Of course, we can also define a type by ourselves, and then implement the interface related to multiplication and subtraction:
\npublic struct MultiplyAndSubCustomStruct : \n IMultiplyOperators<MultiplyAndSubCustomStruct, MultiplyAndSubCustomStruct, MultiplyAndSubCustomStruct>,\n ISubtractionOperators<MultiplyAndSubCustomStruct, MultiplyAndSubCustomStruct, MultiplyAndSubCustomStruct>\n{\n public MultiplyAndSubCustomStruct(int value)\n {\n Value = value;\n }\n\n public int Value;\n\n public static MultiplyAndSubCustomStruct operator *(MultiplyAndSubCustomStruct left, MultiplyAndSubCustomStruct right)\n {\n return new MultiplyAndSubCustomStruct(left.Value * right.Value);\n }\n\n public static MultiplyAndSubCustomStruct operator -(MultiplyAndSubCustomStruct left, MultiplyAndSubCustomStruct right)\n {\n return new MultiplyAndSubCustomStruct(left.Value - right.Value);\n }\n\n public string ToString(string? format, IFormatProvider? formatProvider)\n {\n return Value.ToString(format, formatProvider);\n }\n}You can then call MultiplyAndSub:
MultiplyAndSub(new MultiplyAndSubCustomStruct(1), new MultiplyAndSubCustomStruct(2), new MultiplyAndSubCustomStruct(3));The result is -1, which meets expectations.
My student discounts of Alibaba Cloud and Tencent Cloud will be used up soon, and the cost of subsequent servers is still not small. To save money, I plan to use GitHub Pages back. This time, I don't intend to use Hexo, but consider using a more powerful static page generator with Vue features: VuePress. I chose Hope as the theme, and then will slowly add some contents. I hope this blog is simpler, refreshing and more suitable for reading.
\nTo improve my English writing skill, I decide that most subsequent published articles will be written in both English and Chinese.
\n", "date_published": "2022-11-27T00:00:00.000Z", "date_modified": "2025-02-12T00:00:16.000Z", "authors": [ { "name": "Lazy_V" } ], "tags": [ "Jottings" ] }, { "title": "Implement automatically increase ids in MongoDB", "url": "https://zzxzzk115.github.io/blog/posts/backend/mongodb/auto-increment-id-in-mongodb.html", "id": "https://zzxzzk115.github.io/blog/posts/backend/mongodb/auto-increment-id-in-mongodb.html", "summary": "In MongoDB, every documents have an object id (Bson ID). But sometimes we need ids that can automatically increase when creating a new model. And the id should be an integer sta...", "content_html": "In MongoDB, every documents have an object id (Bson ID). But sometimes we need ids that can automatically increase when creating a new model. And the id should be an integer starts from 1. How to deal with the problem?
\n\nTo solve the problem, we have to create a new collection named AutoIncrementIdCollection, in which we insert some models (AutoIncrementIdModel) that have two fields:
\nEverytime before inserting a new indexed model M to a collection C, we find a AutoIncrementIdModel whose CollectionName is C, and we increase its Sequence by one, then use that sequence to create M (M's id field be initialized by the sequence) and insert it to C.
\n", "date_published": "2022-11-27T00:00:00.000Z", "date_modified": "2022-12-17T14:58:15.000Z", "authors": [ { "name": "Lazy_V" } ], "tags": [ "Backend" ] } ] }