Llenar array

[compuin]

Movorack

Sin comentarios

[compuin]

Empezado por movorack

Tienes razón, no faltaba mas que alguien vaya y se mofe de tu falta de conocimientos técnicos para exponer el problema, de los problemas de redacción, y mucho menos de la falta de claridad. O hasta de pronto de la falta de comprensión lectora, Porque ya leíste la guia de estilo cierto?

En fin, tienes razón.



¡Vaya, vaya! Que ecfisa no te halla comprendido muestra lo mal explicado que está.



Y... me quedo sin saber aún cual es el problema, porque no funciona, como quieres que funcione, si van a sacar una segunda película de The Joker.

Bueno si, solo un comentario mas....payaso seras tu!

[Casimiro Notevi]

Empezado por compuin

Bueno si, solo un comentario mas....payaso seras tu!

Sigue así, y serás expulsado.

[compuin]

Empezado por compuin

Bueno si, solo un comentario mas....payaso seras tu!

Y el que me llamo Joker no cierto??

[[escafandra]]

Calma. Creo que hay un acúmulo de malas interpretaciones. Por un lado tenemos un usuario con poca experiencia pero con ganas de resolver un tema y por otro lado foristas que con ganas de prestar ayuda no terminamos de entender el tema en profundidad. Frustración por ambas partes. Entiendo que cuando alguien tiene poca experiencia le resulta complejo explicarse. El problema es que la gente más experta también tiene problemas en entender puesto que se necesita precisión en la pregunta. Si aparecen suspicacias se pierde el sentido y ultimo fin, que es la ayuda desinteresada. No hay magos de sabiduría infinita que todo lo entiendan al vuelo como tampoco hay gente que consiga hacerse entender en problemas que le resultan complejos. Con buena voluntad las cosas van saliendo y así ha sido siempre.

Yo pediría a compuin que trate de estudiar mejor su problema para poder preguntar con mayor precisión, que es la garantía de buenas respuestas y soluciones. También pediría al resto, comprensión ante la dificultad de explicarse pues no creo que sea deliberada. Creo que compuin debería abordar temas más pequeños para familiarizarse con delphi y la forma de encarar los problemas desde el punto de vista del programador y, sobre todo, no tener prisa en abordar nuevas cuestiones sin tener claras al 100% las previas, es la única forma de aprender con provecho.

Saludos.

[compuin]

Muchas gracias escafandra por tu post. Tomare un tiempo para replantear mi inquietud de la forma más clara para todos.

[mamcx]

Una manera simple cuando estas estancado con codigo, es mostrar los datos de entrada y los datos deseados de salida. Es posible que haya un algoritmo mas simple.

[xalo]

@Compuin, hay una cosa/concepto (no caigo ahora como llamarle, la verdad :-) muy útil que se llama MCVE y que muy resumido es un ejemplo mínimo de código donde se reproduzca el error. Aquí tienes todos los detalles y amplia explicación...

Para problemas complejos (y también no tan complejos), va muy bién para que se entienda rápidamente el problema y a la vez te ayude el máximo número de gente (aquí encontrarás muchísima), ya que con un copiar-pegar lo puede reproducir cualquiera, y creeme que quitas muchas barreras así.

(No tiene nada de ironía esta respuesta, simplemente la única buena intención de ayudar a resolver el problema)

Un saludo

[Neftali [Germán.Estévez]]

Empezado por xalo

@Compuin, hay una cosa/concepto (no caigo ahora como llamarle, la verdad :-) muy útil que se llama MCVE y que muy resumido es un ejemplo mínimo de código donde se reproduzca el error. Aquí tienes todos los detalles y amplia explicación...

Muy de acuerdo contigo.

...
...
...

Empezado por Neftali [Germán.Estévez]

Otra opción que no se utiliza mucho, pero que es muy útil es subir un pequeño proyecto (código) sólo con la parte del código a examinar y en ese caso el muy fácil descargarlo, abrirlo y revisar el comportamiento.

[orodriguezca]

Al parecer la librería "swedll32.dll" si está documentada y aparentemente tiene un nicho de usuarios importante. Buscando información al respecto encontré el siguiente dato:

(tomado de stackoverflow) Antes de llamar a swe_calc_ut usted debería colocar un Path a un folder con los datos de "ephe" con algo similar a lo siguiente :

Código PHP:

[DllImport("swedll32.dll", CharSet = CharSet.Ansi, EntryPoint = "swe_set_ephe_path")]
private static extern void swe_set_ephe_path(String swe_path);

swe_set_ephe_path(@"c:\path\to\ephe\"); 


Tal vez está información sea de utilidad para compuin.

[compuin]

Aca dejo el llamado de funciones para la swedll32.dll

Lo copio en parte porque no puedoi agregar todo en un post

Código Delphi [-]
unit swiss;

{ Swiss Ephemeris function declarations for Delphi 2 (32-bit), by Sarah Ashton}

interface

{Calculate positions of planets, asteroids, lunar nodes and apogees}
function swe_calc(tjd          : double;    {Julian day, Ephemeris Time}
                   ipl         : Integer;   {planet number}
                   iflag       : Longint;   {flag bits}
                   var xx      : double;    {first of 6 doubles}
                   sErr        : PChar      {Error-String}
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_calc@24';

function swe_calc_ut(tjd         : double;    {Julian day, Universal Time}
                     ipl         : Integer;   {planet number}
                     iflag       : Longint;   {flag bits}
                     var xx      : double;    {first of 6 doubles}
                     sErr        : PChar      {Error-String}
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_calc_ut@24';


{Close Swiss Ephemeris. Release resources used by the Swiss Ephemeris DLL.
 i.e. - the ephemeris path set by swe_set_ephe_path()
      - the JPL file name set by swe_set_jpl_file()
      - the geographical location set by swe_set_topo() for topocentric
planetary positions
      - the sidereal mode set by swe_set_sid_mode() for sidereal planetary
positions}
procedure swe_close; stdcall; far; external 'swedll32.dll' name
'_swe_close@0';

{Coordinate transformation, from ecliptic to equator (-ve eps) or
vice-versa}
procedure swe_cotrans(var xpin  : double; {long., lat., dist}
                   var xpout    : double;
                   eps          : double   {obliquity}
); stdcall; far; external 'swedll32.dll' name '_swe_cotrans@16';

{Coordinate transformation of position and speed}
procedure swe_cotrans_sp(var xpin  : double;
                   var xpout    : double;
                   eps          : double
); stdcall; far; external 'swedll32.dll' name '_swe_cotrans_sp@16';

function swe_csnorm(p: Longint
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_csnorm@4';

function swe_csroundsec(x: Longint
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_csroundsec@4';

function swe_cs2degstr(t: Longint;
                   s     : pchar
): pchar; stdcall; far; external 'swedll32.dll' name '_swe_cs2degstr@8';

function swe_cs2lonlatstr(t: Longint;
                   pch   : char;
                   mch   : char;
                   s     : pchar
): pchar; stdcall; far; external 'swedll32.dll' name
'_swe_cs2lonlatstr_d@16';

function swe_cs2timestr(t: Longint;
                   sep   : integer;
                   suppresszero : integer;
                   s     : pchar
): pchar; stdcall; far; external 'swedll32.dll' name '_swe_cs2timestr@16';

function swe_date_conversion(year: integer;
                   month       : integer;
                   day         : integer;
                   utime       : double;
                   c           : char;      {'g'regorian or 'j'ulian}
                   var tjd     : double
): integer; stdcall; far; external 'swedll32.dll' name
'_swe_date_conversion@28';

function swe_day_of_week(var tjd: double
): integer; stdcall; far; external 'swedll32.dll' name
'_swe_day_of_week@8';

function swe_degnorm(x: double
): double; stdcall; far; external 'swedll32.dll' name '_swe_degnorm@8';

function swe_deltat(tjd  : double
): double; stdcall; far; external 'swedll32.dll' name '_swe_deltat@8';

function swe_difcsn(p1: Longint;
                   p2 : Longint
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_difcsn@8';

function swe_difcs2n(p1: Longint;
                   p2 : Longint
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_difcs2n@8';

function swe_difdegn(p1 : double;
                   p2     : double
): double; stdcall; far; external 'swedll32.dll' name '_swe_difdegn@16';

function swe_difdeg2n(p1 : double;
                   p2     : double
): double; stdcall; far; external 'swedll32.dll' name '_swe_difdeg2n@16';

function swe_d2l(x: double
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_d2l@8';

function swe_fixstar(star      : pchar;     {star name}
                   tjd         : double;    {Julian day in Ephemeris Time}
                   iflag       : Longint;   {flag bits}
                   var xx      : double;    {first of 6 doubles}
                   sErr        : pchar      {Error-String}
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_fixstar@24';

function swe_fixstar_ut(star   : pchar;     {star name}
                   tjd         : double;    {Julian day in Universal Time}
                   iflag       : Longint;   {flag bits}
                   var xx      : double;    {first of 6 doubles}
                   sErr        : pchar      {Error-String}
): Longint; stdcall; far; external 'swedll32.dll' name
'_swe_fixstar_ut@24';

function swe_get_planet_name(ipl : integer;
                   pname      : PChar
): PChar; stdcall; far; external 'swedll32.dll' name
'_swe_get_planet_name@8';

function swe_get_tid_acc(t_acc: double
): double; stdcall; far; external 'swedll32.dll' name '_swe_get_tid_acc@0';

function swe_houses(tjdut      : double;
                    geolat     : double;
                    geolon     : double;
                    hsys       : char;
                    var hcusp0 : double;
                    var ascmc0 : double
): integer; stdcall; far; external 'swedll32.dll' name '_swe_houses@36';

function swe_houses_ex(tjdut   : double;
                    iflag      : Longint; {0 or SEFLG_SIDEREAL or
SEFLG_RADIANS}
                    geolat     : double;
                    geolon     : double;
                    hsys       : char;
                    var hcusp0 : double;
                    var ascmc0 : double
): integer; stdcall; far; external 'swedll32.dll' name '_swe_houses_ex@40';

function swe_houses_armc(armc  : double;
                    geolat     : double;
                    eps        : double;
                    hsys       : char;
                    var hcusp0 : double;
                    var ascmc0 : double
): integer; stdcall; far; external 'swedll32.dll' name
'_swe_houses_armc@36';

function swe_house_pos(armc: double;
                    geolon : double;
                    eps    : double;
                    hsys      : char;
                    var xpin  : double;  {2 doubles: ecl. longitude and
latitude}
                    serr      : pchar
): double; stdcall; far; external 'swedll32.dll' name '_swe_house_pos@36';

function swe_julday(year     : integer;
                    month      : integer;
                    day        : integer;
                    hour       : double;
                    gregflag   : integer
): double; stdcall; far; external 'swedll32.dll' name '_swe_julday@24';

procedure swe_revjul(tjd        : double;
                    gregflag    : integer;
                    var year    : integer;
                    var month   : integer;
                    var day     : integer;
                    var hour    : double
); stdcall; far; external 'swedll32.dll' name '_swe_revjul@28';

{Equation of time}
function swe_time_equ(tjd_et   : double;
                   var e       : double; {local apparent - local mean time}
                   sErr        : PChar      {Error-String}
): integer; stdcall; far; external 'swedll32.dll' name '_swe_time_equ@16';

{Set path for ephemeris files}
procedure swe_set_ephe_path(path: pchar
); stdcall; far; external 'swedll32.dll' name '_swe_set_ephe_path@4';

procedure swe_set_jpl_file(fname: pchar
); stdcall; far; external 'swedll32.dll' name '_swe_set_jpl_file@4';

procedure swe_set_tid_acc(t_acc: double
); stdcall; far; external 'swedll32.dll' name '_swe_set_tid_acc@8';

procedure swe_set_topo(geolon   : double;
                   geolat       : double;
                   height       : double
); stdcall; far; external 'swedll32.dll' name '_swe_set_topo@24';

function swe_sidtime(tjdut: double
): double; stdcall; far; external 'swedll32.dll' name '_swe_sidtime@8';

function swe_sidtime0(tjdut: double;
                    eps_true: double;
                    nut_long: double
): Integer; stdcall; far; external 'swedll32.dll' name '_swe_sidtime0@24';

procedure swe_set_sid_mode(sid_mode: longint;
                            t0      : double;
                            ayan_t0 : double
); stdcall; far; external 'swedll32.dll' name '_swe_set_sid_mode@20';

function swe_get_ayanamsa(tjd_et: double
): double; stdcall; far; external 'swedll32.dll' name
'_swe_get_ayanamsa@8';

function swe_get_ayanamsa_ut(tjd_ut: double
): double; stdcall; far; external 'swedll32.dll' name
'_swe_get_ayanamsa_ut@8';


{Eclipse calculations??}
{Computes geographic location and attributes of solar eclipse at a given
tjd}
function swe_sol_eclipse_where(tjd_ut  : double;
                            ifl        : longint; {Ephemeris flag }
                            var geopos : double;  {longitude, latitude,
height above sea}                           
                            var attr   : double; {first of 20 doubles}
                            serr       : pchar
): longint; stdcall; far; external 'swedll32.dll' name
'_swe_sol_eclipse_where@24';

{Computes attributes of a solar eclipse for given tjd, geolon, geolat}
function swe_sol_eclipse_how(tjd_ut    : double;        {time, Jul. day UT}
                            ifl        : longint; {ephemeris flag}
                            var geopos : double;  {longitude, latitude,
height above sea}
                            var attr   : double; {first of 20 doubles}
                            serr       : pchar
): longint; stdcall; far; external 'swedll32.dll' name
'_swe_sol_eclipse_how@24';

{Finds time of next local eclipse}
function swe_sol_eclipse_when_loc(tjd  : double;  {start date for search,
Jul. day UT}
                            ifl        : longint; {Ephemeris flag }
                            var geopos : double;  {longitude, latitude,
height above sea}
                            var tret   : double; {first of 10 doubles}
                            var attr   : double; {first of 20 doubles}
                            backward   : boolean; {TRUE, if backward
search}
                            serr       : pchar
): longint; stdcall; far; external 'swedll32.dll' name
'_swe_sol_eclipse_when_loc@32';

{Finds time of next eclipse globally}
function swe_sol_eclipse_when_glob(tjd  : double;  {start date for search,
Jul. day UT}
                             ifl        : longint; {Ephemeris flag}
                             ifltype    : longint; {eclipse type wanted:
SE_ECL_TOTAL etc}
                             var tret   : double; {first of 10 doubles}
                             var attr   : double; {first of 20 doubles}
                             backward   : boolean; {TRUE, if backward
search}
                             serr       : pchar
): longint; stdcall; far; external 'swedll32.dll' name
'_swe_sol_eclipse_when_glob@28';

{computes attributes of a lunar eclipse for given tjd}
function swe_lun_eclipse_how(tjd_ut     : double;  {time, Jul. day UT}
                             ifl        : longint; {Ephemeris flag}
                             var geopos : double;  {longitude, latitude,
height above sea}
                             var attr   : double; {first of 20 doubles}
                             serr       : pchar
): longint; stdcall; far; external 'swedll32.dll' name
'_swe_lun_eclipse_how@24';

function swe_lun_eclipse_when(tjd       : double;  {start date for search,
Jul. day UT}
                             ifl        : longint; {Ephemeris flag}
                             ifltype    : longint; {eclipse type wanted:
SE_ECL_TOTAL etc}
                             var tret   : double; {first of 10 doubles}
                             backward   : boolean; {TRUE, if backward
search}
                             serr       : pchar
): longint; stdcall; far; external 'swedll32.dll' name
'_swe_lun_eclipse_when@28';


{planetary phenomena}
function swe_pheno(tjd_et    : double; {time Jul. Day ET}
                  ipl        : longint; {planet number}
                  ifl        : longint; {Ephemeris flag}
                  var attr   : double; {first of 20 doubles}
                  serr       : pchar
): longint; stdcall; far; external 'swedll32.dll' name '_swe_pheno@24';

function swe_pheno_ut(tjd_ut : double; {time Jul. Day UT}
                  ipl        : longint; {planet number}
                  ifl        : longint; {Ephemeris flag}
                  var attr   : double; {first of 20 doubles}
                  serr       : pchar
): longint; stdcall; far; external 'swedll32.dll' name '_swe_pheno_ut@24';

function swe_refrac(inalt   : double;
                   atpress  : double; {atmospheric pressure in mbar (hPa)}
                   attemp   : double; {atmospheric temperature in degrees
Celsius}
                   ifl      : longint {either SE_TRUE_TO_APP or
SE_APP_TO_TRUE}
): double; stdcall; far; external 'swedll32.dll' name '_swe_refrac@28';

procedure swe_azalt(tjd_ut  : double;   {UT}
                 cflag      : longint; {SE_ECL2HOR or SE_EQU2HOR}
                 var geopos : double;  {longitude, latitude, height above
sea}
                 atpress    : double; {atmospheric pressure in mbar (hPa)}
                 attemp     : double; {atmospheric temperature in degrees
Celsius}
                 var xin    : double;   {ecliptical or equatorial
coordinates}
                 var xaz    : double    {azimuth, true altitude, apparent
altitude}
); stdcall; far; external 'swedll32.dll' name '_swe_azalt@40';

procedure swe_azalt_rev(tjd_ut  : double;       {UT}
                     cflag      : longint; {SE_HOR2ECL or SE_HOR2EQU}
                     var geopos : double;  {longitude, latitude, height
above sea}
                     var xin    : double;  {azimuth and true altitude}
                     var xout   : double        {ecliptical or equatorial
coordinates: x,y,z}
); stdcall; far; external 'swedll32.dll' name '_swe_azalt_rev@24';

function swe_rise_trans(tjd_ut : double; {Search after this time (UT)}
                    ipl        : longint; {planet number}
                    starname   : pchar;     {star name, if star}
                    ifl        : longint; {Ephemeris flag}
                    rsmi       : longint; {Transits wanted}
                    var geopos : double;  {longitude, latitude, height
above sea}
                    atpress    : double; {atmospheric pressure in mbar
(hPa)}
                    attemp     : double; {atmospheric temperature in
degrees Celsius}
                    var tret   : double; {first of 10 doubles}
                    serr       : pchar
): longint; stdcall; far; external 'swedll32.dll' name
'_swe_rise_trans@52';


{Compute planetary nodes and apsides}
function swe_nod_aps(tjd_et : double; {Julian day, Ephemeris Time}
                  ipl       : longint; {planet number}
                  iflag     : Longint;   {flag bits}
                  method    : longint; {calculation method}
                  var xnasc : double; {First of 6 doubles for ascending
node}
                  var xndsc : double; {First of 6 doubles for descending
node}
                  var xperi : double; {First of 6 doubles for perihelion}
                  var xaphe : double; {First of 6 doubles for aphelion}
                  serr      : pchar
): longint; stdcall; far; external 'swedll32.dll' name '_swe_nod_aps@40';

function swe_nod_aps_ut(tjd_ut : double; {Julian day, Universal Time}
                  ipl       : longint;{planet number}
                  iflag     : Longint;{flag bits}
                  method    : longint;{calculation method}
                  var xnasc : double; {First of 6 doubles for ascending
node}
                  var xndsc : double; {First of 6 doubles for descending
node}
                  var xperi : double; {First of 6 doubles for perihelion}
                  var xaphe : double; {First of 6 doubles for aphelion}
                  serr      : pchar
): longint; stdcall; far; external 'swedll32.dll' name
'_swe_nod_aps_ut@40';


{Swiss Ephemeris constants for Pascal}
const
   SE_ECL_NUT: integer         = -1;
   SE_SUN: integer             = 0;
   SE_MOON: integer            = 1;
   SE_MERCURY: integer         = 2;
   SE_VENUS: integer           = 3;
   SE_MARS: integer            = 4;
   SE_JUPITER: integer         = 5;
   SE_SATURN: integer          = 6;
   SE_URANUS: integer          = 7;
   SE_NEPTUNE: integer         = 8;
   SE_PLUTO: integer           = 9;
   SE_MEAN_NODE: integer       = 10;
   SE_TRUE_NODE: integer       = 11;
   SE_MEAN_APOG: integer       = 12;
   SE_OSCU_APOG: integer       = 13;
   SE_EARTH: integer           = 14;
   SE_CHIRON: integer          = 15;
   SE_PHOLUS: integer          = 16;
   SE_CERES: integer           = 17;
   SE_PALLAS: integer          = 18;
   SE_JUNO: integer            = 19;
   SE_VESTA: integer           = 20;

   SE_NPLANETS: integer        = 21;
   SE_AST_OFFSET: integer      = 10000;
   SE_FICT_OFFSET: integer     = 40;
   SE_NFICT_ELEM: integer      = 15;

   { Hamburger or Uranian "planets" }
   SE_CUPIDO: integer          = 40;
   SE_HADES: integer           = 41;
   SE_ZEUS: integer            = 42;
   SE_KRONOS: integer          = 43;
   SE_APOLLON: integer         = 44;
   SE_ADMETOS: integer         = 45;
   SE_VULKANUS: integer        = 46;
   SE_POSEIDON: integer        = 47;
   { other ficticious bodies }
   SE_ISIS: integer            = 48;
   SE_NIBIRU: integer          = 49;
   SE_HARRINGTON: integer      = 50;
   SE_NEPTUNE_LEVERRIER: integer = 51;
   SE_NEPTUNE_ADAMS: integer     = 52;
   SE_PLUTO_LOWELL: integer      = 53;
   SE_PLUTO_PICKERING: integer   =  54;

{Flag bits for parameter iflag in function swe_calc()
 Iflag = 0 delivers - the default ephemeris (SWISS) is used,
     - apparent geocentric positions referring to the true equinox of date
are returned.
     If not only coordinates, but also speed values are required, use iflag
= SEFLG_SPEED.}
   SEFLG_JPLEPH: Longint = 1;       { use JPL ephemeris }
   SEFLG_SWIEPH: Longint = 2;       { use SWISSEPH ephemeris }
   SEFLG_MOSEPH: Longint = 4;       { use Moshier ephemeris }
   SEFLG_HELCTR: Longint = 8;      { return heliocentric position }
   SEFLG_TRUEPOS: Longint = 16;    { return true positions, not apparent }
   SEFLG_J2000: Longint = 32;    { no precession, i.e. give J2000 equinox }
   SEFLG_NONUT: Longint = 64;    { no nutation, i.e. mean equinox of date }
   SEFLG_SPEED: Longint = 256;    { high precision speed (analytical
computation) }
   SEFLG_NOGDEFL: Longint = 512;    { turn off gravitational deflection }
   SEFLG_NOABERR: Longint = 1024;   { turn off 'annual' aberration of light
}
   SEFLG_EQUATORIAL: Longint = (2*1024);   { equatorial positions are
wanted }
   SEFLG_XYZ: Longint = (4*1024);   { cartesian, not polar, coordinates are
wanted}
   SEFLG_RADIANS: Longint   = (8*1024);   { coordinates are wanted in
radians, not degrees }
   SEFLG_BARYCTR: Longint   = (16*1024);  { barycentric positions }
   SEFLG_TOPOCTR: Longint   = (32*1024);  { topocentric positions }
   SEFLG_SIDEREAL: longint  =  (64*1024);  { sidereal positions }

   SE_SIDBITS              = 256; {for projection onto ecliptic of t0}
   SE_SIDBIT_ECL_T0        = 256;  {for projection onto solar system plane}
   SE_SIDBIT_SSY_PLANE     = 512;

   SE_MAX_STNAME : Longint = 20; {maximum size of fixstar name;
                                   the parameter star in swe_fixstar
                                   must allow twice this space for
                                   the returned star name.}

   SEHOUSE_SYSTEM: array[0..9] of Char = ('P', 'K', 'O', 'R', 'C', 'E',
'V', 'X', 'H', 'T');
{       'P'     Placidus
        'K'     Koch
        'O'     Porphyrius
        'R'     Regiomontanus
        'C'     Campanus
        'A' or 'E'      Equal (cusp 1 is Ascendant)
        'V'     Vehlow equal (Asc. in middle of house 1)
        'X'     axial rotation system
        'H'     azimuthal or horizontal system
        'T'     Polich/Page ("topocentric" system)
}
       

 {Sidereal modes for swe_set_sid_mode}
    SE_SIDM_FAGAN_BRADLEY = 0;
    SE_SIDM_LAHIRI = 1;
    SE_SIDM_DELUCE = 2;
    SE_SIDM_RAMAN = 3;
    SE_SIDM_USHASHASHI = 4;
    SE_SIDM_KRISHNAMURTI = 5;
    SE_SIDM_DJWHAL_KHUL = 6;
    SE_SIDM_YUKTESHWAR = 7;
    SE_SIDM_JN_BHASIN = 8;
    SE_SIDM_BABYL_KUGLER1 = 9;
    SE_SIDM_BABYL_KUGLER2 = 10;
    SE_SIDM_BABYL_KUGLER3 = 11;
    SE_SIDM_BABYL_HUBER = 12;
    SE_SIDM_BABYL_ETPSC = 13;
    SE_SIDM_ALDEBARAN_15TAU = 14;
    SE_SIDM_HIPPARCHOS = 15;
    SE_SIDM_SASSANIAN = 16;
    SE_SIDM_GALCENT_0SAG = 17;
    SE_SIDM_J2000 = 18;
    SE_SIDM_J1900 = 19;
    SE_SIDM_B1950 = 20;
    SE_SIDM_USER = 255;

    SE_NSIDM_PREDEF    = 21;

{eclipse codes}
    SE_ECL_CENTRAL: longint       = 1;
    SE_ECL_NONCENTRAL: longint    = 2;
    SE_ECL_TOTAL: longint         = 4;
    SE_ECL_ANNULAR: longint       = 8;
    SE_ECL_PARTIAL: longint       = 16;
    SE_ECL_ANNULAR_TOTAL: longint = 32;
    SE_ECL_PENUMBRAL: longint     = 64;
    SE_ECL_VISIBLE: longint       = 128;
    SE_ECL_MAX_VISIBLE: longint   = 256;
    SE_ECL_1ST_VISIBLE: longint   = 512;
    SE_ECL_2ND_VISIBLE: longint   = 1024;
    SE_ECL_3RD_VISIBLE: longint   = 2048;
    SE_ECL_4TH_VISIBLE: longint   = 4096;

{Bits for data conversion with swe_azalt() and swe_azalt_rev()}
    SE_ECL2HOR         = 0;
    SE_EQU2HOR         = 1;
    SE_HOR2ECL         = 0;
    SE_HOR2EQU         = 1;

{For swe_refrac()}
    SE_TRUE_TO_APP     = 0;
    SE_APP_TO_TRUE     = 1;

{Indices for swe_rise_trans()}
    SE_CALC_RISE        = 1;
    SE_CALC_SET         = 2;
    SE_CALC_MTRANSIT    = 4;    {upper meridian transit}
    SE_CALC_ITRANSIT    = 8;    {lower meridian transit}
    SE_BIT_DISC_CENTER  = 256; {added to SE_CALC_RISE/SET if rise or set of
disc center is  requried}
    SE_BIT_NO_REFRACTION =512; {added to SE_CALC_RISE/SET if refraction is
not to be considered }


{points returned by swe_houses() and swe_houses_armc() ascmc[0...10]}
    SE_ASC              = 0;
    SE_MC               = 1;
    SE_ARMC             = 2;
    SE_VERTEX           = 3;
    SE_EQUASC           = 4;    { "equatorial ascendant" }
    SE_COASC1           = 5;    { "co-ascendant" (W. Koch) }
    SE_COASC2           = 6;    { "co-ascendant" (M. Munkasey) }
    SE_POLASC           = 7;    { "polar ascendant" (M. Munkasey)}
    SE_NASCMC           = 8;

{Modes for planetary nodes/apsides, swe_nod_aps(), swe_nod_aps_ut()}
    SE_NODBIT_MEAN      = 1;
    SE_NODBIT_OSCU      = 2;
    SE_NODBIT_OSCU_BAR  = 4;
    SE_NODBIT_FOPOINT   = 256;

implementation

end.

[compuin]

Aca dejo un ejemplo del codigo con el que estoy trabajando

Código Delphi [-]
unit sample2;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls;

type
  TForm1 = class(TForm)
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    Label4: TLabel;
    Label5: TLabel;
    button_doit: TButton;
    button_exit: TButton;
    day: TEdit;
    month: TEdit;
    year: TEdit;
    outfld: TMemo;
    hour: TEdit;
    minute: TEdit;
    second: TEdit;
    combo_utet: TComboBox;
    lon_deg: TEdit;
    lon_min: TEdit;
    lon_sec: TEdit;
    Combo_EW: TComboBox;
    lat_deg: TEdit;
    lat_min: TEdit;
    lat_sec: TEdit;
    Combo_NS: TComboBox;
    combo_hsys: TComboBox;
    procedure button_doitClick(Sender: TObject);
    procedure button_exitClick(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation
var
  iday, imonth, iyear, ipl, ihour, imin, isec: Integer;
  xx    : Array[0..5] of double;
  serr :  Array[0..255] of Char;

function swe_calc(tjd          : double;    {Julian day number}
                   ipl         : Integer;   {planet number}
                   iflag       : Longint;   {flag bits}
                   var xx      : double;    {first of 6 doubles}
                   sErr        : PChar      {Error-String}
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_calc@24';

procedure swe_close; stdcall; far; external 'swedll32.dll' name '_swe_close@0';

procedure swe_cotrans(var xpin  : double;
                   var xpout    : double;
                   eps          : double
); stdcall; far; external 'swedll32.dll' name '_swe_cotrans@16';

procedure swe_cotrans_sp(var xpin  : double;
                   var xpout    : double;
                   eps          : double
); stdcall; far; external 'swedll32.dll' name '_swe_cotrans_sp@16';

function swe_csnorm(p: Longint
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_csnorm@4';

function swe_csroundsec(x: Longint
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_csroundsec@4';

function swe_cs2degstr(t: Longint;
                   s     : pchar
): pchar; stdcall; far; external 'swedll32.dll' name '_swe_cs2degstr@8';

function swe_cs2lonlatstr(t: Longint;
                   pch   : char;
                   mch   : char;
                   s     : pchar
): pchar; stdcall; far; external 'swedll32.dll' name '_swe_cs2lonlatstr_d@16';

function swe_cs2timestr(t: Longint;
                   sep   : integer;
                   suppresszero : integer;
                   s     : pchar
): pchar; stdcall; far; external 'swedll32.dll' name '_swe_cs2timestr@16';

function swe_date_conversion(year: integer;
                   month       : integer;
                   day         : integer;
                   utime       : double;
                   c           : char;      {'g'regorian or 'j'ulian}
                   var tjd     : double
): integer; stdcall; far; external 'swedll32.dll' name '_swe_date_conversion@28';

function swe_day_of_week(var tjd: double
): integer; stdcall; far; external 'swedll32.dll' name '_swe_day_of_week@8';

function swe_degnorm(x: double
): double; stdcall; far; external 'swedll32.dll' name '_swe_degnorm@8';

function swe_deltat(tjd  : double                   
): double; stdcall; far; external 'swedll32.dll' name '_swe_deltat@8';

function swe_difcsn(p1: Longint;
                   p2 : Longint
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_difcsn@8';

function swe_difcs2n(p1: Longint;
                   p2 : Longint
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_difcs2n@8';

function swe_difdegn(p1 : double;
                   p2     : double
): double; stdcall; far; external 'swedll32.dll' name '_swe_difdegn@16';

function swe_difdeg2n(p1 : double;
                   p2     : double                   
): double; stdcall; far; external 'swedll32.dll' name '_swe_difdeg2n@16';

function swe_d2l(x: double
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_d2l@8';

function swe_fixstar(star      : pchar;     {star name}
                   tjd         : double;    {Julian day number}
                   iflag       : Longint;   {flag bits}
                   var xx      : double;    {first of 6 doubles}
                   sErr        : pchar      {Error-String}
): Longint; stdcall; far; external 'swedll32.dll' name '_swe_fixstar@24';

function swe_get_planet_name(ipl : integer;
                   pname      : PChar
) : PChar; stdcall; far; external 'swedll32.dll' name '_swe_get_planet_name@8';

function swe_get_tid_acc(t_acc: double
) : double; stdcall; far; external 'swedll32.dll' name '_swe_get_tid_acc@0';

function swe_houses(tjdut      : double;
                    geolat     : double;
                    geolon     : double;
                    hsys       : char;
                    var hcusp0 : double;
                    var ascmc0 : double
) : integer; stdcall; far; external 'swedll32.dll' name '_swe_houses@36';

function swe_houses_armc(armc  : double;
                    geolat     : double;
                    eps        : double;
                    hsys       : char;
                    var hcusp0 : double;
                    var ascmc0 : double
) : integer; stdcall; far; external 'swedll32.dll' name '_swe_houses_armc@36';

function swe_house_pos(armc: double;
                    geolon : double;
                    eps    : double;
                    hsys       : char;
                    var xpin   : double;  {2 doubles: ecl. longitude and latitude}
                    serr       : pchar
): double; stdcall; far; external 'swedll32.dll' name '_swe_house_pos@36';

function swe_julday(year     : integer;
                    month      : integer;
                    day        : integer;
                    hour       : double;
                    gregflag   : integer
) : double; stdcall; far; external 'swedll32.dll' name '_swe_julday@24';

procedure swe_revjul(tjd        : double;
                    gregflag    : integer;
                    var year    : integer;
                    var month   : integer;
                    var day     : integer;
                    var hour    : double
); stdcall; far; external 'swedll32.dll' name '_swe_revjul@28';

procedure swe_set_ephe_path(path: pchar
); stdcall; far; external 'swedll32.dll' name '_swe_set_ephe_path@4';

procedure swe_set_jpl_file(fname: pchar
); stdcall; far; external 'swedll32.dll' name '_swe_set_jpl_file@4';

procedure swe_set_tid_acc(t_acc: double
); stdcall; far; external 'swedll32.dll' name '_swe_set_tid_acc@8';

procedure swe_set_topo(geolon   : double;
                   geolat       : double;
                   height       : double
); stdcall; far; external 'swedll32.dll' name '_swe_set_topo@24';

function swe_sidtime(tjdut: double                    
) : double; stdcall; far; external 'swedll32.dll' name '_swe_sidtime@8';

function swe_sidtime0(tjdut: double;
                    eps_true: double;
                    nut_long: double                    
) : Integer; stdcall; far; external 'swedll32.dll' name '_swe_sidtime0@24';


{$R *.DFM}

procedure TForm1.button_doitClick(Sender: TObject);
    const
   hsys: array[0..4] of Char = ('P', 'K', 'R', 'C', 'E');
   SE_ECL_NUT: integer = -1;
   SE_SUN : integer =          0;
   SE_MOON : integer =         1;
   SE_MERCURY : integer =      2;
   SE_VENUS : integer =        3;
   SE_MARS : integer =         4;
   SE_JUPITER : integer =      5;
   SE_SATURN : integer =       6;
   SE_URANUS : integer =       7;
   SE_NEPTUNE : integer =      8;
   SE_PLUTO : integer =        9;
   SE_MEAN_NODE : integer =    10;
   SE_TRUE_NODE : integer =    11;
   SE_MEAN_APOG : integer =    12;
   SE_OSCU_APOG : integer =    13;
   SE_EARTH : integer =        14;
   SE_CHIRON : integer =       15;
   SE_PHOLUS : integer =       16;
   SE_CERES : integer =        17;
   SE_PALLAS : integer =       18;
   SE_JUNO : integer =         19;
   SE_VESTA : integer =        20;

   SE_NPLANETS : integer =     21;
   SE_AST_OFFSET : integer =   10000;
   SE_FICT_OFFSET : integer =  40;
   SE_NFICT_ELEM : integer =   15;

   { Hamburger or Uranian "planets" }
   SE_CUPIDO : integer =         40;
   SE_HADES : integer =          41;
   SE_ZEUS : integer =           42;
   SE_KRONOS : integer =         43;
   SE_APOLLON : integer =        44;
   SE_ADMETOS : integer =        45;
   SE_VULKANUS : integer =       46;
   SE_POSEIDON : integer =       47;
   { other ficticious bodies }
   SE_ISIS : integer =           48;
   SE_NIBIRU : integer =         49;
   SE_HARRINGTON : integer =           50;
   SE_NEPTUNE_LEVERRIER : integer =    51;
   SE_NEPTUNE_ADAMS : integer =        52;
   SE_PLUTO_LOWELL : integer =         53;
   SE_PLUTO_PICKERING : integer =      54;

   {  flag bits for parameter iflag in function swe_calc()
   The flag bits are defined in such a way that iflag = 0 delivers what one
   usually wants:
     - the default ephemeris (SWISS) is used,
     - apparent geocentric positions referring to the true equinox of date are returned.
     If not only coordinates, but also speed values are required, use iflag = SEFLG_SPEED.
   }
   SEFLG_JPLEPH : Longint =      1;       { use JPL ephemeris }
   SEFLG_SWIEPH : Longint =      2;       { use SWISSEPH ephemeris }
   SEFLG_MOSEPH : Longint =      4;       { use Moshier ephemeris }
   SEFLG_HELCTR : Longint =        8;      { return heliocentric position }
   SEFLG_TRUEPOS : Longint =       16;    { return true positions, not apparent }
   SEFLG_J2000 : Longint =         32;    { no precession, i.e. give J2000 equinox }
   SEFLG_NONUT : Longint =         64;    { no nutation, i.e. mean equinox of date }
   SEFLG_SPEED : Longint =         256;    { high precision speed (analytical computation) }
   SEFLG_NOGDEFL : Longint =       512;    { turn off gravitational deflection }
   SEFLG_NOABERR : Longint =       1024;   { turn off 'annual' aberration of light }
   SEFLG_EQUATORIAL : Longint =    (2*1024);   { equatorial positions are wanted }
   SEFLG_XYZ : Longint =           (4*1024);   { cartesian, not polar, coordinates are wanted}
   SEFLG_RADIANS : Longint =       (8*1024);   { coordinates are wanted in radians, not degrees }
   SEFLG_BARYCTR : Longint =       (16*1024);  { barycentric positions }
   SEFLG_TOPOCTR : Longint =       (32*1024);  { topocentric positions }


var
   tjd, tjdet, tjdut, tsid, armc, dhour, deltat : double;
   eps_true, e, nut_long: double;
   glon, glat: double;
   sjul: String[30];
   s: Array[0..255] of Char;
   sout: string[255];
   i, j: integer;
   iflag, rflag : Longint;
   ilondeg, ilonmin, ilonsec, ilatdeg, ilatmin, ilatsec: Integer;
   hcusps: array[0..12] of double;
   ascmc: array[0..9] of double;
   pname: array[0..19] of Char;
begin
  outfld.clear;
  iflag := 0;
  iday := StrToInt(day.Text);
  imonth := StrToInt(month.Text);
  iyear := StrToInt(year.Text);
  ihour := StrToInt(hour.Text);
  imin := StrToInt(minute.Text);
  isec := StrToInt(second.Text);
  ilondeg := StrToInt(lon_deg.Text);
  ilonmin := StrToInt(lon_min.Text);
  ilonsec := StrToInt(lon_sec.Text);
  ilatdeg := StrToInt(lat_deg.Text);
  ilatmin := StrToInt(lat_min.Text);
  ilatsec := StrToInt(lat_sec.Text);
  dhour := ihour + imin / 60.0 + isec / 3600.0;
  tjd := swe_julday(iyear, imonth, iday, dhour, 1);
  deltat := swe_deltat(tjd);
  if (combo_utet.ItemIndex <= 0)then
    begin
    {input date is Universal Time}
    Str((deltat * 86400):16:10,  sjul);
    sout := 'deltat:     ' + sjul + ' sec';
    outfld.Lines.Add(sout);
    tjdut := tjd;
    tjdet := tjd + deltat;
    Str(tjdut:10:8,  sjul);
    sjul := sjul + ' UT';
    end
  else
    begin
    {input date is Ephemeris Time}
    tjdet := tjd;
    tjdut := tjd - deltat;
    Str(tjdet:16:10,  sjul);
    sjul := sjul + ' ET';
    end;
  sout := 'jul. day:   ' + sjul;
  outfld.Lines.Add( sout);
  outfld.Lines.Add(' ');
  { planets }
  for i := SE_SUN to SE_TRUE_NODE do
    begin
      rflag := swe_calc(tjdet, i, iflag, xx[0], serr);
      if (rflag <> iflag) then outfld.Lines.Add(StrPas(serr));
      Str(xx[0]:16:10,  sjul);
      swe_get_planet_name(i, pname);
      sout := StrPas(pname);
      for j := StrLen(pname) to 11 do sout := sout + ' ';
      sout := sout + sjul;
      outfld.Lines.Add( sout);
    end;
  { for houses: ecliptic obliquity and nutation }
  rflag := swe_calc(tjdet, SE_ECL_NUT, 0, xx[0], serr);
  if (rflag <> 0) then outfld.Lines.Add(StrPas(serr));
  eps_true := xx[0];
  e:=xx[1];
  nut_long := xx [2];
  { geographic position }
  glon := ilondeg + ilonmin / 60.0 + ilonsec / 3600.0;
  if (combo_EW.ItemIndex > 0) then glon := -glon;
  glat := ilatdeg + ilatmin / 60.0 + ilatsec / 3600.0;
  if (combo_NS.ItemIndex > 0) then glat := -glat;
  { sidereal time }
  tsid := swe_sidtime(tjdut);
  tsid := tsid + glon / 15;
  armc := tsid * 15;
  outfld.Lines.Add(' ');
  Str(tsid:16:10, sjul);
  sout := 'Sid. time   ' + sjul;
  outfld.Lines.Add( sout);
  Str(armc:16:10, sjul);
  sout := 'ARMC        ' + sjul;
  outfld.Lines.Add( sout);
  { house method }
  i := combo_hsys.ItemIndex;
  if (i < 0) then i := 0;
  swe_houses_armc(armc, glat, eps_true, hsys[i], hcusps[0], ascmc[0]);
  Str(ascmc[0]:16:10, sjul);
  sout := 'ascendant   ' + sjul;
  outfld.Lines.Add( sout);
  Str(ascmc[1]:16:10, sjul);
  sout := 'MC          ' + sjul;
  outfld.Lines.Add( sout);
  Str(ascmc[3]:16:10, sjul);
  sout := 'vertex      ' + sjul;
  outfld.Lines.Add( sout);
  outfld.Lines.Add( '');
  for i := 1 to 12 do
    begin
      Str(i:2, sjul);
      sout := 'house ' + sjul + '    ';
      Str(hcusps[i]:16:10, sjul);
      sout := sout + sjul;
      outfld.Lines.Add( sout);
    end;

end;

procedure TForm1.button_exitClick(Sender: TObject);
begin
swe_close;
  close;
  Exit;
end;

end.

Lo que quisiera es que

Código Delphi [-]
Str(xx[0]:16:10,  sjul);

me llene un array que se llame planeta[i], donde planeta es xx[0] y el elemento i es

Código Delphi [-]
swe_calc(tjdet, i, iflag, xx[0], serr);

Atento a sus comentarios

[mamcx]

El asunto es que en una "marea" de codigo es facil perderse:

http://www.dreamsongs.com/ObjectsHaveNotFailedNarr.html

Muestrame tus flujos y esconde tus tablas, y me mantendrás estupefacto. Muestrame tus tablas y usualmente no necesitare tus flujos, estos serán obvios.

Show me your flowchart and conceal your tables, and I shall continue to be mystified. Show me your tables, and I won't usually need your flowchart; it'll be obvious.
--Fred Brooks, in Chapter 9 of The Mythical Man-Month

Por lo que veo del codigo, esta muy complicado. Tiene DEMASIADAS constantes, abreviaciones y demás que no dejan claro qué es que. Es mas simple escribir funciones cortas que resuelven tareas especificar, y unirlas reduciendo al minimo el uso de variables de estado. Para simular el uso de "tablas" y hacer evidente la estructura del programa, usa en Delphi Records(mejor pa este caso)/Objetos.

Asi, por ejm:

Código Delphi [-]
type
   TPlaneta = (SE_MERCURY, SE_VENUS, ...); 

TPlanetaMedicion = Record
    nombre: TPlaneta
    ..
    ..
  end;

procedure medir(planeta : TPlaneta): TPlanetaMedicion;

Nota bien lo interesante. Usando records/clases como si modelaras las "tablas" de una BD vas dandole forma a la estructura conceptual del programa, y al usuarlo en funciones/metodos se vuelve claro cual es el flujo de este: "medir TPlaneta me retorna un TPlanetaMedicion".

El programa se AUTO DOCUMENTA cuando usas los nombres/clasificaciones/tipos de datos adecuados. De allí es copiar datos y calcular. Ademas, en Delphi tienes enumeraciones y sets, que son superiores (logicamente) que clavar constantes como ocurre con SE_MERCURY y similares.

Aunque pueden haber expeciones, si un metodo/funcione tiene "muchas" lineas *tal vez* es buena idea partirlo en sub rutinas (o agregas marcas con comentario en las secciones).

El truco que dice Fred Brooks es que estructurar los datos clarifica el programa mientras el codigo "duro" lo obscurece.

Con respecto a copiar arrays, es mejor que aprendas como usar iteraciones y LOW/HIGH para capturar las posiciones del mismo:

http://www.delphibasics.co.uk/Article.asp?Name=Arrays

[[escafandra]]

De entrada y sin entrar en el funcionamiento del código veo que tienes una unit con las definiciones para usar swedll32.dll desde delphi. Eso implica que debes incluirla en el uses y no repetir de nuevo nada.


Tu código debe quedar mucho más sencillo y resumiendo esto es la parte que interesa:

Código Delphi [-]
unit sample2; 

interface  

uses   Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,   StdCtrls, swiss;  

type   TForm1 = class(TForm)
    button_doit: TButton;     
    button_exit: TButton;
    outfld: TMemo;
    combo_utet: TComboBox;
    Combo_EW: TComboBox;
    Combo_NS: TComboBox;
    combo_hsys: TComboBox;
    day: TEdit;
    month: TEdit;
    year: TEdit;
    outfld: TMemo;
    hour: TEdit;
    minute: TEdit;
    second: TEdit;
    lon_deg: TEdit;
    lon_min: TEdit;
    lon_sec: TEdit;
    lat_deg: TEdit;
    lat_sec: TEdit;
    lat_min: TEdit;

 ...........
implementation

{$R *.dfm}

procedure TForm1.button_doitClick(Sender: TObject);
const
   hsys: array[0..4] of Char = ('P', 'K', 'R', 'C', 'E');
var
   tjd, tjdet, tjdut, tsid, armc, dhour, deltat : double;
   eps_true, e, nut_long: double;
   glon, glat: double;
   sjul: String[30];
   s: Array[0..255] of Char;
   sout: string[255];
   i, j: integer;
   iflag, rflag : Longint;
   ilondeg, ilonmin, ilonsec, ilatdeg, ilatmin, ilatsec: Integer;
   hcusps: array[0..12] of double;
   ascmc: array[0..9] of double;
   pname: array[0..19] of Char;
begin
  outfld.clear;
  iflag := 0;
  iday := StrToInt(day.Text);
  imonth := StrToInt(month.Text);
  iyear := StrToInt(year.Text);
  ihour := StrToInt(hour.Text);
  imin := StrToInt(minute.Text);
  isec := StrToInt(second.Text);
  ilondeg := StrToInt(lon_deg.Text);
  ilonmin := StrToInt(lon_min.Text);
  ilonsec := StrToInt(lon_sec.Text);
  ilatdeg := StrToInt(lat_deg.Text);
  ilatmin := StrToInt(lat_min.Text);
  ilatsec := StrToInt(lat_sec.Text);
  dhour := ihour + imin / 60.0 + isec / 3600.0;
  tjd := swe_julday(iyear, imonth, iday, dhour, 1);
  deltat := swe_deltat(tjd);
  if (combo_utet.ItemIndex <= 0)then
    begin
    {input date is Universal Time}
    Str((deltat * 86400):16:10,  sjul);
    sout := 'deltat:     ' + sjul + ' sec';
    outfld.Lines.Add(sout);
    tjdut := tjd;
    tjdet := tjd + deltat;
    Str(tjdut:10:8,  sjul);
    sjul := sjul + ' UT';
    end
  else
    begin
    {input date is Ephemeris Time}
    tjdet := tjd;
    tjdut := tjd - deltat;
    Str(tjdet:16:10,  sjul);
    sjul := sjul + ' ET';
    end;
  sout := 'jul. day:   ' + sjul;
  outfld.Lines.Add( sout);
  outfld.Lines.Add(' ');
  { planets }
  for i := SE_SUN to SE_TRUE_NODE do
    begin
      rflag := swe_calc(tjdet, i, iflag, xx[0], serr);
      if (rflag <> iflag) then outfld.Lines.Add(StrPas(serr));
      Str(xx[0]:16:10,  sjul);
      swe_get_planet_name(i, pname);
      sout := StrPas(pname);
      for j := StrLen(pname) to 11 do sout := sout + ' ';
      sout := sout + sjul;
      outfld.Lines.Add( sout);
    end;
  { for houses: ecliptic obliquity and nutation }
  rflag := swe_calc(tjdet, SE_ECL_NUT, 0, xx[0], serr);
  if (rflag <> 0) then outfld.Lines.Add(StrPas(serr));
  eps_true := xx[0];
  e:=xx[1];
  nut_long := xx [2];
  { geographic position }
  glon := ilondeg + ilonmin / 60.0 + ilonsec / 3600.0;
  if (combo_EW.ItemIndex > 0) then glon := -glon;
  glat := ilatdeg + ilatmin / 60.0 + ilatsec / 3600.0;
  if (combo_NS.ItemIndex > 0) then glat := -glat;
  { sidereal time }
  tsid := swe_sidtime(tjdut);
  tsid := tsid + glon / 15;
  armc := tsid * 15;
  outfld.Lines.Add(' ');
  Str(tsid:16:10, sjul);
  sout := 'Sid. time   ' + sjul;
  outfld.Lines.Add( sout);
  Str(armc:16:10, sjul);
  sout := 'ARMC        ' + sjul;
  outfld.Lines.Add( sout);
  { house method }
  i := combo_hsys.ItemIndex;
  if (i < 0) then i := 0;
  swe_houses_armc(armc, glat, eps_true, hsys[i], hcusps[0], ascmc[0]);
  Str(ascmc[0]:16:10, sjul);
  sout := 'ascendant   ' + sjul;
  outfld.Lines.Add( sout);
  Str(ascmc[1]:16:10, sjul);
  sout := 'MC          ' + sjul;
  outfld.Lines.Add( sout);
  Str(ascmc[3]:16:10, sjul);
  sout := 'vertex      ' + sjul;
  outfld.Lines.Add( sout);
  outfld.Lines.Add( '');
  for i := 1 to 12 do
    begin
      Str(i:2, sjul);
      sout := 'house ' + sjul + '    ';
      Str(hcusps[i]:16:10, sjul);
      sout := sout + sjul;
      outfld.Lines.Add( sout);
    end;

end;

procedure TForm1.button_exitClick(Sender: TObject);
begin
  swe_close;
  close;
  Exit;
end;

end.

El código es un galimatías. Debes ir con orden. Primero inicializaciza los ComboBox en funciones de inicio o en el Form.Create.
Luego darás funcionalidad a los botones...

Debes estudiar el uso de esa dll pues al parecer debes inicializar con una ruta que debe contener previamente algunos archivos y quizás requiera más acciones. Este punto es básico y piensa que probablemente ninguno de nosotros estamos familiarizados con esa dll, ese es tu cometido.

Cuando requieras preguntar alguna cosa concreta, trata de aislar en lo posible el código que te preocupa y que sea suficiente para entenderte pero no tán sobrecargado que se pierdan las ganas de leerlo.


Saludos.

[[escafandra]]

Ahora fíjate en este código:

Código Delphi [-]
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, DateUtils, swiss;
.............................



var
  i, iflag: integer;
  xx:       array[0..5] of double;
  planet:   array [1..12] of double;
  serr:     PChar;
  JulDay:   double;
begin
  swe_set_ephe_path(PCHAR('c:\sweph\ephe\'));
  JulDay:= DateTimeToJulianDate(Date);
  for i:= 1 to 12 do
  begin
    swe_calc_ut(Date, i, SE_ECL_NUT, xx[0], serr);
    planet[i]:= xx[0];
  end;
end;

El array es asignado correctamente, otra cosa es que los valores sean los experados.

Fíjate que arroja un error serr = 'SwissEph file 'seplm48.se1' not found in PATH 'c:\sweph\ephe\'' para todos los valores de i hasta para I=10.

Para i= 11 el error es 'SwissEph file 'semom48.se1' not found in PATH 'c:\sweph\ephe\'' y para i=12 no falla


Esto quiere decir que en ese path deben existir previamente esos archivos y probablemente alguno más.

Entonces la pregunta no es como rellenar un array, sino como manejar swedll32.dll para conseguir el array que esperamos.


Saludos.

[[escafandra]]

Pero si lo usamos así:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
var
  i, iflag: integer;
  xx:       array[0..5] of double;
  planet:   array [1..12] of double;
  serr:     PChar;
  JulDay:   double;
begin
//  swe_set_ephe_path(PCHAR('c:\sweph\ephe\'));
  JulDay:= DateTimeToJulianDate(Date);
  iflag := 0;
  for i:= 1 to 12 do
  begin
    swe_calc(Date, i, iflag, xx[0], serr);
    planet[i]:= xx[0];
  end;
end;

Entonces no hay errores y los valores son:

0
0
0
0
0
0
0
0
0
188,01570562548
0
200,800942459646

Ahora bien, no tengo ni idea si eso es lo que se espera para la fecha de hoy.



Saludos.

[compuin]

Hola Escafandra

Te anexo el archivo con el projecto completo (Puse el link ya que no me deja ponerlos adjuntos )


https://www.astro.com/ftp/swisseph/sweph.zip

La Dll hace los calculos, pero existen unos archivos .se1 que aunque arrojan error no son necesarios (Son para calculo de asteroides)

La variable xx[0] se espera que arroje la longitud o posicion planetaria del sol, luna, mercurio, venus, marte, jupiter, saturn, urano, neptuno y pluton

Son 10 planetas, asi que seria del 1 al 10

[compuin]

Para la fecha de hoy esto es lo que se espera

deltat: 69.5103960890 sec
jul. day: 2458900.50000000 UT

Sun 331.8094127618
Moon 302.2187037435
Mercury 341.5633697228
Venus 15.2722542439
Mars 273.1099711227
Jupiter 287.8282244089
Saturn 297.2549903731
Uranus 33.3602165722
Neptune 347.7743860929
Pluto 294.0205054947
mean Node 95.5387999697
true Node 97.1857573215

Sid. time 10.5957212216
ARMC 158.9358183233
ascendant 230.7646482310
MC 157.2282506635
vertex 92.2206035689

house 1 230.7646482310
house 2 261.2501400084
house 3 298.8634035392
house 4 337.2282506635
house 5 8.4105200249
house 6 32.0604837022
house 7 50.7646482310
house 8 81.2501400084
house 9 118.8634035392
house 10 157.2282506635
house 11 188.4105200249
house 12 212.0604837022

[[escafandra]]

Ya, pero eso no es xx [0] que fue el origen de la pregunta y tampoco queda claro que son todos esos datos a no ser que seas entendido en la materia.

Saludos.

[compuin]

Empezado por escafandra

Ya, pero eso no es xx [0] que fue el origen de la pregunta y tampoco queda claro que son todos esos datos a no ser que seas entendido en la materia.

Saludos.

OK

Los datos de houses son las posiciones en una rueda que no esta presente en el codigo (no necesaria dibujarla)

Los calculos de la posicion de los planetas son mostrados en xx[0]

La pregunta original era como podia llenar un array llamado planeta a partir de este ultimo valor