/sci/ - Science & Math

grats dude i'm happy that you killed another thread just to share this with us

>>9625796
thanks for bumping it and killing another, fucking moron.

>>9625791
>doesn't even look at variable explorer

Your fault.

>>9625791
Nice. That's the kind of language design I can get behind.

>>9625808
I was forced to use this garbage for implementing an SVM classifier.

>>9625802
actually i saged
so no, i didn't

>>9625796
>>9625802
>flatearth & iq-whining
good riddance

>>9625791
>using matlab to compare strings.

>>9625791
Why the fuck would you write a C-type program in Matlab

>OP didn't test the logic as they went
you shat out code and expected it to just work the first time?

>>9625791
I don't know man, learning the basic quirks of the core data structures of your programming language seems like a pretty low bar of knowledge required before you start programming in said language.

Why you would start a project before even studying how the main data structures work is beyond me.

>people are actually defending this shit.

Had to stay awake through multiple caffeine pills and piracetams to finish this project on time because this software sucks fucking donkey dick. Fuck off.

>>9625948
>blaming a program for your own ignorance

yeah you really deserve that C

>>9625948
A bad craftsman blames his tools.

A dogshit craftsman blames his tools without realising he is a tool.

>>9625791
Unless you're writing in an assembly language, you're not actually programming.

your debugging skills suck, your problem.

>>9625824
This. OP deserves to suffer

>>9625948
if you'd managed your time better you wouldn't have to take drugs to finish it

fuck off brainlet

>>9625791
>proprietary programming language

>>9626318
huh?

>>9625791
Matlab strings are the worst thing I have ever experienced in Programming, ever single person responsible for that disaster has to be removed from the face of this earth.

Aside from that the language is pretty great though, I like a lot of its features and to be fair, it *probably* wasn't the ideal choice for what you were trying to accomplish.

It had it's time. Choose python if you can.

>>9627850
Disregard that, I suck cocks.

>>9627777
>Using strings in MATLAB ever

You asked for problems

>>9628063
Yes, at least that is something I learned during that experience.

>>9626318
who are you quoting

>>9627850
This. Python is the future. SciPy and the scikit modules are already superior to any commercial software.

The only exception is that Mathematica is superior to SymPy, but you can get one of these for free and more importantly you can modify the source code when you need to.

>>9625824
>>9626075
>what are command-line arguments

>>9628312
>Doing input in matlab instead of just changing the script

You deserve hell

>>9625791
>has to use 35 helper functions to take an array of strings to break it into an array of characters to edit a character and then back into an array of strings

this thing sucks so much ass, just trying to import data from directories takes 100 line script from their forums when in python its a one line import statement using glob.

Python is leagues better or even mathematica if you are lucky to have your school give you a license

>>9625791
>it's another episode of RTFM
found the shitty undergrad

>>9626319
>>9628290
MATLAB is a proprietary programming language you brainlets.

>>9629354
More like MATLAB sucks, period.

>>9629361
>implying Python in better than Matlab

Get the fuck out of here, gnutard

>>9630280
It's not and nobody said so

>>9630291
It is though. Python with numba or even numpy is faster than Matlab in array operations; which is the only thing Matlab is supposed to be good for.

>>9630713
Do you have any benchmarks for that claim, it seem at least somewhat counter intuitive, I would suspect that both would base themselves on LAPACK or similar and at least use the same underlying BLAS routines.

>>9630765
As a matter of fact I do.

http://jekel.me/2017/Python-with-Numba-faster-than-fortran/

Notice that MATLAB has the worst results on the all the tests.

> I would suspect that both would base themselves on LAPACK or similar and at least use the same underlying BLAS routines.

You would be correct. However, the Python compiler efficiency is superior on all platforms, as you can see from the other results. In addition, numba allows for greater control of parallelization according to the users needs.

>>9630816
>Numpy code
>X += Y; X += Y;

>Matlab code
>X = X + 2.0*Y;

CS majors prove to be fucking retarded once again.

>>9630836
Kek.

Neither me nor that guy is a CS major though. I have to admit, idiotic syntax (which the compiler will modify anyway so doesn't change the results of the benchmark)

>>9630850
>I have to admit, idiotic syntax (which the compiler will modify anyway so doesn't change the results of the benchmark
>syntax

The point is the python code is doing 2 floating point addition operations where the Matlab/Fortran code is doing a floating point MULTIPLICATION operation followed by an addition operation. Of course a FP mult instruction will slower than a FP add instruction. The benchmark is highly invalid and purposely misleading.

>>9628310
scipy is shit and sympy is full of bugs.

>>9630816
Very interesting I have to say, that makes me want to look into numba.

>>9631032
fake and gay, look at the code.

>>9631033
>look at the code
If I understand you correctly, the only thing you pointed out was the discrepancy between numpy and the others, which I do not care about.
"return x + 2 * y" seems to be the relevant line in the numba code, where it is "X = X + 2.0*Y;" in the matlab example.

>>9631017
>The point is the python code is doing 2 floating point addition operations where the Matlab/Fortran code is doing a floating point MULTIPLICATION operation followed by an addition operation.
Sorry, but you don't understand how modern compilers work.

Syntax have zero influence on the final operations performed.

You can write something like

X = X + 1
X = X - 1

And any good compiler will ignore this.

If MATLAB is somehow a 60s tier compiler that doesn't do this then that alone is reason enough not to use it. But it isn't.

>>9631030
>scipy is shit
Then why does all the most relevant research questions in the world get answered using it, including the black hole gravity wave simulations, various CERN groups etc. They have more money, resources and intellect than God and you think that they purposely use a shit software? No they use it because it is the best as most research articles show.

>>9631038
He's a fucking idiot of no consequence, just ignore him.

>>9631059
>X = X + 1
>X = X - 1
>And any good compiler will ignore this.

Only for built-in types. It can't assume it does nothing for custom data types like matrices and vectors.

>>9631070
>He's a fucking idiot of no consequence, just ignore him.
>>9631059
>Syntax have zero influence on the final operations performed.

Try finding an optimizing compiler that will return run "y=y+2*x;" instead of "y=y+x; y=y+x;" with the following code. I fucking dare you.

#include<iostream>

class custom_type{
int data;

public:
constexpr custom_type(int data): data{data} {}
constexpr custom_type(): data{0} {}

custom_type operator+(custom_type x){
custom_type z{x.data+data};
std::cout<<"Adding!";
return z;
}

custom_type operator*(custom_type x){
custom_type z{x.data*data};
std::cout<<"Multiplying!";
return z;
}

};

int main(){
custom_type x = 1;
custom_type y = 0;
y = y+x; y = y+x;
}

>>9631070
>He's a fucking idiot of no consequence, just ignore him.
>>9631059
>Syntax have zero influence on the final operations performed.

Try finding an optimizing compiler that will return run "y=y+2*x;" instead of "y=y+x; y=y+x;" with the following code. I fucking dare you.

#include<iostream>

class custom_type{
int data;

public:
constexpr custom_type(int data): data{data} {}
constexpr custom_type(): data{0} {}

custom_type operator+(const custom_type& x) const {
std::cout<<"Adding!";
return x.data+data;
}

custom_type operator*(const custom_type& x) const {
std::cout<<"Multiplying!";
return x.data*data;
}

};

int main(){
custom_type x = 1;
custom_type y = 0;
y = y+x; y = y+x;
}

>>9630280
>implying Python is better than Matlab
Correct.

>>9630816
Really surprising and interesting result, although I'm curious to see how that stacks up for other tasks and also what the errors are in the means. I swear every time someone reports singular values without error estimates in benchmarking I want to punch a bird.

Come on people just copy his code and make the adjustment yourself and see if it modifies the benchmark

>>9631070
> and you think that they purposely use a shit software?
Some idiot post-doc probably started to program in python (because "muh open source") and now, years later, the code-base is so convoluted that it's not worth changing. The fact that scipy isn't shitty enough for people to rewrite their whole code-base from scratch does not mean it's not shit. Had it been that shitty no one would have used it in the first place.

>>9631070
>and you think that they purposely use a shit software

Some of them use Perl, IDL, and labview. \burn

>>9630280
When did he imply that

>>9628312
>command line arguments in MATLAB
Ahahahahhaha lmaooo

>>9625927
Any retard that reads all of the documentation before beginning to do shit in a high-level normie language like MATLAB should be post-birth aborted for severe autism.

>>9625957
If programming languages are tools, then MATLAB is Tonka tough.

>>9635424
Please elaborate.

>>9630713
Matlab/Octave/Julia all have better syntax than Python for technical programming by people who are not primarily programmers.

>>9628290
Not how this works newfag

>>9630816
>I’m not going to touch GPU acceleration in this benchmark, but I think it will be worthwhile to do so sometime.
Into the trash it goes

Simulink is a pretty cool guy

>>9625791
INDEXES START AT 0
EVERY FUNCTIONS DOESN'T HAVE TO BE ITS OWN FILE
REEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE

>>9637347
EVERYTHING DOESN'T HAVE TO BE A GOD DAMN MATRIX

>>9637347
>INDEXES START AT 0
so exactly like in linear algebra

>>9637353
if you ain't using matrices use a different language