Jared Frazier's questions

A questão é exatamente o título: Fortran permite alterar membros de dados de tipo derivado SUBROUTINEmesmo com INTENT(IN), como proteger dados? Sou bem novo em Fortran e esse comportamento de permitir a mutação de membros de dados de um tipo derivado apesar do INTENT(IN)atributo no argumento fictício de tipo derivado é bem preocupante para mim. Existe uma maneira de capturar esse tipo de mutação insegura com o compilador? Por exemplo, gfortran -Wallnão parece fazer isso, mas talvez esse seja um problema comum o suficiente em bases de código legadas ou mesmo modernas para onde alguma detecção estática do problema esteja disponível de alguma forma?

Programa de exemplo:

! @file main.f90
!
! @purpose: Show data members of derived types are mutable in SUBROUTINE 
!
! @compile: gfortran -Wall main.f90
PROGRAM test
    IMPLICIT NONE

    INTEGER :: n_states = 1
    INTEGER :: len_state = 5 
    INTEGER :: i, j

    TYPE t_states 
        INTEGER, POINTER, CONTIGUOUS :: state(:) ! (len_state,)
    END TYPE t_states

    TYPE(t_states), ALLOCATABLE :: states(:) ! (n_states,)

    ALLOCATE(states(1:n_states)) 

    ! Populate allocated array of states
    DO i = 1, n_states 
        ALLOCATE(states(i)%state(len_state))
        DO j = 1, len_state 
            states(i)%state(j) = j
            PRINT *, states(i)%state(j)
        END DO
        PRINT *
    END DO
 
    CALL unsafe_mutation(states(1))

    ! Print state array after modification
    DO j = 1, len_state
        PRINT *, states(1)%state(j)
    END DO 

CONTAINS

    ! Arbitrary update of state data member even though INTENT(IN)!!!
    SUBROUTINE unsafe_mutation(p_states)
        TYPE(t_states), INTENT(in) :: p_states
        p_states%state(1) = -1 
    END SUBROUTINE

END PROGRAM test

Saída:

           1
           2
           3
           4
           5

          -1
           2
           3
           4
           5

Estou tentando aplicar o princípio DRY a classes de plotagem de brinquedo como um exercício intelectual para melhorar meu entendimento de POO (atualmente lendo Python Object Oriented programming ), mas intuitivamente parece que o uso de uma hierarquia de herança potencialmente cada vez mais profunda pode levar a uma base de código mais complicada (especialmente porque li que a composição parece ser favorecida em relação à herança, veja Composition over inheritance wiki ). Parece que uma biblioteca de brinquedo poderia potencialmente acabar com muitas classes abstratas como AbstractMonthlyMultiPanelPlote AbstractSeasonalPlotassim por diante para tipos de plotagem arbitrários acomodarem diferentes dados de entrada.

Existe uma maneira mais pythonic de lidar com o problema abaixo que talvez eu esteja esquecendo? Estou violando algum tipo de princípio de design que eu interpretei mal ou talvez tenha simplesmente perdido completamente?

from abc import abstractmethod, ABC
from numpy import ndarray
from typing import List, Tuple
import matplotlib.pyplot as plt 

class AbstractPlot(ABC)
    @abstractmethod
    def plot(self): 
        raise NotImplementedError

class AbstractMonthlyPlot(AbstractPlot):
    @abstractmethod
    def plot_for_month(ax, data):
        raise NotImplementedError

    @property
    def n_months(self): 
        """number of months in a year"""
        return 12 

    def plot(self, month_to_data: List[Tuple[ndarray]]):
        fig, axs = plt.subplots(self.n_months, 1)
        for month in range(self.n_months):
            self._plot_for_month(ax=axs[month], data=month_to_data[month])

class Contour(AbstractMonthlyPlot):
    def _plot_for_month(self, ax, data):
        ax.contourf(*data)

class Linear(AbstractMonthlyPlot):
    def _plot_for_month(self, ax, data):
        ax.plot(*data)

Estou usando shdoc para gerar arquivos markdown para minhas funções bash; no entanto, gostaria de anexar também o corpo da função bash associada , bem como os comentários nesse corpo, ao arquivo markdown gerado por shdoc. Como posso imprimir um corpo de função bash e, ao mesmo tempo, incluir os comentários no corpo da função?

Como um exemplo simples, considere que todos os meus arquivos bash estão contidos em um diretório chamado srce todos esses arquivos terminam em .sh. A função abaixo no arquivosrc/foo.sh

# @description A function that does something
foo() {
  # oh wow, a comment
  echo "something cool"
}

Agora, se eu quiser obter o corpo da função sem comentários, posso fazer isso facilmente, declare -fconforme mostrado abaixo, em um arquivo chamado src/doc.sh:

# assuming you are in the `src` dir and both .sh files are executable
. foo.sh
foo_doc=$(declare -f foo)
echo "$foo_doc"

Mas o problema é foo_docque só tem a função body, já queecho "$foo_doc"

foo () 
{ 
    echo "something cool"
}

e nenhum comentário. Então, se eu fosse anexar essas informações a um markdown gerado por shdoc, não seria uma documentação ideal do código-fonte.

Acho que uma abordagem seria usar sedpara determinar as linhas correspondentes à função de interesse (minhas funções bash são "delimitadas" por {e }, embora, pelos comentários, eu entenda que há outras maneiras de declarar funções bash válidas), então eu poderia usar sedpara obter apenas essas linhas, como feito aqui .

Eu entendo como um somatório em 1, 2 e 3 dimensões poderia ser definido usando 1, 2 e 3 forloops respectivamente, mas como você poderia fazer uma função geral que soma um multi-índice como o definido abaixo?

Suponha que uapenas amostras de um número inteiro aleatório por simplicidade, ou seja,

from random import randint
def u(a=0, b=100):
    return randint(a, b)

Por exemplo, digamos o vetor multi-índice js = [0, 0, 0]e o vetor de limite superior Ms = [5, 5, 5], isso implicaria que d = 3(ou seja, multi-índice tridimensional), e a soma poderia ser escrita simplesmente como abaixo

mysum = 0
for j1 in range(Ms[0]):
    for j2 in range(Ms[1]):
        for j3 in range(Ms[2]):
            mysum += u()

mas qual seria uma maneira geral de escrever isso para ddimensões (como mostrado na imagem)?

Editar: eu sei que neste exemplo trivial, alguém poderia simplesmente fazer algo como

from numpy import prod
M = prod(Ms)
mysum = sum([u() for i in range(M)]) 

mas, novamente, estou interessado especificamente em uma maneira geral de fazer loops daninhados for, já que a função upode ser mais complexa e depender dos índices j_1, j_2, ..., j_d.