[C++]Unire più file .exe

[^TiGeRShArK^]

Originariamente inviato da tomminno

Ti sfido ad usare Monodevelop e a paragonarlo anche solo minimamanete a VisualStudio (ma anche a SharpDevelop)

beh..
ho paura solo ad immaginare cosa sia dato che il BELLISSIMO visual studio nemmeno mi rinomina il nome delle classi in seguito ad una copia e mi sono accorto che aveva fatto un casino tremendo solo una volta che ho riaperto il file originale e non funzionava + una mazza dato che avevo fatto refactor -> rename a manetta..
meno male che c'è il santissimo SVN altrimenti sarebbe stata la volta buona che sarei partito dritto dritto per redmond...
Ma cazzarola..
Un editor completamente gratuito come eclipse fa 'sta cosa da tempo immemore..
possibile che nel 2008 ancora devo smazzarmi le cose a mano io?!?
ah.. ovviamente mi è capitato proprio in questo istante... per questo da quasto post traspare tutto il mio "amore" verso visual studio....

[Torav]

Originariamente inviato da gugoXX

Avevo intenzione di proporre un esercizio quasi accademico.
Un simulatore di sistema solare, con pianeti definiti da coordinate e massa.
Il simulatore dovrebbe preoccuparsi di calcolare le accellerazioni e di manutenere le velocita', tutto partendo dalla legge di Newton.
Poi sarebbe anche bello stampare a video il risultato passo-passo della simulazione, disegnando dove i pianeti (e il sole) vanno a posizionarsi man mano che il tempo passa.

Cosi' anche chi dice che non c'e' soluzione per il problema dei 3 pianeti sta zitto. Anche qui matematicamente si ha una soluzione, che non e' analitica, ma precisa a piacere.
Proprio come le tanto elogiate funzioni analitiche, che tanto hanno lo stesso problema.
sin(31) sara' tanto bella scritta cosi', ma per avere il valore numerico si devono fare gli sviluppi, con tanti passi quanti sono necessari per ottenere la precisione che si desidera. Esattamente come potrebbe essere la nostra simulazione...

Stasera provo.
Ho capito che in Python non ci sara' la parte grafica, fa lo stesso.
Al C# gliela aggiungero', magari in un bel Thread separato, per non bloccare la finestra come capita a tutti i niubbi...

io credo di non essere un gran programmatore (tutt'altro! ), però se vuoi il progammino l'ho fatto in python, perchè non avevo mai provato a fare un algoritmo di simulazione numerica non in c/c++ e volevo vedere quanto ci avrei messo . Devo dire che lo sviluppo è stato molto più rapido che in uno dei due suddetti linguaggi, anche se mi sembra decisamente più lento (come c'era da aspettarsi) nell'esecuzione. Se vuoi posso mandartelo via mail e puoi giudicare tu, ma onestamente credo che chiunque qua dentro saprebbe scriverlo meglio

[gugoXX]

Originariamente inviato da Torav

io credo di non essere un gran programmatore (tutt'altro! ), però se vuoi il progammino l'ho fatto in python, perchè non avevo mai provato a fare un algoritmo di simulazione numerica non in c/c++ e volevo vedere quanto ci avrei messo . Devo dire che lo sviluppo è stato molto più rapido che in uno dei due suddetti linguaggi, anche se mi sembra decisamente più lento (come c'era da aspettarsi) nell'esecuzione. Se vuoi posso mandartelo via mail e puoi giudicare tu, ma onestamente credo che chiunque qua dentro saprebbe scriverlo meglio

L'ho quasi finito anche io, la parte matematica e' fatta.
Mi sto solo arrabbiando un po' con la parte grafica. Non mi hanno messo la possibilita' di disegnare un semplice punto. Ma perche'?
Vabbe'. Sto per disegnare dei piccoli cerchi, e a sto punto li faccio tanto piu' grossi quanto piu' grande e' la loro massa.
Putroppo non ho un compilatore Python sotto mano. Ho scaricato IronPython e me lo guardero' con calma.
Sulla velocita' di sviluppo non lo metto in dubbio che sia piu' veloce del C.
Devo dire pero' che lo pensavo piu' accattivante. Invece a conti fatti non e' proprio tanto stravolto rispetto al C++.
Il codice della parte centrale, ovvero lo STEP di simulazione, e' venuto fuori cosi'

public List<Planet> PlanetList = new List<Planet>();

// Costruttore: vado a caricarmi un po' di pianeti da file XML.

// Un passo di simulazione.
public void Step()
{
    int plength = PlanetList.Count;
    foreach (Planet p in PlanetList) p.ResetAccell();
    // Per ciascuna coppia di pianeti calcolo l'interazione reciproca
    for(int t=0;t<plength;t++)
    {
        Planet p = PlanetList[t];
        for(int u=t+1;u<plength;u++)
        {
            Planet q = PlanetList[u];
            Interaction(p, q);
        }
    }
    // Applico l'accellerazione di ciascun pianeta.
    foreach(Planet p in PlanetList)
    {                
        p.vinst += p.accell;
        p.coords += p.vinst;
    }
}

public const double G = 1d;

//Interazione tra due pianeti. Calcolo dell'accellerazione su ciascuno dei 2
public void Interaction(Planet p1, Planet p2)
{
    double dist2 = PointD.Dist2(p1.coords, p2.coords);
    double dist = Math.Sqrt(dist2);          

    double F = G / dist2;
    PointD delta = (p1.coords - p2.coords) / dist;
    PointD deltaF = delta * F;

    p1.accell += deltaF*(-p2.m);
    p2.accell += deltaF*p1.m;            
}

Tutto ben scritto grazie all'overload degli operatori.
Ma non mi sembra molto diverso da come l'avrei scritto in C++

Il resto e' poco interessante, solo la definizione degli operatori di cui prima e la definizione della classe Planet (quasi una struttura in realta')
In Python come e' venuto scritto?

[cdimauro]

Originariamente inviato da gugoXX

E quindi non ci sono differenze, dato che lo si puo' fare anche in C#.

Scusami, mi son perso: cosa si potrebbe fare anche in C#?

L'unica differenza sarebbe quindi che in C# non posso riusare lo stesso nome di variabile? Non mi sembra un cosi' grande limite.

No, chiaro: non si muore mica.

Una differenza potrebbe essere che il tipo di una variabile viene fissata in C# al momento della creazione dell'istanza dell'oggetto, cosa che invece mi sembra di aver capito che in Python puo' anche avvenire dopo vero? (Come in javascript, p.es.)

Il tipo può cambiare in base all'oggetto referenziato, ma è sempre "fissato".

In JavaScript mi sembra che un variabile mai assegnata assuma il valore "unknown" (se ricordo bene) una volta referenziata. In Python ciò scatena un errore (prima di essere referenziata dev'essere sempre assegnata).

Chiaro. I problemi sono 2 pero'. Conoscere un linguaggio di programmazione e' una fatica non nulla. Lo farei se fossi sicuro di ottenere qualcosa in cambio.
Finora il x10 rispetto al C# non l'ho proprio visto. Ma neppure x2 o x1 ad essere sinceri.
C'e' un caso, un pattern, una situazione dove e' chiaramente piu' vantaggioso l'uso di Python?
Se qualcuno me lo chiedesse tra C++ e C# saprei tirare fuori decine di esempi.

Ti faccio qualche esempio, dividendo il discorso in due macroaree.

Ricca varietà di tipi di dati predefiniti (riporto i più importanti e "particolari"):
- interi (illimitati. Es: 1 << 256 = 115792089237316195423570985008687907853269984665640564039457584007913129639936L);
- stringhe (queste devi provarle: per la manipolazione delle stringhe Python è particolarmente comodo e versatile; esempietto al volo: s = ', '.join(['Qui', 'Quo', 'Qua']) produce s = 'Qui, Quo, Qua'), con supporto anche allo unicode (quindi posso avere stringhe che contentono sequenze di byte, oppure sequenze di caratteri unicode; la gestione è esattamente la stessa);
- tuple, cioé sequenza di oggetti immodificabile (per restituire più valori o s/impacchettarli; es: return 'Qui', 'Quo', 'Qua' in una funzione, oppure x, y, z = 'Qui', 'Quo', 'Qua' assegna x = 'Qui', y = 'Quo', y = 'Qua');
- liste; simili alle tuple, ma modificabili (es: x = [1, 2, 3]; y = [9, 8, 7, 6]; z = x + y assegna z = [1, 2, 3, 9, 8 ,7, 6]));
- dizionari, cioé array associativi / hash map / hash table (es: x = {'Qui' : 1, 'Quo' : 2, 'Qua' : 3}; x['Quo'] restituisce 2;
- set; simili alle liste, ma contengono valori unici e non ordinati, e inoltre supportano le operazioni su insiemi (unione, differenza simmetrica, intersezione, ecc.).
- decimali (valori in virgola fissa illimitati).

Ce ne sarebbero tanti altri, ma te li risparmio.

La seconda "macroarea" verte sul carattere dinamico di Python. In parte l'avrai notato dagli esempi precedenti, dove le liste o dizionari non hanno specificato il/i tipo/i su cui lavorano. In soldoni: possono contenere valori di qualunque tipo.

Esempio: L = [1, 'Qui', 3.14, {'Qui' : 1, 1 : 'Qui'}, set([1, 2, 3, 5, 7, 11])]

Da nessuna parte devi specificare il tipo dell'oggetto. Ad esempio quando definisci una funzione (o metodo):

def Somma(x, y):
return x + y

Non solo non definisci il tipo, ma più che una funzione hai appena definito un "comportamento", posto che x e y siano oggetti che supportano l'operazione di addizione (il primo o, in mancanza, il secondo oggetto).
Insomma, è un'operazione "generica" / "universale".

Un'utile conseguenza di ciò è che non hai bisogno di ricorrere alla definizione di un delegate quando devi "passare una funzione" a un'altra funzione.

def Apply(Function, x, y):
return Function(x, y)

print Apply(Somma, 1, 2)

Sulla "dinamicità" di Python ci sarebbe ancora parecchio da dire. Se ti ho stuzzicato l'appetito posso farti altri esempi (ci sarebbero argomenti molto più avanzati, come i "decoratori", ad esempio).

L'altro problema e' questo.

E ho tolto quelli a contratto, questi sono permanent.
A contratto in C# ce ne sono parecchi (e arrivano a 1000€ al giorno), mentre per Python non ne ho trovati.
Vorrei sottolineare la differenza sui matches, non sui salari, che sono effettivamente molto simili.

Questo solo per dire che oggi il mercato richiede di piu' il C#, e se devo proprio tirare la monetina per decidere cosa imparare, ho piu' speranze che mi possa servire per lavoro il C# piuttosto che il Python.
Questo oggi, domani magari sara' invece diverso.
Rendo merito anche che il Python si conosce di meno, quindi e' possibile che io riesca piu' facilmente a trovare lavoro se lo conosco bene. Non generalizzerei neppure qui.
Ma se fossi proprio digiuno di entrambi io personalmente sceglierei C#.

Nulla da dire su questo: il mercato al momento è così...

Ed e' la stessa cosa che dico io del C#.
Ma non vado a dire in giro che quindi e' 10 volte meglio di qualsiasi altro linguaggio, soprattutto di quelli che non conosco.
Magari 10 volte meglio del C, e parecchie volte meglio del C++, ma non generalizzerei.

10 volte è una sparata, dai: non è cosa di tutti giorni, perché può capitare qualche volta. Ma IMHO Python è più produttivo.

Originariamente inviato da fek

Ma non lasciamoli perdere proprio per nulla, perche' e' l'unica cosa che per me conta: due giorni di lavoro persi per un errore che doveva essere trovato a compile-time. Il resto e tutti gli altri esempi, davvero, sono chiacchiere perche' nell'applicazione sul campo in un progetto ampio Python per me ha fallito. Occhio che sono due anni che lavoro con un sistema totalmente scritto in Python e so che cosa vuole dire. E infatti usero' altri strumenti.

De gustibus: a me (che ci lavoro da 3 anni e mezzo a tempo pieno: qualcosa varrà pure come esperienza, spero ) e a tanti altri va benissimo con Python.
Ci sono aziende come Google che non hanno certo progettini da due soldi e per i quali viene utilizzato Python...

Abbiamo avuto esperienze diverse. Tutto qui.

Ho tirato in ballo cinquanta righe di codice che posso scrivere in mezz'ora per fare esattamente quello che dici tu! C# in console.

Mai negato questo Fran, ma io lo posso già fare da dubito, senza scrivere né cercare alcunché: in qualunque distribuzione di Python oltre alla V.M. (e la libreria standard) c'è sempre la shell a disposizione per smanettare.

Permettimi, come consigli ad altri di studiare meglio Python, dai un'occhiata meglio alle possibilita' offerte da .NET prima di fare certe affermazioni.

Ma mica ho negato che per C# (su .NET, poi, gira IronPython! ) sono disponibili tanti utili e comodi strumenti.

Però quando ti dico che esistono IDE e strumenti per Python che permettono di individuare velocemente l'errore in cui sei incappato non vuoi sentire ragioni... :|

[Torav]

oddio...devo dire che dato che l'ho preso come esercizio per l'università io ho usato l'algoritmo di runge kutta (al quart'ordine) e il formalismo hamiltoniano (quindi ho 2 coordinate e 2 momenti, il tutto fatto con coordinate angolari perchè è un problema quasi centrale e mi sembrava meglio) quindi mi sa che è venuto decisamente più illeggibile

[Torav]

beh tanto per far vedere del codice:
ho la classe pianeta che anche nel mio caso è praticamente una struttura:

class pianetaClass:
    def __init__(self, nome, massa, r, theta, pr, ptheta):
        self.nome = nome
        self.massa = massa
        self.coord = dict([('r',r), ('theta',theta)])
        self.mom = dict([('r',pr), ('theta',ptheta)])


    def __str__(self):
        return self.nome + ": massa = " + str(self.massa) + ", posizione = (" + str(self.coord['r']) + ", " + str(self.coord['theta']) + "), momenti = (" + str(self.mom['r']) + ", " + str(self.mom['theta']) + ")"


    # Ritorna un pianeta con coordinate e momenti uguali a quelli di self + gli argomenti
    def aggiungiCost(self, r, theta, PR, PTheta):
        return pianetaClass(self.nome, self.massa, self.coord['r'] + r, self.coord['theta'] + theta, self.mom['r'] + PR, self.mom['theta'] + PTheta)


    # Ritorna la distanza (al quadrato) tra self e il pianeta in argomento
    def distanzaQ(self, pianeta):
        dist = self.coord['r']**2 + pianeta.coord['r']**2 - self.coord['r']  * pianeta.coord['r'] * math.cos(self.coord['theta'] - pianeta.coord['theta'])

        return math.sqrt(dist)

e la classe sistema solare che controlla tutto "l'ambiente":

class sistemaSolareClass:
    def __init__(self, pianeti):
        self.pianeti = pianeti


    def __str__(self):
        toPrint = "Attuali posizioni e momenti dei pianeti all'interno del sistema solare:\n"
        for pianeta in self.pianeti:
            toPrint += str(pianeta) + "\n"

        return toPrint


    def evolvi(self, tempo, salvaOgni=1000):
        # questo metodo prende un centinaio di righe di codice piuttosto noiosette
        # che sono semplicemente l'implementazione dell'algoritmo di runge kutta

 
    def rPunto(self, pianeta):
        return (pianeta.mom['r'] / pianeta.massa)


    def thetaPunto(self, pianeta):
        return pianeta.mom['theta'] / (pianeta.massa * pianeta.coord['r']**2)
    

    def PRPunto(self, pianeta, altriPianeti):
        valore = - G*M * pianeta.massa / (pianeta.coord['r']**2) + pianeta.mom['theta']**2 / (pianeta.massa * pianeta.coord['r']**3)

        for altroP in altriPianeti:
            valore -= (1./2.) * G * altroP.massa * pianeta.massa / (pianeta.distanzaQ(altroP)**(3./2.)) * (2.*pianeta.coord['r'] - altroP.coord['r'] * math.cos(pianeta.coord['theta'] - altroP.coord['theta']))

        return valore


    def PThetaPunto(self, pianeta, altriPianeti):
        valore = 0
        for altroP in altriPianeti:
            valore -= (1./2.) * G * pianeta.massa * altroP.massa / (pianeta.distanzaQ(altroP)**(3./2.)) * pianeta.coord['r'] * altroP.coord['r'] * math.sin(pianeta.coord['theta'] - altroP.coord['theta'])

        return valore

all'inizio ovviamente ho definitio un paio di variabili contenente G, la massa del "sole" (che considero fisso, più che altro per comodità, non ci vorrebbe nulla a piazzarlo al centro con una massa molto grande ) e l'intervallo di tempo DT.
per inciso nel metodo che calcola runge kutta ho anche messo la scrittura su file dei risultati (in output ci sono solo x = r cos(theta) e y=r sin(theta) per poter essere visualizzati meglio, io uso gnuplot e vengono tante belle quasi-ellissi ).
il programma "esterno" si riduce ad un qualcosa del genere:

a = pianetaClass("Terra", 1, 1, 0.4, 0.1, 0.5)
b = pianetaClass("Mercurio", 0.3 0.4, 2, 0.03, 0.02)

mySis = sistemaSolareClass((a, b))

mySis.evolvi(10, 100000)

mi scuso per l'orrido uso degli oggetti, ma nella mia facoltà non ci sono esami di ingegneria del software e da solo non riesco proprio a tirare fuori qualcosa di meglio

[fek]

Originariamente inviato da cdimauro

De gustibus: a me (che ci lavoro da 3 anni e mezzo a tempo pieno: qualcosa varrà pure come esperienza, spero ) e a tanti altri va benissimo con Python.

Urca due giorni di lavoro persi per un difetto del linguaggio non e' una questione di gusti.

Mai negato questo Fran, ma io lo posso già fare da dubito, senza scrivere né cercare alcunché: in qualunque distribuzione di Python oltre alla V.M. (e la libreria standard) c'è sempre la shell a disposizione per smanettare.

Anch'io posso farlo subito, mi scarico la shell per C# come tu ti scarichi la shell di Python.

Però quando ti dico che esistono IDE e strumenti per Python che permettono di individuare velocemente l'errore in cui sei incappato non vuoi sentire ragioni... :|

Perche' un IDE non e' la soluzione ad un difetto di progettazione del linguaggio, come i commenti non sono una soluzione al codice scritto coi piedi

Si riscrive il codice. E si usa un linguaggio migliore.

[cdimauro]

Originariamente inviato da fek

Urca due giorni di lavoro persi per un difetto del linguaggio non e' una questione di gusti.

Ma lo posso dire che a me piace così?

Anch'io posso farlo subito, mi scarico la shell per C# come tu ti scarichi la shell di Python.

Ehm... c'è già con Python: non devo scaricare niente.

Perche' un IDE non e' la soluzione ad un difetto di progettazione del linguaggio, come i commenti non sono una soluzione al codice scritto coi piedi

Si riscrive il codice. E si usa un linguaggio migliore.

OK, OK: cedo alla violenza.

[gugoXX]

Originariamente inviato da Torav

oddio...devo dire che dato che l'ho preso come esercizio per l'università io ho usato l'algoritmo di runge kutta (al quart'ordine) e il formalismo hamiltoniano (quindi ho 2 coordinate e 2 momenti, il tutto fatto con coordinate angolari perchè è un problema quasi centrale e mi sembrava meglio) quindi mi sa che è venuto decisamente più illeggibile

Olamadd... hai fatto un Runge Kutta in una sera?
Stocks!!!
100 righe nascoste pure.

Comunque hai praticamente scritto la formula di evoluzione secondo newton qui

valore -= (1./2.) * G * pianeta.massa * altroP.massa / (pianeta.distanzaQ(altroP)**(3./2.)) * pianeta.coord['r'] * altroP.coord['r'] * math.sin(pianeta.coord['theta'] - altroP.coord['theta'])

(Fra l'altro sin e cos li puoi calcolare direttamente date le coordinate, e ci guadagni qualcosina sia in codice che in velocita')

A cosa ti e' servito Runge Kutta?

[morskott]

Originariamente inviato da Torav

beh tanto per far vedere del codice:
ho la classe pianeta che anche nel mio caso è praticamente una struttura:

class pianetaClass:
    def __init__(self, nome, massa, r, theta, pr, ptheta):
        self.nome = nome
        self.massa = massa
        self.coord = dict([('r',r), ('theta',theta)])
        self.mom = dict([('r',pr), ('theta',ptheta)])


    def __str__(self):
        return self.nome + ": massa = " + str(self.massa) + ", posizione = (" + str(self.coord['r']) + ", " + str(self.coord['theta']) + "), momenti = (" + str(self.mom['r']) + ", " + str(self.mom['theta']) + ")"


    # Ritorna un pianeta con coordinate e momenti uguali a quelli di self + gli argomenti
    def aggiungiCost(self, r, theta, PR, PTheta):
        return pianetaClass(self.nome, self.massa, self.coord['r'] + r, self.coord['theta'] + theta, self.mom['r'] + PR, self.mom['theta'] + PTheta)


    # Ritorna la distanza (al quadrato) tra self e il pianeta in argomento
    def distanzaQ(self, pianeta):
        dist = self.coord['r']**2 + pianeta.coord['r']**2 - self.coord['r']  * pianeta.coord['r'] * math.cos(self.coord['theta'] - pianeta.coord['theta'])

        return math.sqrt(dist)

e la classe sistema solare che controlla tutto "l'ambiente":

class sistemaSolareClass:
    def __init__(self, pianeti):
        self.pianeti = pianeti


    def __str__(self):
        toPrint = "Attuali posizioni e momenti dei pianeti all'interno del sistema solare:\n"
        for pianeta in self.pianeti:
            toPrint += str(pianeta) + "\n"

        return toPrint


    def evolvi(self, tempo, salvaOgni=1000):
        # questo metodo prende un centinaio di righe di codice piuttosto noiosette
        # che sono semplicemente l'implementazione dell'algoritmo di runge kutta

 
    def rPunto(self, pianeta):
        return (pianeta.mom['r'] / pianeta.massa)


    def thetaPunto(self, pianeta):
        return pianeta.mom['theta'] / (pianeta.massa * pianeta.coord['r']**2)
    

    def PRPunto(self, pianeta, altriPianeti):
        valore = - G*M * pianeta.massa / (pianeta.coord['r']**2) + pianeta.mom['theta']**2 / (pianeta.massa * pianeta.coord['r']**3)

        for altroP in altriPianeti:
            valore -= (1./2.) * G * altroP.massa * pianeta.massa / (pianeta.distanzaQ(altroP)**(3./2.)) * (2.*pianeta.coord['r'] - altroP.coord['r'] * math.cos(pianeta.coord['theta'] - altroP.coord['theta']))

        return valore


    def PThetaPunto(self, pianeta, altriPianeti):
        valore = 0
        for altroP in altriPianeti:
            valore -= (1./2.) * G * pianeta.massa * altroP.massa / (pianeta.distanzaQ(altroP)**(3./2.)) * pianeta.coord['r'] * altroP.coord['r'] * math.sin(pianeta.coord['theta'] - altroP.coord['theta'])

        return valore

all'inizio ovviamente ho definitio un paio di variabili contenente G, la massa del "sole" (che considero fisso, più che altro per comodità, non ci vorrebbe nulla a piazzarlo al centro con una massa molto grande ) e l'intervallo di tempo DT.
per inciso nel metodo che calcola runge kutta ho anche messo la scrittura su file dei risultati (in output ci sono solo x = r cos(theta) e y=r sin(theta) per poter essere visualizzati meglio, io uso gnuplot e vengono tante belle quasi-ellissi ).
il programma "esterno" si riduce ad un qualcosa del genere:

a = pianetaClass("Terra", 1, 1, 0.4, 0.1, 0.5)
b = pianetaClass("Mercurio", 0.3 0.4, 2, 0.03, 0.02)

mySis = sistemaSolareClass((a, b))

mySis.evolvi(10, 100000)

mi scuso per l'orrido uso degli oggetti, ma nella mia facoltà non ci sono esami di ingegneria del software e da solo non riesco proprio a tirare fuori qualcosa di meglio

Come si è passati dall'unire due file exe a dissertazioni astrofisiche sul sistema solare devo ancora capirlo....... Passando dal solito (flame? (almeno è garbato)) Python VS resto del mondo

[gugoXX]

Originariamente inviato da cdimauro

Ricca varietà di tipi di dati predefiniti (riporto i più importanti e "particolari"):
- interi (illimitati. Es: 1 << 256 = 115792089237316195423570985008687907853269984665640564039457584007913129639936L);
- stringhe (queste devi provarle: per la manipolazione delle stringhe Python è particolarmente comodo e versatile; esempietto al volo: s = ', '.join(['Qui', 'Quo', 'Qua']) produce s = 'Qui, Quo, Qua'), con supporto anche allo unicode (quindi posso avere stringhe che contentono sequenze di byte, oppure sequenze di caratteri unicode; la gestione è esattamente la stessa);
- tuple, cioé sequenza di oggetti immodificabile (per restituire più valori o s/impacchettarli; es: return 'Qui', 'Quo', 'Qua' in una funzione, oppure x, y, z = 'Qui', 'Quo', 'Qua' assegna x = 'Qui', y = 'Quo', y = 'Qua');
- liste; simili alle tuple, ma modificabili (es: x = [1, 2, 3]; y = [9, 8, 7, 6]; z = x + y assegna z = [1, 2, 3, 9, 8 ,7, 6]));
- dizionari, cioé array associativi / hash map / hash table (es: x = {'Qui' : 1, 'Quo' : 2, 'Qua' : 3}; x['Quo'] restituisce 2;
- set; simili alle liste, ma contengono valori unici e non ordinati, e inoltre supportano le operazioni su insiemi (unione, differenza simmetrica, intersezione, ecc.).
- decimali (valori in virgola fissa illimitati).

Per intanto ti ringrazio.
Mi sa che non sono mica tanto diversi alla fine allora.
Guarda qui:

var sorgente = new string[] { "bimbo", "Brutto", "Cattivo", "ﺹﻀﻏﻖﺦﺬﺡﺴ" };
var pippolone=string.Join(",", sorgente );

var Tupla=new{ Nome = "Pippo", age = 15 };
string PippoName=Tupla.Nome;
int PippoAge=Tupla.age;

int[] int1=new[]{1,2,3,4};
var int2=new[]{5,6,7,7};
var insieme=int1.Union(int2);

Poi mi sono divertito con l'insieme:

            var quanti = insieme.Count();
            var qualigrossi = insieme.Where( u => u>3);
            int quantigrossi = qualigrossi.Count();
            var alcontrario = insieme.Reverse();
            var piuuno = insieme.Select( u=>u+1 );
            var diversi = insieme.Distinct();
            bool celo = insieme.Contains(2);
            var manca = !insieme.Contains(9);
            int sommone = insieme.Sum();
            var soloiprimi5 = insieme.Take(5);
            int dammiquesto = int1.Single(y => (y > 4) && (y < 6));

            var comuni = int1.Intersect(int2);
            var subtract=int1.Where(t => !int2.Contains(t));

Poi ho visto che tu hai citato le operazioni su insieme, e io ho trovato in libreria la Intersect e la Union, ma non la Subtract (che li' sopra ho fatto con quella Where)
A questo punto, aggiungendo una funzione alla classe generica "array di interi" (penso che sia un concetto simile alla decorazione di cui accennavi)
ho potuto scrivere anche

var oracelho=int1.MenoSoloPerInt(int2);

Poi, visto che mi rompeva alquanto avere sto metodo solo per gli "Array di interi", allora l'ho esteso a quasiasi tipo di array. Il codice dei 2 estensori e' bruttino, ma lo metto qui per libreria.

public static int[] MenoSoloPerInt(this int[] daquesti, int[] togliquesti)
{
    return daquesti.Where(t => !togliquesti.Contains(t)).ToArray();
}

public static IEnumerable<T> Meno<T>(this IEnumerable<T> daquesti, IEnumerable<T> togliquesti)
{
    return daquesti.Where(t => !togliquesti.Contains(t));
}

Sul fatto di passare "funzioni" ad altre funzioni, anche senza delegate, lo puoi vedere dal codice divertimento che ho scritto sopra. In C# si chiamano lambda function.

I dictionary ci sono, per implementare le Hashtable tipizzate.
Ci sono anche i SortedDictionary per resituire velocemente le chiavi ordinate (quando servono), le LookUp che sono Dictionary con solo le chiavi, e altre.

Conti fatti restano fuori gli interi lunghi e i virgola fissa lunghi (e magari altri che non hai citato) pero' ammetti che non si usano poi cosi' spesso. E soprattutto non fanno uso del coprocessore (molto probabilmente) quindi non saranno neppure molto performanti. Spero che gli interi normali si differenzino da questi.

Pero' potrei mettere sul tavolo ancora una trentina (non esagero) di funzioni come le Where, Union, etc. di cui sopra, gia' in libreria e pronti all'uso, da applicare su oggetti enumerabili come le liste, etc.
Se poi ci si mette si puo' scrivere anche qualcosa di molto carino, che sembra quasi SQL.

Finisco dicendo che l'uso della keyword var lo limiterei proprio solo dove non se ne puo' fare a meno,
ovvero dopo le creazioni al volo di oggetti di una classe senza nome (Come la Tupla di prima),
oppure a seguito della restituzione di oggetti "anonimi" da funzioni che usano i generici.
In pratica io sopra avrei esplicitato quasi tutte le dichiarazioni, ma solo perche' in seguito mi piace leggere le cose in quel modo. Il risultato sarebbe stato lo stesso.

[Torav]

Originariamente inviato da gugoXX

Olamadd... hai fatto un Runge Kutta in una sera?
Stocks!!!
100 righe nascoste pure.

Comunque hai praticamente scritto la formula di evoluzione secondo newton qui


(Fra l'altro sin e cos li puoi calcolare direttamente date le coordinate, e ci guadagni qualcosina sia in codice che in velocita')

A cosa ti e' servito Runge Kutta?

beh, con runge kutta al quarto ordine hai errori del quinto ordine, con il metodo di eulero (mi pare che usi quelli?) che usi tu invece non si conserva neanche l'energia
e te l'ho detto, ho usato la tua idea come banco di prova per provare a sviluppare un programmino di calcolo numerico in python (cosa che non avevo mai fatto) e per riprendere la mano con runge kutta che mi tocca utilizzare in un corso che sto facendo ora

[gugoXX]

Originariamente inviato da Torav

beh, con runge kutta al quarto ordine hai errori del quinto ordine, con il metodo di eulero (mi pare che usi quelli?) che usi tu invece non si conserva neanche l'energia
e te l'ho detto, ho usato la tua idea come banco di prova per provare a sviluppare un programmino di calcolo numerico in python (cosa che non avevo mai fatto) e per riprendere la mano con runge kutta che mi tocca utilizzare in un corso che sto facendo ora

Guarda, non so se si chiama di Eulero oppure no.
Semplicemente ad ogni passo calcolo l'interazione fra ciascuna coppia di pianeti (accellerazioni), aggiorno le velocita' di ciascuno, aggiorno di conseguenza le coordinate e ricomincio.
Perche' non si conserverebbe l'energia?
L'unica cosa che non considero e' la collisione (al posto di schiantarsi e inglobarsi si trapassano, e questo non e' ovviamente reale).

[Torav]

Originariamente inviato da gugoXX

Guarda, non so se si chiama di Eulero oppure no.
Semplicemente ad ogni passo calcolo l'interazione fra ciascuna coppia di pianeti (accellerazioni), aggiorno le velocita' di ciascuno, aggiorno di conseguenza le coordinate e ricomincio.
Perche' non si conserverebbe l'energia?
L'unica cosa che non considero e' la collisione (al posto di schiantarsi e inglobarsi si trapassano, e questo non e' ovviamente reale).

guarda è assai possibile che mi sbaglio, il primo esame di analisi numerica in cui facevo questi metodi l'ho dato un paio di anni fa e non ricordo bene, in pratica il problema del tuo algoritmo (che però fa il suo più che onesto dovere eh!) è che è del primo ordine e quindi ha un errore che va come n*dt^2 dove n è il numero di passi e dt l'ampiezza dell'intervallo temporale. Mi ricordo che a laboratorio avevamo graficato l'energia e in effetti veniva una roba un po' oscillante ! cmq penso che per la precisione che serve a noi un algoritmo vale l'altro! solo che ho usato questo problema come esercizio e ho colto la palla al balzo

[gugoXX]

Originariamente inviato da Torav

guarda è assai possibile che mi sbaglio, il primo esame di analisi numerica in cui facevo questi metodi l'ho dato un paio di anni fa e non ricordo bene, in pratica il problema del tuo algoritmo (che però fa il suo più che onesto dovere eh!) è che è del primo ordine e quindi ha un errore che va come n*dt^2 dove n è il numero di passi e dt l'ampiezza dell'intervallo temporale. Mi ricordo che a laboratorio avevamo graficato l'energia e in effetti veniva una roba un po' oscillante ! cmq penso che per la precisione che serve a noi un algoritmo vale l'altro! solo che ho usato questo problema come esercizio e ho colto la palla al balzo

Mi fido. E' ovvio che si tratti di un'approssimazione, ma pensavo che riducendo a piacere il DeltaT potessi raggiungere una precisione a piacere.
Ma a questo punto mi sa che non e' cosi'.

Ho finito la parte grafica. E' davvero carino. Velocissimo peraltro, non pensavo.
Ci ho messo anche un attrito, senno' era noioso. Non succedeva nulla e i pianeti andavano avanti forse per sempre.
Ora sto facendo girare un po' di pianeti in senso orario e un po' in senso antiorario. Funzionano pure i satelliti!!!
Ma il sole non doveva stare sempre in uno dei 2 fuochi dell'ellisse? Non era una delle leggi di Keplero? Ad occhio mi sembra che ci siano casi che non sembrano proprio rispettarla... boh?

[Torav]

bello! domani faccio anche io la gui va...carina l'idea dell'attrito

[fek]

Originariamente inviato da cdimauro

Ehm... c'è già con Python: non devo scaricare niente.

Python, l'unico linguaggio che funziona senza neppure scaricare l'interprete... solo su... Rieducational Channel

[DioBrando]

Originariamente inviato da tomminno

Ti sfido ad usare Monodevelop e a paragonarlo anche solo minimamanete a VisualStudio (ma anche a SharpDevelop)

Se è per questo possiamo sostituire la stragrande maggioranza degli IDE al posto di Monodevelop e SharpDevelop e otterremo lo stesso risultato ovvero che non sono paragonabili.

Quei pochi che reggono il confronto sono sulle dita di una mano e in ogni caso non offrono la stessa varietà e produttività in termini di strumenti: lo stesso Eclipse, è sì ricco di plugin ma se si sviluppa in Java è un discorso, passando ai linguaggi C-like un altro (senza menzionare nemmeno il confronto tra Matisse e il tool integrato in Eclipse).

Per quanto riguarda Mono sono rimasto piuttosto di sale anche io eppure sì è utilizzato anche i progetti grossi; al di là dei nomi che ha fatto fek ci sono Beagle, F-Spot, Zenworks Linux Management, lo stesso Moonlight (porting di Silverlight per Linux) ne è un suo "frutto".


x cionci:
scusa ma abbiamo capito che Python non lo digerisci, più o meno ad ogni menzione di questa parola scrivi un messaggio in cui si capisce piuttosto bene il tuo pensiero, tanto quanto Cesare invece lo loda.
Basterà no?
Posso capire che il suo atteggiamento sia un po' "oltranzista" (anche se poi tutto sommato ci si ride in tanti su ), magari è un lato del suo carattere, ma d'altra parte se lo consiglia è perchè evidentemente nella sua esperienza ha tratto dei benefici in termini di produttività rispetto alle tecnologie utilizzate prima (magari usando C# avrebbe avuto lo stesso impatto...magari anche no perchè mi pare almeno fino a un po' di tempo fa lavorasse su piattaforme Linux).
Fek ha avuto un'esperienza completamente opposta, però ci hanno lavorato entrambe seppur con profitto differente e dal mio punto di vista hanno senz'altro più titolo per parlarne con cognizione di causa.
E al di là del profilo tenuto, le critiche penso siano più solide di chi le fa sulla base delle caratteristiche del linguaggio ma senza (correggimi se sbaglio) averlo mai utilizzato nella sua esperienza lavorativa.
D'altra parte il tuo non sapere che Python rientri nella famiglia NET, mi pare sia piuttosto indicativo, come tempo fa' non sapevi fosse disponibile il plugin per Eclipse.

[cdimauro]

Originariamente inviato da morskott

Come si è passati dall'unire due file exe a dissertazioni astrofisiche sul sistema solare devo ancora capirlo....... Passando dal solito (flame? (almeno è garbato)) Python VS resto del mondo

Don't underestimate the power of flame...

Originariamente inviato da gugoXX

Per intanto ti ringrazio.
Mi sa che non sono mica tanto diversi alla fine allora.
Guarda qui:

var sorgente = new string[] { "bimbo", "Brutto", "Cattivo", "ﺹﻀﻏﻖﺦﺬﺡﺴ" };
var pippolone=string.Join(",", sorgente );

var Tupla=new{ Nome = "Pippo", age = 15 };
string PippoName=Tupla.Nome;
int PippoAge=Tupla.age;

int[] int1=new[]{1,2,3,4};
var int2=new[]{5,6,7,7};
var insieme=int1.Union(int2);

Poi mi sono divertito con l'insieme:

            var quanti = insieme.Count();
            var qualigrossi = insieme.Where( u => u>3);
            int quantigrossi = qualigrossi.Count();
            var alcontrario = insieme.Reverse();
            var piuuno = insieme.Select( u=>u+1 );
            var diversi = insieme.Distinct();
            bool celo = insieme.Contains(2);
            var manca = !insieme.Contains(9);
            int sommone = insieme.Sum();
            var soloiprimi5 = insieme.Take(5);
            int dammiquesto = int1.Single(y => (y > 4) && (y < 6));

            var comuni = int1.Intersect(int2);
            var subtract=int1.Where(t => !int2.Contains(t));

Poi ho visto che tu hai citato le operazioni su insieme, e io ho trovato in libreria la Intersect e la Union, ma non la Subtract (che li' sopra ho fatto con quella Where)
A questo punto, aggiungendo una funzione alla classe generica "array di interi" (penso che sia un concetto simile alla decorazione di cui accennavi)
ho potuto scrivere anche

var oracelho=int1.MenoSoloPerInt(int2);

Poi, visto che mi rompeva alquanto avere sto metodo solo per gli "Array di interi", allora l'ho esteso a quasiasi tipo di array. Il codice dei 2 estensori e' bruttino, ma lo metto qui per libreria.

public static int[] MenoSoloPerInt(this int[] daquesti, int[] togliquesti)
{
    return daquesti.Where(t => !togliquesti.Contains(t)).ToArray();
}

public static IEnumerable<T> Meno<T>(this IEnumerable<T> daquesti, IEnumerable<T> togliquesti)
{
    return daquesti.Where(t => !togliquesti.Contains(t));
}

Che si possano fare più o meno le stesse cose non ci sono dubbi, ma t'invito a riflette sul COME queste cose vengano fatte, che mi sembra alquanto diverso (specialmente con le ultime parti in cui hai usato IEnumerable; a proposito: le "decorazioni" in Python servono ad altro; hanno a che fare con la composizione di funzioni ).

Sul fatto di passare "funzioni" ad altre funzioni, anche senza delegate, lo puoi vedere dal codice divertimento che ho scritto sopra. In C# si chiamano lambda function.

Le lambda function ci sono anche in Python:

Somma = (lambda x, y: x + y)(1, 2)



Ma Python, come dicevo, non richiede che tu definisca un "delegate" per indicare che il parametro di una funzione è... una funzione: passi direttamente o il nome della funzione (se esiste una funzione) oppure ne crei al volo una con l'istruzione lambda.

I dictionary ci sono, per implementare le Hashtable tipizzate.
Ci sono anche i SortedDictionary per resituire velocemente le chiavi ordinate (quando servono), le LookUp che sono Dictionary con solo le chiavi, e altre.

OK, ma vedi sopra: vogliamo vedere in che modo si utilizzano? Oggetti come questi ormai li mettono a disposizione quasi tutti i linguaggi di programmazione, ma dubito che tu possa fare qualcosa di più semplice di:

Map = {'Qui' : 1, 'Quo' : 2, 'Qua' : 3}

in C#.

Conti fatti restano fuori gli interi lunghi e i virgola fissa lunghi (e magari altri che non hai citato) pero' ammetti che non si usano poi cosi' spesso. E soprattutto non fanno uso del coprocessore (molto probabilmente) quindi non saranno neppure molto performanti. Spero che gli interi normali si differenzino da questi.

No, anzi con Python 3.0 ci sarà un solo tipo di interi, quello a precisione illimitata (adesso se un intero "sfora", l'oggetto viene fatto diventare un long integer, per l'appunto, come puoi vedere dall'esempio che t'avevo fatto: 1 << 256).

E' chiaro che le prestazioni non posso essere paragonabili a quelle di C#, ma tieni presente che Python attualmente non usa nessuna forma di compilazione JIT: l'interprete esegue i byte code uno alla volta. Esistono poi progetti come Psyco http://psyco.sourceforge.net/ che permettono di ottenere delle buone prestazioni.

Comunque Python non è nato per essere veloce, ma semplice: non ti devi preoccupare di quale tipo di intero da usare fra gli 8 (se non ricordo male) che un linguaggio come C# ti mette a disposizione (più eventuali altre classe per gestire "BigInt").

Pero' potrei mettere sul tavolo ancora una trentina (non esagero) di funzioni come le Where, Union, etc. di cui sopra, gia' in libreria e pronti all'uso, da applicare su oggetti enumerabili come le liste, etc.
Se poi ci si mette si puo' scrivere anche qualcosa di molto carino, che sembra quasi SQL.

Non lo metto in dubbio, ma potrei portarti anche gli iteratori e le funzioni di iterazione (nel modulo standard itertools) che permettono di ottenere risultati simili, ma non ne usciamo più: ogni linguaggio ha i suoi oggetti, e altri se ne possono usare da librerie esterne, ma... rimane la (diversa) espressività con cui riesci a rappresentare la soluzione al tuo problema.

Finisco dicendo che l'uso della keyword var lo limiterei proprio solo dove non se ne puo' fare a meno,
ovvero dopo le creazioni al volo di oggetti di una classe senza nome (Come la Tupla di prima),
oppure a seguito della restituzione di oggetti "anonimi" da funzioni che usano i generici.
In pratica io sopra avrei esplicitato quasi tutte le dichiarazioni, ma solo perche' in seguito mi piace leggere le cose in quel modo. Il risultato sarebbe stato lo stesso.

Chiaro. Con Python, proprio perché è un linguaggio dinamico, non te ne devi preoccupare. Ad esempio, non hai bisogno dei generic perché le tuple, le liste, i dizionari, ecc. ecc. accettano oggetti di qualunque tipo.

Comunque stare a fare confronti "sulla carta" lascia il tempo che trova: potrei stare qui per ore a raccontarti come si fa qualcosa in Python, e tu a rispondermi come la faresti in C#, ma non risolveremmo nulla.

Dopo che avrai approfondito il tuo studio di C#, quando avrai tempo ti consiglio di smanettare con Python: è il modo migliore per poterti fare un'idea sul linguaggio, i suoi pregi e i suoi difetti.

Originariamente inviato da fek

Python, l'unico linguaggio che funziona senza neppure scaricare l'interprete... solo su... Rieducational Channel

print "Permettimi, come consigli ad altri di studiare meglio Python, dai un'occhiata meglio alle possibilita' offerte da .NET prima di fare certe affermazioni.".replace('Python', 'C#').replace('.NET', 'Python')

Python è costituito da 3 elementi fondamentali: la virtual machine, il "compilatore" (lo metto tra virgolette e ti spiego dopo il perché) e la libreria standard. Senza di queste non vai da nessuna parte: non puoi lavorare in Python.

Il "compilatore" è un eseguibile (python.exe per Windows), ma non ha soltano questa funzionalità perché può:
- compilare (e basta) un sorgente (specificando l'opzione che forza la sola compilazione);
- compilare (se il sorgente è cambiato dall'ultima esecuzione) ed eseguire l'applicazione;
- eseguire i comandi in maniera interattiva.

Ecco perché ti dico che con Python la shell (interattiva) è già inclusa, mentre con linguaggi come C# (o Java, che ha javac.exe per compilare e java.exe per eseguire l'applicazione) devi andare a cercare soluzioni di terze parti.

Poi è chiaro che "fuori" c'è di meglio: ci sono IDE molto più avanzati, ma anche shell interattive decisamente migliori.

[cionci]

Originariamente inviato da DioBrando

x cionci:
scusa ma abbiamo capito che Python non lo digerisci, più o meno ad ogni menzione di questa parola scrivi un messaggio in cui si capisce piuttosto bene il tuo pensiero, tanto quanto Cesare invece lo loda.

Ti spiego, questo perché l'unico che posta quando qualcuno chiede "con quale linguaggio posso fare questo" è sempre e solo Cesare e la risposta è sempre e solo Python. Una situazione del genere mi sembra più vicina al tentativo di indottrinamento che al consiglio sulla base delle effettive qualità del linguaggio e le necessità del richiedente. E' per questo che questa volta mi sono permesso non solo di consigliare una strada alternativa, ma anche di giustificarla. Spesso non lo faccio (e lascio che non ci siano contraddittori), ma questa volta mi è sembrato giusto, visto che la situazione lo richiedeva.
Obiettivamente, visti gli scopi di chi ha creato il thread, cioè creare un programma di monitoraggio e rilevamento della caratteristiche hardware, avresti consigliato Python ? Questo un giorno potrebbe avere la necessità di scrivere un driver...e gli si consiglia Python ?