Author Topic: Advanced Theory & Programming of The Human Organism  (Read 4185 times)

0 Members and 1 Guest are viewing this topic.


vag

  • Hero Member
  • *****
  • Posts: 4966
  • Respect: +2641
    • View Profile
Re: Advanced Theory & Programming of The Human Organism
« Reply #1 on: November 07, 2010, 05:28:02 am »
0
v.0.1

The idea being born talking about raptor's fat loss phase :

Well I don't feel like there's another way... I don't see one. It's not like I'm competing in powerlifting, 3 months should be "enough" for strength training.

3 months is not that much but its not little either. From personal experience your main concern should be the cutting phase , it is imperative to maintain strength in order to avoid yo-yo.
So connecting that to JCs post , IMO 3 months of bulking are enough to put some serious mass and strength , but then yo umust plan the fat-loss phase really good. I would suggest caloric deficit and increased cardio combined with heavy singles ( MSEM ) workouts & big eating. It should be more like a try-catch approach , start with a scheme ( low eating + MSEM ) , see how your body responds to it , adjust , retry and so on...

void fat_loss_phase( void )
{
    project_plan = init_fat_los_plan();
    do{
        iok = attemptFatLoss( project_plan );
        if( iok != continue_current_plan ){
             project_plan = adjust_project_plan()
        }
    }while( iok != fat_loss_achieved )
}

int attemptFatLoss( int project_plan )
{
    int iret;

    if( doFatLoss( project_plan ) != succesfull ){
         iret = needs_adjust;
    }else{
        if( isFatLossComplete() ){
            iret = fat_loss_achieved;
        }else{
            iret = continue_current_plan;
        }
    }
    return iret;
}


Note that this programm deliberately doesn't have an abort case , it will continue forever untill you succeed!

GO GET IT!

woot

vag

  • Hero Member
  • *****
  • Posts: 4966
  • Respect: +2641
    • View Profile
Re: Advanced Theory & Programming of The Human Organism
« Reply #2 on: November 07, 2010, 05:29:30 am »
0
v.0.2

adarq LEVELS IT UP!


epic post, hall of fame status.






adjusted for raptor:

typedef struct exercises {
char * name;
int status;
} exercise_t;

exercise_t exercises[EXERCISE_MAX];


void fat_loss_phase( void )
{
    project_plan = init_fat_los_plan();
    init_exercise_list();
    do{
        iok = attemptFatLoss( project_plan );
        if( iok != continue_current_plan ){
             project_plan = adjust_project_plan()
        }
    }while( iok != fat_loss_achieved )
}

int attemptFatLoss( int project_plan )
{
    int iret;
    exercise_t * ex;


    ex = provide_safe_exercises();
    if(ex == NULL) { puts("you're fucked, relax"); exit(1); }

    if( doFatLoss( ex, project_plan ) != succesfull ){
         iret = needs_adjust;
    }else{
        if( isFatLossComplete() ){
            iret = fat_loss_achieved;
        }else{
            iret = continue_current_plan;
        }
    }
    return iret;
}

#define EXERCISE_CURRENTLY_SAFE 0
#define EXERCISE_CURRENTLY_UNSAFE_AND_PROBLEMATIC 1
#define EXERCISE_CURRENTLY_UNSAFE_DONT_FUCKING_DO_IT 2

exercise_t * provide_safe_exercises(void) {
exercise_t * ex = NULL;
int i; for(i=0;i<EXERCISE_MAX;i++) { if(!(exercises.status == 1 || exercises.status == 2)) { ex = &exercise; break; }}
return ex;
}





ok typed that out real quick, hope it compiles.

lulz
woot

vag

  • Hero Member
  • *****
  • Posts: 4966
  • Respect: +2641
    • View Profile
Re: Advanced Theory & Programming of The Human Organism
« Reply #3 on: November 07, 2010, 05:30:57 am »
0
v.1.0

Uh-Oh , it's getting serious...  :o

Hahahahaha , epic x 2 , that's exactly what i thought you would reply , word-by-word! :D

I typed mine on the go too.  :D
Funny thing , i really liked the whole idea and afterwards my mind has been working on the complete design pattern of that shit. An object oriented design , where depending on user we will load the apropriate function , that will be pretty epic but it comes pretty close to what i do at work so it ruins the fun of being in here , LOLLLLLLLLLLL

Oh well, here's a fast version of it , on the go again:

struct UltimateTrainer
{
     int assesmentFunc();
     int trainingFunc();
     int evaluationFunc();
     struct trainingData{
        ....
        ....
        ....
     }*data;
}

int goGetIt( string *athlete )
{
    struct UltimateTrainer *my_trainer

    my_trainer = initAthletesTrainer( athlete );
    runUltimateTrainer( my_trainer );
}

struct UltimateTrainer initAthletesTrainer( string *athlete )
{
    UltimateTrainer *my_trainer  = malloc( ...);

    if( athlete == 'raptor' ){
        assesmentFunc = aquireListOfSafeExcercises( my_trainer->data );
        trainingrFunc = attemptFatLoss( my_trainer->data );
        evaluationFunc = checkIfFatLossAchieved( my_trainer->data );
    }
     return my_trainer;
}

runUltimateTrainer( struct UltimateTrainer *my_trainer )
{
    my_trainer->assesmentFunc( my_trainer->data);
    do{
         my_trainer->trainingFunc( my_trainer->data);
    }while( my_trainer->evaluationFunc() != my_trainer->data->user_goal );
}

HAHAHAHA , loving it!  ;D  ;D  ;D

Pretty geeky too  :-\ , LETS NERD THE FUCK OUT!  :headbang:

woot

adarqui

  • Administrator
  • Hero Member
  • *****
  • Posts: 29615
  • who run it.
  • Respect: +7018
    • View Profile
    • Email
Re: Advanced Theory & Programming of The Human Organism
« Reply #4 on: November 07, 2010, 05:40:01 am »
0
Some data structures for the UltimateAthlete struct:

typedef struct UltimateAthlete {
uA_bioanalysis_t        bioanalysis; // height, weight, age, name.. contains pointers to muscleanalysis, boneanalysis, etc
uA_injury_history_t    injury_history; // list of bone, tendon, ligament, etc injuries sustained
uA_training_history_t training_history; // linked list of training programs/systems utilized, including sub-lists of training sessions per day, also including the pre-testing & post-testing results for each training program
uA_muscles_t            muscleanalysis; // linked list of each muscle group, force & length/tension characteristics, dynamic/static/passive flexibility characteristics, injury history list, circumference/CSA - complete mapping, fiber composition, tendon lengths to insertion on bone
uA_bones_t               boneanalysis; // list of bone lengths, csa's - complete mapping, bone density
uA_braintype_t          brainanalysis; // the conscious & subconscious psychological aspects of the athlete
uA_diet_t                  dietaryanalysis; // a list of days with sublists to each meal/snack/liquid intake for that day, based per 24hour period
uA_sleep_t                sleepanalysis; // a list the sleep habits experienced per day, for how long, feeling upon waking, how long it took to sleep, etc
} uA_t;


next, define those substructures lolz (ok lets just picture them for now).

everything could then be linked together based on timestamps, or, have it organized a different way, an array of ultimateAthlete structures with all information filled in for that day, each member of the array is the day they were alive, so you can just access ultimateAthlete[365] for data @ 1 year of age, then ultimateAthlete[365*20] for 20 years of age. Then you wouldn't have to keep a history any longer, the history would be in the array, the only thing you'd need to keep lists for is things that attach, like the muscleanalysis & boneanalysis substructures.

lool.



feedback_t * TrainingSession(ultimateAthlete_t *ua, ...) where ... is a variable length number of arguments consisting of an exercise_t *, which includes sets, reps, rest intervals, tempo, cues, weight lifted/height achieved/etc.. a feedback_t is returned, which contains lists of exercises & their outcomes, to monitor progress properly or to flag an exercise as dangerous or currently too intense, etc.

feedback_t is then used to update progressions, re-calculate maxes, flag exercises by adding them to integrity checks prior to sessions (ie, aquireListOfSafeExcercises( my_trainer->data ); )

etc

lolzlzlz





vag

  • Hero Member
  • *****
  • Posts: 4966
  • Respect: +2641
    • View Profile
Re: Advanced Theory & Programming of The Human Organism
« Reply #5 on: November 07, 2010, 07:11:24 am »
0
Niceeeee , that's why i didnt fill anything in the data substruct.
The "athlete" data will be input on the beginning ( assesment func ).
But they will also be modified during the process.

ok , v1.1 patch:

struct UltimateTrainer
{
     int assesmentFunc();
     int trainingFunc();
    int updateAthleteData();
    int reFormTrainingPlan();
     int evaluationFunc();
     struct trainingData{
        uA_bioanalysis_t        bioanalysis; // height, weight, age, name.. contains pointers to muscleanalysis, boneanalysis, etc
        uA_injury_history_t    injury_history; // list of bone, tendon, ligament, etc injuries sustained
        uA_training_history_t training_history; // linked list of training programs/systems utilized, including sub-lists of training sessions per day, also including the pre-testing & post-testing results for each training program
        uA_muscles_t            muscleanalysis; // linked list of each muscle group, force & length/tension characteristics, dynamic/static/passive flexibility characteristics, injury history list, circumference/CSA - complete mapping, fiber composition, tendon lengths to insertion on bone
        uA_bones_t               boneanalysis; // list of bone lengths, csa's - complete mapping, bone density
        uA_braintype_t          brainanalysis; // the conscious & subconscious psychological aspects of the athlete
        uA_diet_t                  dietaryanalysis; // a list of days with sublists to each meal/snack/liquid intake for that day, based per 24hour period
        uA_sleep_t                sleepanalysis; // a list the sleep habits experien        ....
        ....
        ....
     }*data;
}



And the main function changes to:

runUltimateTrainer( struct UltimateTrainer *my_trainer )
{
    my_trainer->assesmentFunc( my_trainer->data);
    do{
         my_trainer->trainingFunc( my_trainer->data);
        my_trainer->updateAthleteData( my_trainer->data );
        my_trainer->reformTrainingPlan( my_trainer->data );// this will be just dummy if no change is needed.
    }while( my_trainer->evaluationFunc() != END_TRAINING );
}

 :P  :P  :P
woot

adarqui

  • Administrator
  • Hero Member
  • *****
  • Posts: 29615
  • who run it.
  • Respect: +7018
    • View Profile
    • Email
Re: Advanced Theory & Programming of The Human Organism
« Reply #6 on: November 07, 2010, 06:24:44 pm »
0
struct UltimateTrainer
{
     int assesmentFunc();



assessmentFunc() would also go through all of the *analysis substructures, and based on the bioanalysis of the person on that day, would filter out exercises that would be less effective, for example, using limb lengths, extremely long SHR'd athletes would have ATG squatting downvoted in favor of half squatting.. Based on explosive to maximal strength ratios, ie, RVJ to SVJ to static SVJ, plyometric/reactive/explosive exercises would be filtered/added to the list of available exercises, sets/reps/durations would also be calculated based on work capacity values taken from the training history analysis substructs.

so trainingFunc() feeds off of assessmentFunc() as the athlete matures chronologically.


so, before you get to trainingFunc(), you go through assessmentFunc()/evaluationFunc(), then you apply extra filters based on reFormTrainingPlan();, then and only then, may you apply trainingFunc().. optimal training, every day, no exceptions.

lulzcakes.

adarqui

  • Administrator
  • Hero Member
  • *****
  • Posts: 29615
  • who run it.
  • Respect: +7018
    • View Profile
    • Email
Re: Advanced Theory & Programming of The Human Organism
« Reply #7 on: November 07, 2010, 06:33:15 pm »
0
i think this thread illustrates the importance of journaling......... hahahahah... we basically do this, though at a much different level, in our journals.. I mean if we had the ability to record so much more data, it would start to look exactly how we're laying this out.. If you look at the "making progress : keeping a journal", it is a crude illustration of this.. If we kept track of more things, like sleep schedule, exact calorie intake/expenditure, etc, and had a program to parse our journals every day, it would become what this thread has become... lol

we already keep track of:

bodyweight =
soreness =
aches/injuries =
fatigue =
diet =

and of course our workouts, and how we felt during them etc..

:)

Joe

  • Global Moderator
  • Hero Member
  • *****
  • Posts: 2041
  • Goobernatorial
  • Respect: +642
    • View Profile
    • Email
Re: Advanced Theory & Programming of The Human Organism
« Reply #8 on: November 07, 2010, 06:41:05 pm »
0
Anyone else feel an open source project coming on?
"i threaten to kill myself whenever my parnets tell me to get a job" - bjpenn

adarqui

  • Administrator
  • Hero Member
  • *****
  • Posts: 29615
  • who run it.
  • Respect: +7018
    • View Profile
    • Email
Re: Advanced Theory & Programming of The Human Organism
« Reply #9 on: November 07, 2010, 06:49:26 pm »
0
so, this programming actually seems pretty simple, it's all just a loop with filters/assessment/analysis functions, then your training function.. I think the next trick is learning how to optimize the actual trainingFunc() code, without changing anything structural.

For example, something like smolov can improve squat form simply by improving motor patterns involved with squatting, that's code optimization.. I don't think that's the key though, I think the key in code optimization comes from accurately predicting supercompensation. Our program must very accurately be able to:

1. create dips in performance which result in supercompensation
2. accurately predict exactly when peak supercompensation results
3. create nutritional strategies that coincide with the above 2 points, that result in the utmost strength/alertness.. integrate those strategies with supercompensation so to enhance the effect.

Any injury that is sustained in our training would then be considered a bug, so to would sub optimal training systems based on the analysis functions.

A bug causes some kind of crash, an injury is a crash.. The hardest types of bugs to find are those which cause data inconsistency way down the road, such as memory allocation bugs / data corruption bugs and crap like that.. Data corruption would involve ineffective programming of the various analysis/evaluation bugs, because it would prime our trainingFunc() with the incorrect/suboptimal road to success.

Too much overcomplication of the trainingFunc() would easily lead to bugs down the road, because it would create too many code paths, bulky code in general, & too much interference. The analysis functions could be very bulky, as their job is to organize all of the information (past & present) and make decisions based on that data, to supply to our streamlined trainingFunc().

llozlzolzozl

adarqui

  • Administrator
  • Hero Member
  • *****
  • Posts: 29615
  • who run it.
  • Respect: +7018
    • View Profile
    • Email
Re: Advanced Theory & Programming of The Human Organism
« Reply #10 on: November 07, 2010, 06:49:55 pm »
0
Anyone else feel an open source project coming on?

hahahaahhahahhahaha

GNUathleticPerformance.

adarqui

  • Administrator
  • Hero Member
  • *****
  • Posts: 29615
  • who run it.
  • Respect: +7018
    • View Profile
    • Email
Re: Advanced Theory & Programming of The Human Organism
« Reply #11 on: November 07, 2010, 07:04:51 pm »
0
another interesting concept here, is this.. we are looking at this from the micro level, but, say we look at it on the macro level. It becomes Genetic Programming, using evolutions and populations.

The population, such as our community of forum users (athlete structures), comes here with their own training histories, injury histories, etc.. Each user generally creates their own evaluation functions, assessment functions, etc, the degree to which each user does this varies with experience etc.. But basically, these are random "individuals" making up the population, the degree of variety exists, and eventually becomes refined/phased out after each evolution through the training process..

For example, we may have 40 athletes in the population, utilizing 40 different training ideologies.. After evolution #1, each athlete will have different results, the athletes with the best results tend to continue what they are doing, while the athletes with the worst results tend to incorporate ideologies based on what the best are using.. Evolution after evolution, the OVERALL asessment/evaluation/trainingFunc/filters are enhanced on a macro level, which each athlete incorporates on the micro level.. So basically, after years and years of evolution, this forum will have some pretty refined functions & filters regarding performance training, that will get people to where they need to go ALOT faster than a forum that people frequent only to "train to train"..

The key here is learning from each individual, taking into account their differences, similarities, etc, then creating branches in the assessment/eval/training functions so that each person goes down the optimal code path.

This is actually what is happening, slowly..

This forum now becomes the evolutionary algorithm of athletic performance enhancement, that is, as more & more journals are created and kept up with, it will happen.

The entire s&c industry is an evolutionary algorithm, but the problem is, so much scam/fluff has been injected, that the branches most people take, lead to failure, which then makes the s&c evolutionary algorithm a DEVOLUTIONARY algorithm. WTF. We need to demonstrate the optimal paths to success, over and over again, in order to make a dent in this massive population.

lolzozozlzo

adarqui

  • Administrator
  • Hero Member
  • *****
  • Posts: 29615
  • who run it.
  • Respect: +7018
    • View Profile
    • Email
Re: Advanced Theory & Programming of The Human Organism
« Reply #12 on: November 07, 2010, 07:10:00 pm »
0
that leads to another thing, we are not simply creating programs / ideologies / systems / assessments out of thin air, we are injecting algorithms that have led to more success into the overall pool of individuals, which then lead to further success etc, and also, further refinement/optimization.

the similarities between genetic programming and s&c is pretty much perfect.

bball2020

  • Hero Member
  • *****
  • Posts: 628
  • Respect: +55
    • View Profile
Re: Advanced Theory & Programming of The Human Organism
« Reply #13 on: November 07, 2010, 07:13:29 pm »
0
good point...lets speed up the evolution by deleting users survivor style who are only bringing the forum down  :strong:

adarqui

  • Administrator
  • Hero Member
  • *****
  • Posts: 29615
  • who run it.
  • Respect: +7018
    • View Profile
    • Email
Re: Advanced Theory & Programming of The Human Organism
« Reply #14 on: November 07, 2010, 07:46:00 pm »
0
good point...lets speed up the evolution by deleting users survivor style who are only bringing the forum down  :strong:

that's why there is a journal graveyard :D






another thing, it's interesting to me that, plenty of people who start trying to improve their athleticism, they completely lack an assessment/evaluation function.. If they lack an assessment/evaluation function, then the feedback_t returned from trainingFunc() becomes useless.. If you don't journal, you might as well give up before you try, because that is the basis for eval/assessment.

plenty of people that do have an assessment/eval function, have a problem understanding the feedback returned from trainingFunc(), i mean, we've all seen people just journal, pages upon pages, of just doing the same old thing over and over without a real focus on results.. You can't reFormTrainingPlan() if feedback_t is useless.. Some people never reform their training plan, they lack that function also, their training just becomes a loop of trainingFunc() without any filters, this usually is devastating.