DEV Community: Trinity

Dynamically allocating memories for matrix in c

Trinity — Tue, 09 Jun 2026 03:28:09 +0000

If you want to create mxn matrix with malloc but not sure how, here's the way.

First of all, mxn matrix is m rows and n columns.

We can use double pointers to do this.

First you create memory space for m rows.

Then, you create memory space for n columns.

int ** mat; 

mat = malloc(m * sizeof(int*)); // we are creating memory space for int pointers. This basically means 'we want to create memory space that can hold memory address that can hold array of columns

// each of mat at i'th index is the memory address for each row
// so we need to allocate memories for each row now

for (int i = 0; i < m; i++) {
    mat[i] = malloc(n * sizeof(int));
}

Voila, we are done!

How to create static library in c

Trinity — Sat, 06 Jun 2026 16:51:33 +0000

Summarizing https://www.youtube.com/watch?v=t5TfYRRHG04&t=84s

Create a source file (.c) and header file (.h)
Write function in source file and prototype in header file
Create lib and include directory
gcc -c <source>.c
ar cr lib<name>.a <source>.o. Defines library name output and source object file
ar t lib<name>.a to find out what function names are included
move the lib<name>.a file to lib folder
gcc <source>.c -l<name> -L <library_folder_name> -o <output_file_name> -I <include_folder_name>. If you created lib and include directory that's where they should go under librar_folder_name and include_folder_name.

OOP in C

Trinity — Fri, 05 Jun 2026 18:59:18 +0000

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct Bank {
    struct Bank* this;
    int num_customers;
    int rating;
    char* address;
    float reserve_amt;
    void(* deposit)(struct Bank*, float);
    void(* withdraw)(struct Bank*,float);
    void(* change_address)(struct Bank*, char*);
    void(* customer_enter)(struct Bank*);
    void(* customer_exit)(struct Bank*);
} Bank;

void deposit(struct Bank* bank, float amt);
void withdraw(struct Bank* bank, float amt);
void customer_enter(struct Bank* bank);
void customer_exit(struct Bank* bank);
Bank* create_bank(char* address);

int main() {
    Bank* bank = create_bank("2424 Blackwater Street");
    bank->deposit(bank, 15);
    bank->withdraw(bank, 13);
    printf("The total is %f\n", bank->reserve_amt);
}

Bank* create_bank(char* address) {
    Bank* b = calloc(1, sizeof(Bank));
    b->this = b;
    b->num_customers = 0;
    b->rating = 0;
    b->address = calloc(strlen(address)+1, 1);
    memcpy(b->address, address, strlen(address)+1);
    b->reserve_amt = 0;
    b->withdraw = withdraw;
    b->deposit = deposit;
    b->customer_enter = customer_enter;
    b->customer_exit = customer_exit;
    return b;
}

void deposit(struct Bank* bank, float amt) {
    bank->reserve_amt += amt;
}

void withdraw(struct Bank* bank, float amt) {
    bank->reserve_amt -= amt;
}

void customer_enter(struct Bank* bank) {
    return;
}
void customer_exit(struct Bank* bank) {
    return;
}

Matrix Manipulation in 3d Graphics

Trinity — Fri, 05 Jun 2026 16:24:22 +0000

Translation

Rotation

Scale

Translate \cdot Rotate \cdot Scale ⎣ ⎡ 1000010000105321 ⎦ ⎤ \cdot ⎣ ⎡ 01001000 00 - 1 0 0001 ⎦ ⎤ \cdot ⎣ ⎡ 2000020000200001 ⎦ ⎤ = Scale, then Rotate, then Translate

VIM TIPS - CLOSING BRACKETS AND OTHERS

Trinity — Mon, 25 May 2026 15:41:15 +0000

In your .vimrc file, add inoremap { {}<Esc>ha
This is equivalent to when I type { in insert mode this is equivalent to typing {,},Esc,h,a that is why you can write new text inside the curly braces. (Try typing {}<Esc>ha in insert mode and see where you land)

Now I don't want to go back to normal mode again to jump over the closing bracket.

function! IgnoreIfThereIsOneAlready(char)
    if getline('.')[col('.') - 1] == a:char
        return "\<Esc>la"
    else
        return a:char
    endif

endfunction

inoremap <expr> } IgnoreIfThereIsOneAlready('}')
inoremap <expr> ) IgnoreIfThereIsOneAlready(')')

This is how it looks

how to find and go to the function name
or how to jump to a function

I need to use ctags.. let's do this later

how to insert space when press enter in the curly braces

inoremap <expr> <cr> getline(".")[    col(".")-2:col(".")-1]=="{}" ? "<c    r><esc>O" : "<cr>"

This is how it looks

Creating a shortcut key to open terminal in VIM
I got lazy to type :belowright terminal in command line mode to open terminal inside vim. So set this in vimrc

nnoremap <C-w>t :belowright terminal<cr>

to close it? press control + d

How to create a shortcut to see explorer

I'm too lazy to type :Lexplore and :E override the screen i'm looking, so I'm going to create shortcut for :Lexplore

How to create a ruler on the vim screen

I don't know if my indentations are correct
Q: Is there a way to maybe auto format when I save the document?
For this one, I give up. Indenting is not much an issue for me haha.

How to run `make` command from the file you are on

:make

Checking if there's existing mapping in vim

Check a specific key: :map (e.g., :map ) shows what that key is mapped to.

Assembly Code to Machine Code (ARM)

Trinity — Fri, 22 May 2026 18:22:17 +0000

Summary of the video https://www.youtube.com/watch?v=ttJZjP0p_uE

I have heard assembly code is the closest of how humans can write in a fashion that machines can understand. I have never understood how. Here's the bit of how the translation occurs from assembly instruction to machine code.

In ARM Assembly, the following is the translation from assembly code to binary. After looking at each section in detail, we will try to translate ARM operations into binary operations that machine (ARM chip in this case) understands.

31:28	27:26	25	24:21	20	19:16	15:12	11:0
cond	op	I	cmd	S	Rn	Rd	Src2

Cond

Opcode [31:28]	Mnemonic extension	Interpretation	Status flag state for execution
0000	EQ	Equal / equals zero	Z set
0001	NE	Not equal	Z clear
0010	CS/HS	Carry set / unsigned higher or same	C set
0011	CC/LO	Carry clear / unsigned lower	C clear
0100	MI	Minus / negative	N set
0101	PL	Plus / positive or zero	N clear
0110	VS	Overflow	V set
0111	VC	No overflow	V clear
1000	HI	Unsigned higher	C set and Z clear
1001	LS	Unsigned lower or same	C clear or Z set
1010	GE	Signed greater than or equal	N equals V
1011	LT	Signed less than	N is not equal to V
1100	GT	Signed greater than or equal	Z clear and N equals V
1101	LE	Signed less than or equal	Z set or N is not equal to V
1110	AL	Always	any
1111	NV	Never (do not use!)	none

SOME NOTES

ADD operation takes Opcode 1110 AL for always.
Flag bit is usually the previous operation that results in some bit set. In ADDEQ it will execute if the previous instruction set Z flag to true (1).

op

I

It stands for immediate
Example, ADD, R1, R2, #0x28
If a constant / label is used, then the I field is set to 1

cmd

This is the operation that we are well aware of
It is ARM data processing instructions

Opcode [24:21]	Mnemonic	Meaning	Effect
0000	AND	Logical bit-wise AND	Rd := Rn AND Op2
0001	EOR	Logical bit-wise exclusive OR	Rd := Rn EOR Op2
0010	SUB	Subtract	Rd := Rn - Op2
0011	RSB	Reverse subtract	Rd := Op2 - Rn
0100	ADD	Add	Rd := Rn + Op2
0101	ADC	Add with carry	Rd := Rn + Op2 + C
0110	SBC	Subtract with carry	Rd := Rn - Op2 + C - 1
0111	RSC	Reverse subtract with carry	Rd := Op2 - Rn + C - 1
1000	TST	Test	Scc on Rn AND Op2
1001	TEQ	Test equivalence	Scc on Rn EOR Op2
1010	CMP	Compare	Scc on Rn - Op2
1011	CMN	Compare negated	Scc on Rn + Op2
1100	ORR	Logical bit-wise OR	Rd := Rn OR Op2
1101	MOV	Move	Rd := Op2
1110	BIC	Bit clear	Rd := Rn AND NOT Op2
1111	MVN	Move negated	Rd := NOT Op2

S

Setting S here means, we want the status of operation
For example, ADDS R1, R2, R3 means, put on the status like whether the operation will be Zero, Negative, Carry (this will be shown in CPSR register - which we will cover but not in this article)
ADDS operation will set S status to 1 and let us start tracking the status.

Rn (19:16)

It is called first source register
In ADD R1, R2, R3 Rn is R2
Hence get's binary value of 0010 in 19:16

Rd (15:12)

It is also called destination register
In ADD R1, R2, R3 Rd is R1
Hence it gets binary value of 0001 in 15:12

Src2 (11:0)

Second Source: Can be a variety of things a) Immediate b) Register c) Register-shifted Register

Immediate

11:8	7:0
rot	imm8

rot is for rotation. Mnemonic for it is ROR for rotate right.
NOTE: It is subject to rotate right by twice the value in the rotate field
11:8 bits represent the amount of rotation to right of their immediate counterpart (7:0)

Register

11:7	6:5	4	3:0
shamt5	sh	0	Rm

shamt5 represents amount of shift whether left or right
sh is the shift operators - ops table at the bottom
Rm is the register of target whose values being shifted

Register-shifted Register

11:8	7	6:5	4	3:0
Rs	0	sh	1	Rm

Rs is the register that holds the amount of shift
Rm is the target register whose value is being shifted

sh table

Instruction	sh	Operation
LSL	00	Logical shift left
LSR	01	Logical shift right
ASR	10	Arithmetic shift right
ROR	11	Rotate right

STARTING WITH THE EASY ONE `ADD R5, R6, R7`

Let's unpack one section at a time

cond is ALWAYS hence 1110, since there's no condition to prevent ADD being done.
op is 00
I is 0 (there's no immediate values here)
cmd is ADD which translates to 0100
No Status indicator ADD(S) S is omitted, hence S is 0
Rn is source, hence R6, 0110
Rd is destination, hence R5, 0101
shamt5 is 00000, since there's no shift
Sh is 00 as there's no shift
Rm is src2 hence, 7. 0111.

Combining them leads to

31:28	27:26	25	24:21	20	19:16	15:12	11:7	6:5	4	3:0
1110	00	0	0100	0	0110	0101	00000	00	0	0111
cond	op	I	cmd	S	Rn	Rd	shamt5	sh	N/A	Rm

Nicely formatted binary here:
1110 0000 1000 0110 0101 0000 0000 0111
Care to convert to hex?
0xE0865007

SLIGHTLY HARDER: `ADD R5, R6, R7, LSR #4`

we pick immediate variety for shift operations since because #4 is a literal value

Most are the same except fields 11:0
LSR has sh code as 01
LSR amount is 4 so shamt5 is 00100
Rm is 7, hence 0111

31:28	27:26	25	24:21	20	19:16	15:12	11:7	6:5	4	3:0
1110	00	0	0100	0	0110	0101	00100	01	0	0111
cond	op	I	cmd	S	Rn	Rd	shamt5	sh	null	Rm

LET'S DO MORE: `ADD R0, R1, #42`

The third one is immediate, hence
I is set to 1
Src2 becomes immediate format (rot for 11:8 and immediate value 7:0)

31:28	27:26	25	24:21	20	19:16	15:12	11:8	7:0
1110	00	1	0100	0	0001	0000	0000	00101010
cond	op	I	cmd	S	Rn	Rd	Rot	imm8

BRING SOME MORE! `SUB R2, R3, #0xFF0`

Rd is 2, Rn is 3, imm - 0xff0
SUB has 0010 code.
OH NO, BUT #0xFF0 does not fit in 8 bit.
That's ok. That's what rot is for.
0xFF0 is 0000 0000 0000 0000 0000 1111 1111 0000
0xFF is 0000 0000 0000 0000 0000 0000 1111 1111
How many shift to right will make 0xFF the 0xFF0?
1 shift right is 1000 0000 0000 0000 0000 0000 0111 1111
Following? Let's shift right a little more.
4 shift right is 1111 0000 0000 0000 0000 0000 0000 1111
8 shift right is 1111 1111 0000 0000 0000 0000 0000 0000
guess what? it takes 24 shift right to get 0xFF0!
So, rot should be 12 since by our rule the actual rotation is twice the value at rot.
Hence, the 11:8 bit values will be 1100 and 7:0 1111 1111
which is just a representation of 0xff0 into 8 bit number combined with rotation.

31:28	27:26	25	24:21	20	19:16	15:12	11:8	7:0
1110	00	1	0010	0	0011	0000	1100	11111111
cond	op	I	cmd	S	Rn	Rd	Rot	imm8

WHAT ABOUT THIS? `LSL R0, R9, #7`

WAIT WAIT... LSL is not in the command table. How am I supposed to put in the bit field 24:21?
Thanks Rakesh, the creator of the video: Basically LSL is equivalent to this: MOV R0, R9, LSL #7
Wait again... Rakesh says R9 is not Rn... Hm.. I thought it would be the same as how SUB was done above.
In the MOV operation, that's not the case, as per user guide armasm user guide page 333 MOV R0, R9, LSL #7 applies to the following syntax: MOV{S}{cond} Rd, Operand2 where operand2 is (according to page 244 the same guide) can be Register with optional shift.. Hence, on page 246 of the guide it says, register with optional shift, is Rm{, shift}.
Still following?
Hence, R9 here is Rm, where Rm is the register holding the data for the second operand.
Hence, Rn here is 0 and Rm is 9
(BY THE WAY THE REFERENCE I'M TALKING ABOUT IS armasm User Guide Version 6.6) - the latest is here

31:28	27:26	25	24:21	20	19:16	15:12	11:7	6:5	4	3:0
1110	00	0	1101	0	0000	0000	00111	00	0	1001
cond	op	I	cmd	S	Rn	Rd	shamt5	sh	null	Rm

OK TAKE A BREAK AND COME BACK! `ROR R3, R5, #21`

GUESS WHAT.. SHIFT AGAIN! Which means Rm is 5
This is equivalent to MOV R3, R5, ROR, #21
Same translation step for LSL above..

31:28	27:26	25	24:21	20	19:16	15:12	11:7	6:5	4	3:0
1110	00	0	1101	0	0000	0011	10101	11	0	0101
cond	op	I	cmd	S	Rn	Rd	shamt5	sh	null	Rm

KEY TAKEAWAY:

There's no one rule for all in the translations. Sometimes, you have to look up command table sometimes you will face operation that are not in one table hence, need to break down the command.
But, all should be translated to binary otherwise, machine won't understand! So, let's stick to the basics and see if we can translate!!!!!
Good news and bad news: You and I have learned how to translate,, not entirely but seen a bit of it... But these translation steps will be also different in A64 architecture but... we learned how to apply our knowledge in some way... Some methods must be similar... must be..

OK AFTER YOUR DINNER... `LSR R4, R8, R6`

This time the shift amount is in R6.
Does that make R8, the source register the Rn?
NOPE!!
This is equivalent to MOV R4, R8, LSR, R6
R6 is Rs haha! Found it!
Rm is 8 hohoho

31:28	27:26	25	24:21	20	19:16	15:12	11:8	7	6:5	4	3:0
1110	00	0	1101	0	0000	0100	0110	0	01	1	1000
cond	op	I	cmd	S	Rn	Rd	Rs	N/A	sh	N/A	Rm

PHEW LET'S SLEEP AFTER THIS... `ASR R5, R1, R12`

What is Rd, Rn, Rm, Rs?? Is some of them 0? Which one?
Answer below:

31:28	27:26	25	24:21	20	19:16	15:12	11:8	7	6:5	4	3:0
1110	00	0	1101	0	0000	0101	1100	0	10	1	0001
cond	op	I	cmd	S	Rn	Rd	Rs	N/A	sh	N/A	Rm

BASIC COMPILATION COMMANDS - GCC

Trinity — Thu, 21 May 2026 11:03:17 +0000

GCC - MAIN command to invoke compiler

-o set name of output file
-E Stop after the preprocessing stage; Creates preprocessed files
-S Stop after the assembly; Creates assembly files
-c Assemble the source files; Creates object files
-save-temps Do not delete intermediate files

Source

ARM BASICS

Trinity — Mon, 18 May 2026 19:50:30 +0000

STR Rx, [Ry]

STORE the value of Rx into the memory with address saved in Ry. So, it's not 'Save value of R3 into R1.' More precisely, suppose R1 has memory address 0x1234, then program will look up memory 0x1234 and save the value there, not directly into R1.

LDR Rx, [Ry]

Program: I will look up the value of Ry, that will be your memory address I will look up, then I will load the value in that memory into Rx.

To wake up cores, you need to

Save the program counter somewhere
Save the #0xe0 or #0xe8 or #0xf0 for core 1, 2, and 3 respectively
Move the PC address into the memory address above.

Hot take - you don't need react

Trinity — Fri, 21 Feb 2025 03:30:20 +0000

don't learn react
just learn javascript and typescript and build one without using react because react is just javascript and typescript.
if anyone tells you react is to ease your life in building software, know it is not, you can do it with just javascript and typescript, react is just a bloat, trying to obscure your understanding of the subject.

Core C++ OOP Concepts

Trinity — Thu, 08 Sep 2022 02:37:15 +0000

Four concepts:

Encapsulation - setting access level for whatever is inside a class
Abstraction - creating a design of things you like

Things learned today

When you write static array and assign to a variable with less than x in array[x] then the rest of the space is by default filled in as 0 (in c++ 14)
If you do not specify the length of the array, then the size is size of element multiplied by how many you put in when you initialize
array as argument in a function parameter will 'read' only one element (int* aka pointer to int)

Pointer & Reference & Deference in C++

Trinity — Sat, 16 Jul 2022 08:26:16 +0000

Say you have a variable 'a' of type integer.
int a = 4;

Then, you can find the address of 'a' using pointer.
int *b = &a;

Well, not exactly because '&a' will give you the address as well. Try,
cout << &a; // will output address of the variable a

But, back to the pointer, it gives you the ability to 'save' the address of memory. Hence, it will show memory address of 'a' as well. Try,
cout << b

What would happen if I try printing out *b? It will give you the value of 'a'. Weird, isn't it? This behavior is called dereferencing, meaning you get the actual value of whatever is saved in that memory.

Does b have memory address as well? Yes, you can access it with '&b'

So, in summary

int a = 4; // note it has memory allocated to this integer
int *b = &a; // you can save the memory address to a variable 'a'
cout << b; // it will give you memory address of 'a'. Notice how it is not saved in '*b' but 'b' itself. 
cout << &a; // this will give you memory address of 'a'
cout << *b; // this will give you the value of 'a'. Dereferenced!

Question remains: what would &*b produce? what will *&a produce?

Answer:
&*b -> it is address of pointer to 'a', hence same as &a, memory address where 'a' is saved.
*&a -> * dereferences memory address aka finds out the value in the address hence value of 'a'

Blindly Following Other People's Solution

Trinity — Fri, 17 Jun 2022 21:36:02 +0000

There are some things I do not understand in the coding world: Making assumptions like it's true. Let's see this solution to binary search.

The question is to find a target number in an array of numbers. If the target is not in the array, return -1. If it is, return the index of the target in the array.

This user's coding solution is brilliant

var search = function(nums, target) {
    let lo = 0, hi = nums.length-1;
    while (lo < hi) {
        let mid = lo + Math.floor((hi-lo+1)/2);
        if (target < nums[mid]) {
            hi = mid - 1
        } else {
            lo = mid; 
        }
    }
    return nums[lo]==target?lo:-1;
};

The solver goes on further to explain (which I really appreciate by the way rather than simply writing down solution) the logic behind his choice of indexes of midpoint, low, and high.

Quote

But! That seemingly sound very mathematical or programmatic is actually not that rigorous because if you change lo+hi/2 to lo+hi+1/2 there won't be an overflow. So, there is nothing wrong with that certain operations.

This, I think is the problem in trying to understand every leetcode problem on the high level. You will not get things correct.

Beware folks! You never know what's true until you see and understand how it works.