[C] Decimaal naar binair (gcc Linux)

[Verwijderd]

Ik heb me al kleurenblind gezocht maar kan het niet vinden

Volgens mij is er geen standaart functie om een decimaal getal
naar een binair getal of string te krijgen in C.

ik gebruiktje vroeger altijd itoa in C++ daarbij kon het wel,
maar dat zit niet in gcc.

Ik heb een formule om van dec naar bin te gaan
Die gebruikt log, maar als ik:
a = log(45);
doe geeft gcc ook een foutmelding..(Undefined reference to `log')
Volgens mij moet die functie toch wel bestaan?

Dit is trouwens de 1e keer dat ik C en op Linux programmeer....

Ik kan wel C++ en php ..... bla bla lijst
maar daz VEEL makkelijker hoor....


Weet iemand misschien een manier voor me op een dec getal om te zetten naar
binair.. Of een oplossing voor de log() functie error?

[bras]

heb je #include <math.h> bovenaan je code staan?

'man 3 log' en 'man 3 math' voor de instructies (bij mij)

[ Voor 44% gewijzigd door bras op 03-11-2003 02:51 ]

[hannos]

je kunt ook gewoon een functie maken die het voor je berekent ik weet zo niet welke functies allemaal in de math library staan maar denk dat log() er haast wel in moet staan

[.oisyn]

itoa is geen ANSI. Overigens is er voor de computer geen verschil tussen een decimaal getal en een binair getal: het is beide een gewoon een bepaalde waarde.
Als je er een string van wilt hebben dan zul je sprintf () moeten gebruiken, maar die kan alleen maar een decimale of een hexadecimale representatie ervan weergeven.

Een eigen itoa () variant maken is overigens niet moeilijk: je kunt alle digits uitrekenen door in een loopje het getal modulo het grondtal te namen (dat is je digit), en vervolgens het getal te delen door het grondtal. En dat net zo lang tot je bij 0 bent. En het grondtal is dan 2 of 10, voor respectivelijk binair en decimaal.

De log functie zit idd in math.h, hoewel ik het verband niet helemaal zie met de berekeningen die je wilt doen

[Soultaker]

.oisyn schreef op 03 november 2003 @ 02:59:
De log functie zit idd in math.h, hoewel ik het verband niet helemaal zie met de berekeningen die je wilt doen

Iemand die geen restdeling kent zal al snel ²log(x) willen gebruiken, lijkt me zo.

[.oisyn]

Nou ja daar kun je hooguit mee berekenen hoeveel digits je nodig gaat hebben voor het getal imho

.edit: ik had even niets te doen

C++:

char * itoa (int value, char * buffer, int radix)
{
    static const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
    char temp[32];
    unsigned v = (unsigned)value;

    if (radix == 10 && value < 0)
        v = (unsigned)(-value);

    int pos = 0, i;
    do
    {
        temp[pos++] = digits[v % radix];
        v /= radix;
    }
    while (v > 0);

    i = 0;
    if (radix == 10 && value < 0)
        buffer[i++] = '-';

    while (pos > 0)
        buffer[i++] = temp[--pos];

    buffer[i] = 0;
    return buffer;
}

voldoet als het goed is aan de eisen die gedefinieerd zijn voor de reguliere itoa versie (alleen signed als radix == 10, en geeft een '-' teken ervoor als value < 0)

[ Voor 79% gewijzigd door .oisyn op 03-11-2003 03:39 ]

[Verwijderd]

Verwijderd schreef op 03 november 2003 @ 02:40:Volgens mij is er geen standaart functie om een decimaal getal naar een binair getal of string te krijgen in C.

Volgens mij is een decimaal getal hetzelfde als een binair getal; getallen worden in je computer binair opgeslagen. Dus ik snap waarschijnlijk de vraag niet.

// edit: .oisyn had dat ook al gezegd; ik moet beter leren lezen

.oisyn heeft al aangegeven hoe je converteert naar een string (mbv sprintf). En de andere kant uit gebruik je atoi of strtol.

[ Voor 8% gewijzigd door Verwijderd op 03-11-2003 07:13 . Reden: eerdere post niet goed gelezen ]

[Verwijderd]

Ik had de math.h geinclude in mijn code.
dus de log() functie had wel moeten werken denk ik.
Ik had ook nog even sqrt() geprobeerd, maar die paktje hij ook niet.
Wat nou precies het probleem is, weet ik niet. Maar ik kom er wel achter als
ik meer ervaring krijg met het C'en op Linux

Ik zal even vertellen waarmee ik bezig ben.
Ik heb vanalles aangesloten op m'n LPT port.
(lampen, kamerlicht, ventilator aquarium zooi .... enz)
Wordt allemaal met crontab of via me php interface aangestuurd

nu wil ik ook een interface programmatje op de commandline.. die een overzicht kan weergeven (l33t ascii dan ) , of alleen een waarde teruggeeft (aan de hand van de parameters die je mee geeft, bijvoorbeeld 24 of 00011000

het programmatje wat ik nu heb geeft alleen een decimale waarde
die ik in php verder verwerk tot een overzicht. Als ik *klik* op een device
bepaald php de nieuwe decimale waarde en stuurt die naar een 2e programmatje dat de lpt aanstuurd

Het werkt perfect, alleen nu ben ik weer wat nieuws van plan met sensoren enz0
en nu lijkt het me handig om deze twee C programmatjes samen te voegen en meer functionaliteit te geven. (en even de php code aanpassen)

op deze manier hoef ik ook niet overal de device list aan te passen maar het op een centraal punt (tekst file ofzo) neer te zetten.


Bedankt voor de reacties allemaal!!
Ik ga meteen even ALLES proberen wat jullie gezegt hebben!!

[farlane]

Als je cmath include staan die functies wel in de std namespace, die moet je dan wel ff 'using std::log' doen.

Btw, heb je de math lib wel meegelinked met -lmath ?

[edit]

Oops, het gaat hier over C.

[ Voor 15% gewijzigd door farlane op 03-11-2003 14:19 ]

[curry684]

oisyn: is deze niet veel sneller?

C:

char* itoa (int value, char * buffer, int radix = 10) 
{
static const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; 
char              temp[33];
char*            p = temp + 33;
unsigned int      val = (unsigned int)value;

--(*p) = '\0';
do
  {
  --(*p)  = digits[val % radix];
  val    /= radix;
  }
while(val);
if(value < 0 && radix == 10)
  --(*p)  = '-';
return strcpy(buffer, p);
}

Die van jou is trouwens geen valide C-code, je declareert 2 variabelen midden in de functie

* curry684 had ook even 2 minuten niets te doen....

[ Voor 3% gewijzigd door curry684 op 03-11-2003 14:53 . Reden: bugje :) ]

[.oisyn]

curry684 schreef op 03 november 2003 @ 14:09:
Die van jou is trouwens geen valide C-code, je declareert 2 variabelen midden in de functie

uh ja ik had die radix check ertussen gevrot nadat ik gekeken had naar de specs van itoa

[ Voor 8% gewijzigd door .oisyn op 03-11-2003 16:32 ]

[MSalters]

curry684 schreef op 03 november 2003 @ 14:09:
Die van jou is trouwens geen valide C-code, je declareert 2 variabelen midden in de functie

Is wel C, C99 zelfs

[curry684]

MSalters schreef op 03 november 2003 @ 17:40:
[...]

Is wel C, C99 zelfs

Is de 3e keer in een maand of zo dat ik C99 om m'n oren krijg, misschien moet ik die standaard toch eens bijlezen

[Verwijderd]

Het is me gelukt met de binaire getallen en het inlezen van tekst files.. !!

Ik wil mijn programma zo maken dat ik hem maar 1 keer kan starten
en een sleeptime kan meegeven...

bijvoorbeeld: prog --sleep 15

In die 15 sec slapen, mag hij niet nog een keer gestart worden....
pas na die 15 sec wordt het programma afgesloten en kan hij opnieuw gestart worden...

Weet iemand hoe ik in C code kan checken of het programma al loopt?

Ik las en deed net wat met fork(), maar dit is volgens mij niet de oplossing.

Ik kan ook een text file openen en hier een bit in zetten maar dit vindt ik eigelijk niet echt netjes

[ Voor 10% gewijzigd door Verwijderd op 04-11-2003 03:50 ]

[.oisyn]

Onder linux weet ik het niet, maar onder windows kun je een named mutex aanmaken

[Verwijderd]

Onder Linux (Windows overigens ook) zou je een lock kunnen maken. Of er een officiele manier is, weet ik niet.

// edit
Het volgende is zoals je zelf min of meer al aangaf (weer niet goed gelezen). Er zijn genoeg programma's die het op deze manier doen.
// edit_end

Als je programma start, controleert het of een bepaalde file bestaat. Bestaat die niet, dan maakt het programma die file aan. Bestaat de file wel, dan stopt de nieuwe instantie van het programma.
Als het programma sluit, verwijdert het de file weer.

Het kan handig zijn om de PID van het proces, dat de file heeft aangemaakt, in die file te zetten. Dan kan bij een tweede start aangegeven worden welke programma (welke pid) de file heeft aangemaakt.

Enige nadeel is dat een crash als resultaat kan hebben dat de file niet verwijderd wordt. Als je de pid in de file opslaat, kan de nieuwe instantie van het programma controleren of het proces dat de lock heeft aangemaakt nog draait (vraag me nu niet hoe) en eventueel toch doorstarten (lock verwijderen en opnieuw aanmaken).

Verder moet de file wel op een vaste plaats staan; hiervoor kun je bv een speciale lock-directory aanmaken. Afhankelijk van de toepassing kan dat in de gebruikers directory of op een algemenere plaats.

[ Voor 9% gewijzigd door Verwijderd op 04-11-2003 19:15 . Reden: laatste edit: typo ]

[kenneth]

Onder Linux kan je IPC (Inter-Process Communication) gebruiken.

Zie hier voor een tutorial.

[Soultaker]

Je zou in theorie ook op de executable zelf kunnen locken, maar dat is een beetje een gemakzuchtige oplossing waar wel wat nadelen aan kleven.

[ Voor 4% gewijzigd door Soultaker op 04-11-2003 15:20 ]

[igmar]

Verwijderd schreef op 04 november 2003 @ 03:45:
Weet iemand hoe ik in C code kan checken of het programma al loopt?

Door een .pid file te schrijven met daarin het procesnummer van het proces. Over het algemeen zet je die in /var/run neem, mits je root privileges hebt dat is.

Met kill() kun je controleren of dat process nog bestaat, is dat niet het geval verwijder je die pidfile en maak je 'm opnieuw aan.

[ Voor 17% gewijzigd door igmar op 04-11-2003 19:02 ]

[MSalters]

't Is niet zo netjes om met root processen te gaan killen die toevallig hetzelfde pid hebben als jouw proces ooit had.

[Verwijderd]

Verwijderd schreef op 03 november 2003 @ 13:24:
Ik had de math.h geinclude in mijn code.
dus de log() functie had wel moeten werken denk ik.
Ik had ook nog even sqrt() geprobeerd, maar die paktje hij ook niet.

Volgens mij link je niet tegen de math library (libm.so). Doe je wel gcc -o executable bestand.c -lm? De -lm linkt tegen libm.so. .

[Verwijderd]

Verwijderd schreef op 04 november 2003 @ 03:45:
Weet iemand hoe ik in C code kan checken of het programma al loopt?

Je kan lockfiles aanmaken, of je kan het programma scriptwise starten, en dan vooraf laten gaan door:

Bash:

#!/bin/bash

EXECUTE=$1

# check of we al runnen
echo "Checking whether $EXECUTE is already started..."
if ( ps -A | grep $EXECUTE | grep -v grep); then
  echo "$EXECUTE is still running"
  exit 0
fi

# we runnen niet, dus laten we proberen te starten
echo "$EXECUTE is not running, re-starting..."
exec $EXECUTE

Dan hoef je 't niet in C te doen, dit is veel simpeler. .

[Soultaker]

MSalters schreef op 04 november 2003 @ 20:51:
't Is niet zo netjes om met root processen te gaan killen die toevallig hetzelfde pid hebben als jouw proces ooit had.

Met kill verstuur je een signaal; je hoeft niet per se het proces stuk te maken. Als je een onschuldig signaal als bijvoorbeeld SIGCONT (CONTINUE: ga maar door met processen) stuurt, dan merkt de applicatie daar helemaal niets van (by default negeert 'ie het signaal en als de applicatie er een andere implementatie aan heeft gegeven die een beetje in de buurt van de bedoelde betekenis komt dan gebeurt er niets fataals).

Je wil met je signaal ook alleen controleren of het proces bestaat; is dat het geval, dan sluit je het nieuwe proces af. Het is dus niet zo dat je het oude proces zou moeten afsluiten.

[.oisyn]

sorry voor de kick, maar de topic kwam weer naar boven borrelen door een link van curry, en toen ik het nog eens doorlas bedacht ik me nog iets

curry684 schreef op 03 november 2003 @ 14:09:
oisyn: is deze niet veel sneller?

C:

char* itoa (int value, char * buffer, int radix = 10) 
{
static const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; 
char              temp[33];
char*            p = temp + 33;
unsigned int      val = (unsigned int)value;

--(*p) = '\0';
do
  {
  --(*p)  = digits[val % radix];
  val    /= radix;
  }
while(val);
if(value < 0 && radix == 10)
  --(*p)  = '-';
return strcpy(buffer, p);
}

ik denk dat dat nog wel eens negatief kan uitpakken. Je vult je buffer namelijk van achter naar voor, waardoor je dus erg veel cache misses kunt krijgen. Ik kopieer 'm ook van achter naar voor, maar dat is nadat ik 'm van voor naar achteren gevuld hebt, dus het staat waarschijnlijk nog gewoon in de cache (tenzij er een task switch heeft plaatsgevonden in de tussentijd, dan is de kans dat het er nog in staat een stuk kleiner)

care for a benchmark?

PS. Die van jou is echt geen valide C, door die default parameter

.edit: laat maar, die van jou is niet correct, ik win
.edit2: logisch ook, je doet --(*p), wat dus de waarde waar p naar wijst verminderd met 1 Je bedoelt natuurlijk *--p

[ Voor 12% gewijzigd door .oisyn op 21-11-2003 14:17 ]

[curry684]

_{edit ipv post, duh}

[ Voor 166% gewijzigd door curry684 op 21-11-2003 14:46 ]

[.oisyn]

Ik had gelijk

Bij een dynamisch gealloceerde buffer is die van mij een fractie sneller:

code:

itoa_curry: 0.360518 (total: 9.68392, avg: 0.372459)
itoa_oisyn: 0.370533 (total: 9.60381, avg: 0.369377)
itoa_curry: 0.380547 (total: 10.0645, avg: 0.372758)
itoa_oisyn: 0.380547 (total: 9.98436, avg: 0.369791)
itoa_curry: 0.360518 (total: 10.425, avg: 0.372321)
itoa_oisyn: 0.370533 (total: 10.3549, avg: 0.369817)
itoa_curry: 0.380547 (total: 10.8055, avg: 0.372605)
itoa_oisyn: 0.360518 (total: 10.7154, avg: 0.369497)
itoa_curry: 0.370533 (total: 11.1761, avg: 0.372536)
itoa_oisyn: 0.370533 (total: 11.0859, avg: 0.369531)
itoa_curry: 0.360518 (total: 11.5366, avg: 0.372148)
itoa_oisyn: 0.380547 (total: 11.4665, avg: 0.369887)

(tijd per 200.000 iteraties)

Bij een statische buffer is die van jou sneller, omdat ie dan in de cache staat:

code:

itoa_curry: 0.520749 (total: 2.65382, avg: 0.530763)
itoa_oisyn: 0.550792 (total: 2.76397, avg: 0.552795)
itoa_curry: 0.540778 (total: 3.19459, avg: 0.532432)
itoa_oisyn: 0.550792 (total: 3.31477, avg: 0.552461)
itoa_curry: 0.550792 (total: 3.74539, avg: 0.535055)
itoa_oisyn: 0.530763 (total: 3.84553, avg: 0.549361)
itoa_curry: 0.550792 (total: 4.29618, avg: 0.537022)
itoa_oisyn: 0.540778 (total: 4.38631, avg: 0.548288)
itoa_curry: 0.530763 (total: 4.82694, avg: 0.536327)
itoa_oisyn: 0.540778 (total: 4.92708, avg: 0.547454)
itoa_curry: 0.530763 (total: 5.3577, avg: 0.53577)
itoa_oisyn: 0.540778 (total: 5.46786, avg: 0.546786)

(tijd per 2.000.000 iteraties)

maar in de praktijk maakt het weinig uit, het scheelt zo'n 0.01 seconde per 1 miljoen iteraties, verwaarloosbaar dus


de code:

C++:

#include <iostream>
#include <windows.h>
#include <conio.h>

char * __declspec (noinline) itoa_oisyn (int value, char * buffer, int radix) 
{ 
    static const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; 
    char temp[32]; 
    unsigned v = (unsigned)value; 

    if (radix == 10 && value < 0) 
        v = (unsigned)(-value); 

    int pos = 0, i; 
    do 
    { 
        temp[pos++] = digits[v % radix]; 
        v /= radix; 
    } 
    while (v > 0); 

    i = 0; 
    if (radix == 10 && value < 0) 
        buffer[i++] = '-'; 

    while (pos > 0) 
        buffer[i++] = temp[--pos]; 

    buffer[i] = 0; 
    return buffer; 
}

char * __declspec (noinline) itoa_curry (int value, char * buffer, int radix = 10)  
{ 
    static const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";  
    char              temp[33]; 
    char*             p = temp + 33; 
    unsigned int      val = (unsigned int)value; 

    *--p = '\0'; 
    do 
    { 
    *--p  = digits[val % radix]; 
    val    /= radix; 
    } 
    while(val); 
    if(value < 0 && radix == 10) 
    *--p  = '-'; 
    return strcpy(buffer, p); 
}

long long gettime ()
{
    long long t1, t2, t3, t4;
    GetThreadTimes (GetCurrentThread (), (LPFILETIME)&t1, (LPFILETIME)&t2, (LPFILETIME)&t3, (LPFILETIME)&t4);
    return t4;
}


int main ()
{
    long long t, t2;
    double d;
    double c = 0.f, o = 0.f;
    int it = 0;

    while (!kbhit ())
    {
        it++;
        t = gettime ();
        for (int i = 0; i < 2000000; i++)   // maak er 200000 van bij dynamische buffers
        {
            char buf[33];
            //char * buf = new char[33];
            itoa_curry (i + 10000000, buf, 10);
            //delete[] buf;
        }
        t2 = gettime ();
        d = (double)(t2 - t) / 10000000.f;
        c += d;
        std::cout << "itoa_curry: " << d << " (total: " << c << ", avg: " << (c / it) << ')' << std::endl;

        t = gettime ();
        for (int i = 0; i < 2000000; i++)
        {
            char buf[33];
            //char * buf = new char[33];
            itoa_oisyn (i + 10000000, buf, 10);
            //delete[] buf;
        }
        t2 = gettime ();
        d = (double)(t2 - t) / 10000000.f;
        o += d;
        std::cout << "itoa_oisyn: " << d << " (total: " << o << ", avg: " << (o / it) << ')' << std::endl;
    }
}

[curry684]

Static buffer op Alpha:

[14:41:43.27] Doing -2500000 to 2500000 for all versions...
[14:41:43.27] Curry's routine, base 10...
[14:41:52.37] Oisyn's routine, base 10...
[14:42:02.58] Curry's routine, base 2...
[14:42:21.83] Oisyn's routine, base 2...
[14:42:44.88] Curry's routine, base 16...
[14:42:50.41] Oisyn's routine, base 16...
[14:42:56.72] Done!

Zoals je ziet win ik structureel rond de 10%

Mijn gebugfixte code:

C:

char* itoa_curry (int value, char * buffer, int radix)  
{ 
static const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";  
char              temp[33]; 
char*             p = temp + 32; 
unsigned int      val = ((radix == 10 && value < 0) ? abs(value) : (unsigned int)value); 

*p = '\0'; 
do 
  { 
  *(--p)  = digits[val % radix]; 
  val    /= radix; 
  } 
while(val); 
if(value < 0 && radix == 10) 
  *(--p)  = '-'; 
return strcpy(buffer, p); 
}

[MisterData]

Hmm dit topic begint te lijken op de replaceString-wedstrijd die Alarmnummer en mbravenboer ook es deden... wie de snelste replace methode kon schrijven

[Eelis]

.

[ Voor 113% gewijzigd door Eelis op 19-02-2015 00:01 ]