• Odpowiedz

@mateusz_s, post #1

• Odpowiedz

@mateusz_s, post #2

• Odpowiedz

@mateusz_s, post #1

Bardzo dużo używam sprintf (a dokładniej snprintf) i nigdy nie miałem z tym problemów wydajnościowych. Ale ja od wielu lat nie dotykałem nic słabszego niż G4.
Ciężko powiedzieć co tam siedzi w implementacji sprintf, ale ze względu na swoją uniwersalność na pewno nie jest to prosta funkcja.

Gdy zapytamy ChatGPT o to żeby zaproponował coś szybszego od sprintf to poleci (ale bez wielkiego przekonania) coś w tym stylu:

#include <stdio.h>
#include <string.h>

void intToStr(int liczba, char str[]) {
    int i = 0;
    int isNegative = 0;

    // Sprawdzamy, czy liczba jest ujemna
    if (liczba < 0) {
        isNegative = 1;
        liczba = -liczba;  // Zmieniamy znak liczby na dodatni
    }

    // Wyciągamy cyfry
    do {
        str[i++] = (liczba % 10) + '0';  // Pobieramy najmniej znaczącą cyfrę i zamieniamy ją na znak ASCII
        liczba /= 10;                    // Dzielimy liczbę przez 10, aby przesunąć się do kolejnej cyfry
    } while (liczba > 0);

    // Jeśli liczba była ujemna, dodajemy znak minus
    if (isNegative) {
        str[i++] = '-';
    }

    // Dodajemy znak końca stringa
    str[i] = '\0';

    // Odwracamy string, ponieważ cyfry zostały zapisane w odwrotnej kolejności
    int len = strlen(str);
    for (int j = 0; j < len / 2; j++) {
        char temp = str[j];
        str[j] = str[len - j - 1];
        str[len - j - 1] = temp;
    }
}

int main() {
    int liczba = -12345;
    char str[12];
    intToStr(liczba, str);
    printf("Liczba jako string: %s\n", str);
    return 0;
}

Bardzo kusi pozbycie się tego odwracania stringa na końcu.
Dobrze byłoby zmierzyć czas w jaki operacja wykona się np. 10000 razy z użyciem sprintf() i tego jego intToStr(). Wiedzielibyśmy czy gra jest warta świeczki czy nie warto się bić.

Ostatnia aktualizacja: 24.09.2024 21:33:59 przez MDW

• Odpowiedz

@MDW, post #4

• Odpowiedz

@teh_KaiN, post #5

• Odpowiedz

@_DiskDoctor_, post #3

void    E_fast_font__render_max_3_digits(int _number, int _color_offset, unsigned char* _dst)
{
    int hundred = _number / 100;
    int ten = (_number % 100) / 10;
    int one = _number % 10;

    _dst -= 4;
    if (one == 1) _dst += 2;

    e_fast_font__render_digit[one](_dst, e_fast_font + _color_offset);

    if (hundred != 0)
    {
        _dst -= 4;
        if (ten == 1) _dst += 2;

        e_fast_font__render_digit[ten](_dst, e_fast_font + _color_offset);

        _dst -= 4;
        if (hundred == 1) _dst += 2;

        e_fast_font__render_digit[hundred](_dst, e_fast_font + _color_offset);
    }
    else if(ten != 0)
    {
        _dst -= 4;
        if (ten == 1) _dst += 2;

        e_fast_font__render_digit[ten](_dst, e_fast_font + _color_offset);
    }
}

• Odpowiedz

@teh_KaiN, post #5

• Odpowiedz

@mateusz_s, post #8

• Odpowiedz

@kiero, post #9

• Odpowiedz

@mateusz_s, post #7

• Odpowiedz

@mateusz_s, post #1

#include <stdio.h>

char* IntToStr(int Liczba);
char  Check(int *LiczbaA, char factor);

int main(void)
{
        int liczba = 234;

        printf("%s\n", IntToStr(liczba));

        return(0);
}

char* IntToStr(int Liczba)
{
        static char str[4];
                
        str[0] = Check(&Liczba, 100);
        str[1] = Check(&Liczba, 10);
        str[2] = Check(&Liczba, 1);
        str[3] = '\0'; 

        return(str);
}

char Check(int *LiczbaA, char factor)
{
        char x = '0' - 1;

        do
        {
                *LiczbaA -= factor;
                x++;
        }
        while(*LiczbaA >= 0);

        *LiczbaA += factor;
        
        return(x);
}

• Odpowiedz

@Phibrizzo, post #12

• Odpowiedz

@Don_Adan, post #11

• Odpowiedz

@teh_KaiN, post #5

__asm UBYTE addBCD(register __a0 UBYTE *op1, register __a1 UBYTE *op2);

CYFRY equ 8

_addBCD:
    adda.w #CYFRY/2,a0
    adda.w #CYFRY/2,a1
    abcd  -(a1),-(a0)
    abcd  -(a1),-(a0)
    abcd  -(a1),-(a0)
    abcd  -(a1),-(a0)
    scs   d0
    rts

#define CYFRY 8

char test[ CYFRY ] = "00012345";

void znaki_do_bcd(char bcd[], char cyfry[])
{
    int i;

    for( i = 0; i < CYFRY / 2; i++)
    {
        bcd[i] = ((cyfry[i * 2] - '\0') << 4) | (cyfry[i * 2 + 1] - '\0');
    }       
}

addBCD( punkty_bcd, bonus_bcd );

char bcd_do_znaki(char cyfry[], char bcd[])
{
    int i;
    for( i = 0; i < CYFRY / 2; i++)
    {
        cyfry[i * 2] = (bcd[i] >> 4) + '\0';
        cyfry[i * 2 + 1] = (bcd[i] & 0xf) + '\0';
    }    
}

• Odpowiedz

@mateusz_s, post #7

• Odpowiedz

@Hexmage960, post #15

Moja intuicja podpowiada, że to rozwiązanie z BCD będzie najszybsze. Po to właśnie powstało BCD

Jeśli operacji wyświetlania liczby będzie dużo więcej niż jej zmian, to można rozważyć zapamiętywanie każdej cyfry w osobnym bajcie (w tym przypadku 3 bajty). Wtedy trzeba tylko oprogramować operacje arytmetyczne i porównania na takiej liczbie (dodawania i odejmowanie będą proste).
Jeśli porównań będzie sporo, to można dla nich przechowywać kopię liczby w klasycznym bajcie.

• Odpowiedz

@mateusz_s, post #1

void HudDrawLives(void)
{
	UWORD nr = gm->lives;

	ULONG scrOfs = 26;

	if (nr > 9)
	{
		nr = 9;
	}

	char c = '0' + nr;

	GfxSmallFontItemsAdd(c, scrOfs);
}

void HudDrawGems(void)
{
	UWORD nr = gm->totalItems;
	ULONG scrOfs = 13;

	char c = '0';
	while (nr > 99)
	{
		c++;
		nr -= 100;
	}
	GfxSmallFontItemsAdd(c, scrOfs++);

	c = '0';

	while (nr > 9)
	{
		c++;
		nr -= 10;
	}
	GfxSmallFontItemsAdd(c, scrOfs++);

	c = '0' + nr;
	GfxSmallFontItemsAdd(c, scrOfs++);
}

• Odpowiedz

@asman, post #18

• Odpowiedz

@Don_Adan, post #19

• Odpowiedz

@mateusz_s, post #20

• Odpowiedz

@mateusz_s, post #20

• Odpowiedz

@Krashan, post #21

• Odpowiedz

@Don_Adan, post #22

char* NumToStr(short liczba, char *bufor)
{
	char k = 47;

	do
	{
		liczba -= 100;
		k++;
	}
	while (liczba >= 0);

	liczba += 100;
	bufor[0] = k;
	k = 47;
	
	do
	{
		liczba -= 10;
		k++;
	}
	while (liczba >= 0);
	
	bufor[1] = k;
	bufor[2] = 58 + liczba;
	bufor[3] = 0x00;
	return bufor;
}

_NumToStr:
    MOVEQ   #47,d1
.1: ADDQ.B  #1,d1
    ADDI.W  #-100,d0
    BPL.S   .1
    ADDI.W  #100,d0
    MOVE.B  d1,(a0)
    MOVEQ   #47,d1
.2: ADDQ.B  #1,d1
    ADDI.W  #-10,d0
    BPL.S   .2
    MOVE.B  d1,1(a0)
    ADDI.B  #58,d0
    MOVE.B  d0,2(a0)
    CLR.B   3(a0)
    MOVE.L  a0,d0
    RTS

• Odpowiedz

@mateusz_s, post #20

'\0'

'0'

char cyfry[] = { 0, 0, 0, 1, 2, 3, 4, 5 };

char ascii[] = "00012345";

char bcd[] = { 0x00, 0x01, 0x23, 0x45 };

• Odpowiedz

@Krashan, post #24

_NumToStr
	movem.l	l134,-(a7)
	moveq	#10,d4
	moveq	#100,d3
	move.w	(6+l136,a7),d1
	move.l	(8+l136,a7),a1
	moveq	#47,d2
l115
	sub.w	d3,d1
	addq.b	#1,d2
	tst.w	d1
	bge	l115
	add.w	d3,d1
	move.b	d2,(a1)
	moveq	#47,d2
l116
	sub.w	d4,d1
	addq.b	#1,d2
	tst.w	d1
	bge	l116
	move.b	d2,(1,a1)
	move.w	d1,d0
	ext.l	d0
	add.l	#58,d0
	move.b	d0,(2,a1)
	move.b	#0,(3,a1)
	move.l	a1,d0
l134	reg	d2/d3/d4
	movem.l	(a7)+,d2/d3/d4
l136	equ	12
	rts

_NumToStr:	moveq	#$2F,d1
lbC0000A6:	add.w	#$FF9C,d0
	addq.b	#1,d1
	tst.w	d0
	bge.s	lbC0000A6
	add.w	#$64,d0
	move.b	d1,(a0)
	moveq	#$2F,d1
lbC0000B8:	add.w	#$FFF6,d0
	addq.b	#1,d1
	tst.w	d0
	bge.s	lbC0000B8
	move.b	d1,1(a0)
	add.b	#$3A,d0
	move.b	d0,2(a0)
	clr.b	3(a0)
	move.l	a0,d0
	rts

• Odpowiedz

@asman, post #26

void NumToStr(short liczba, char *bufor)
{
	char k = 47;
	short sto = 100, dycha = 10;
	
	do
	{
		k++;
		liczba -= sto;
	}
	while (liczba >= 0);

	liczba += sto;
	*bufor++ = k;
	k = 47;
	
	do
	{
		k++;
		liczba -= dycha;
	}
	while (liczba >= 0);
	
	*bufor++ = k;
	*bufor++ = 58 + liczba;
	*bufor = 0x00;
}

_NumToStr:
    MOVE.L   d2,-(sp)
    MOVEQ    #47,d1
    MOVEA.W  #100,a1
    MOVEQ    #10,d2
.1: ADDQ.B   #1,d1
    SUB.W    a1,d0
    BPL.S    .1
    ADD.W    a1,d0
    MOVE.B   d1,(a0)+
    MOVEQ    #47,d1
.2: ADDQ.B   #1,d1
    SUB.W    d2,d0
    BPL.S    .2
    MOVE.B   d1,(a0)+
    ADDI.B   #58,d0
    MOVE.B   d0,(a0)+
    CLR.B    (a0)
    MOVE.L   (sp)+,d2
    RTS

• Odpowiedz

@mateusz_s, post #1

• Odpowiedz

@Krashan, post #24

; input D0 (word)
; output D1 (longword)
; D2 temp

 move.l #$FFFF00FF,D1 ; wartosci poczatkowe to $FF dla kazdej z 3 cyfr
 moveq #100,D2
B100
 addq.b #1,D1
 sub.w D2,D0
 bcc.b B100
 add.w D2,D0
 swap D1 ; pierwsza cyfra ustawiona
 moveq #10,D2
B10
 addq.b #1,D1
 sub.w D2,D0
 bcc.b B10
 add.w D2,D0
 lsl.w #8,D1 ; druga cyfra ustawiona
 move.b D0,D1 ; trzecia cyfra ustawiona
 rts

• Odpowiedz

@Don_Adan, post #29

; input D0 (word)
; output D1 (longword)
; D2, A0 temp

 move.l #$FFFF00FF,D1 ; wartosci poczatkowe to $FF dla kazdej z 3 cyfr
 moveq #100,D2
B100
 addq.b #1,D1
 sub.w D2,D0
 bcc.b B100
 add.w D2,D0
 swap D1 ; pierwsza cyfra ustawiona
 moveq #10,D2
 lea $100.W,A0
B10
 add.w A0,D1 ; druga cyfra ustawiana
 sub.w D2,D0
 bcc.b B10
 add.w D2,D0
 move.b D0,D1 ; trzecia cyfra ustawiona
 rts

• Odpowiedz