f4go alternatives and similar packages

Based on the "Go Compilers" category.
Alternatively, view f4go alternatives based on common mentions on social networks and blogs.

gopherjs

9.6 8.2 f4go VS gopherjs

A compiler from Go to JavaScript for running Go code in a browser
llgo

7.6 0.0 f4go VS llgo

LLVM-based compiler for Go

WorkOS - The modern identity platform for B2B SaaS

The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.

Promo workos.com

android-go

7.5 0.0 f4go VS android-go

The android-go project provides a platform for writing native Android apps in Go programming language.
tardisgo

6.4 0.0 f4go VS tardisgo

Golang->Haxe->CPP/CSharp/Java/JavaScript transpiler
c4go

6.1 7.0 f4go VS c4go

Transpiling C code to Go code
c2go

5.6 8.0 f4go VS c2go

Convert C to Go
esp32

3.7 1.7 f4go VS esp32

Transpile Golang into Arduino code to use fully automated testing at your IoT projects.
xgo

3.6 9.1 f4go VS xgo

Enable function trap in go, provide trace and mock to help write and debug unit test faster

Do you think we are missing an alternative of f4go or a related project?

Add another 'Go Compilers' Package

Popular Comparisons

README

f4go

Example of use

> # Install golang
> # Compile f4go
> go get -u github.com/Konstantin8105/f4go
> cd $GOPATH/src/github.com/Konstantin8105/f4go
> go build
> ./f4go ./testdata/blas/caxpy.f
> # Look on Go result source
> less ./testdata/blas/caxpy.go

Transpiling fortran code to golang code

Present result:

*> \brief \b CAXPY
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at
*            http://www.netlib.org/lapack/explore-html/
*
*  Definition:
*  ===========
*
*       SUBROUTINE CAXPY(N,CA,CX,INCX,CY,INCY)
*
*       .. Scalar Arguments ..
*       COMPLEX CA
*       INTEGER INCX,INCY,N
*       ..
*       .. Array Arguments ..
*       COMPLEX CX(*),CY(*)
*       ..
*
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*>    CAXPY constant times a vector plus a vector.
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] N
*> \verbatim
*>          N is INTEGER
*>         number of elements in input vector(s)
*> \endverbatim
*>
*> \param[in] CA
*> \verbatim
*>          CA is COMPLEX
*>           On entry, CA specifies the scalar alpha.
*> \endverbatim
*>
*> \param[in] CX
*> \verbatim
*>          CX is COMPLEX array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
*> \endverbatim
*>
*> \param[in] INCX
*> \verbatim
*>          INCX is INTEGER
*>         storage spacing between elements of CX
*> \endverbatim
*>
*> \param[in,out] CY
*> \verbatim
*>          CY is COMPLEX array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
*> \endverbatim
*>
*> \param[in] INCY
*> \verbatim
*>          INCY is INTEGER
*>         storage spacing between elements of CY
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee
*> \author Univ. of California Berkeley
*> \author Univ. of Colorado Denver
*> \author NAG Ltd.
*
*> \date November 2017
*
*> \ingroup complex_blas_level1
*
*> \par Further Details:
*  =====================
*>
*> \verbatim
*>
*>     jack dongarra, linpack, 3/11/78.
*>     modified 12/3/93, array(1) declarations changed to array(*)
*> \endverbatim
*>
*  =====================================================================
      SUBROUTINE CAXPY(N,CA,CX,INCX,CY,INCY)
*
*  -- Reference BLAS level1 routine (version 3.8.0) --
*  -- Reference BLAS is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     November 2017
*
*     .. Scalar Arguments ..
      COMPLEX CA
      INTEGER INCX,INCY,N
*     ..
*     .. Array Arguments ..
      COMPLEX CX(*),CY(*)
*     ..
*
*  =====================================================================
*
*     .. Local Scalars ..
      INTEGER I,IX,IY
*     ..
*     .. External Functions ..
      REAL SCABS1
      EXTERNAL SCABS1
*     ..
      IF (N.LE.0) RETURN
      IF (SCABS1(CA).EQ.0.0E+0) RETURN
      IF (INCX.EQ.1 .AND. INCY.EQ.1) THEN
*
*        code for both increments equal to 1
*
         DO I = 1,N
            CY(I) = CY(I) + CA*CX(I)
         END DO
      ELSE
*
*        code for unequal increments or equal increments
*          not equal to 1
*
         IX = 1
         IY = 1
         IF (INCX.LT.0) IX = (-N+1)*INCX + 1
         IF (INCY.LT.0) IY = (-N+1)*INCY + 1
         DO I = 1,N
            CY(IY) = CY(IY) + CA*CX(IX)
            IX = IX + INCX
            IY = IY + INCY
         END DO
      END IF
*
      RETURN
      END

Go code:

package main

//*> \brief \b CAXPY
//*
//*  =========== DOCUMENTATION ===========
//*
//* Online html documentation available at
//*            http://www.netlib.org/lapack/explore-html/
//*
//*  Definition:
//*  ===========
//*
//*       SUBROUTINE CAXPY(N,CA,CX,INCX,CY,INCY)
//*
//*       .. Scalar Arguments ..
//*       COMPLEX CA
//*       INTEGER INCX,INCY,N
//*       ..
//*       .. Array Arguments ..
//*       COMPLEX CX(*),CY(*)
//*       ..
//*
//*
//*> \par Purpose:
//*  =============
//*>
//*> \verbatim
//*>
//*>    CAXPY constant times a vector plus a vector.
//*> \endverbatim
//*
//*  Arguments:
//*  ==========
//*
//*> \param[in] N
//*> \verbatim
//*>          N is INTEGER
//*>         number of elements in input vector(s)
//*> \endverbatim
//*>
//*> \param[in] CA
//*> \verbatim
//*>          CA is COMPLEX
//*>           On entry, CA specifies the scalar alpha.
//*> \endverbatim
//*>
//*> \param[in] CX
//*> \verbatim
//*>          CX is COMPLEX array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
//*> \endverbatim
//*>
//*> \param[in] INCX
//*> \verbatim
//*>          INCX is INTEGER
//*>         storage spacing between elements of CX
//*> \endverbatim
//*>
//*> \param[in,out] CY
//*> \verbatim
//*>          CY is COMPLEX array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
//*> \endverbatim
//*>
//*> \param[in] INCY
//*> \verbatim
//*>          INCY is INTEGER
//*>         storage spacing between elements of CY
//*> \endverbatim
//*
//*  Authors:
//*  ========
//*
//*> \author Univ. of Tennessee
//*> \author Univ. of California Berkeley
//*> \author Univ. of Colorado Denver
//*> \author NAG Ltd.
//*
//*> \date November 2017
//*
//*> \ingroup complex_blas_level1
//*
//*> \par Further Details:
//*  =====================
//*>
//*> \verbatim
//*>
//*>     jack dongarra, linpack, 3/11/78.
//*>     modified 12/3/93, array(1) declarations changed to array(*)
//*> \endverbatim
//*>
//*  =====================================================================
func CAXPY(N *int, CA *complex128, CX *[]complex128, INCX *int, CY *[]complex128, INCY *int) {
    I := new(int)
    IX := new(int)
    IY := new(int)
    //*
    //*  -- Reference BLAS level1 routine (version 3.8.0) --
    //*  -- Reference BLAS is a software package provided by Univ. of Tennessee,    --
    //*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
    //*     November 2017
    //*
    //*     .. Scalar Arguments ..
    //*     ..
    //*     .. Array Arguments ..
    //*     ..
    //*
    //*  =====================================================================
    //*
    //*     .. Local Scalars ..
    //*     ..
    //*     .. External Functions ..
    //*     ..
    if (*(N)) <= 0 {
        return
    }
    if (*SCABS1((CA))) == 0.0e+0 {
        return
    }
    if (*(INCX)) == 1 && (*(INCY)) == 1 {
        //*
        //*        code for both increments equal to 1
        //*
        for (*I) = 1; (*I) <= (*(N)); (*I)++ {
            (*(CY))[(*I)-(1)] = (*(CY))[(*I)-(1)] + (*(CA))*(*(CX))[(*I)-(1)]
        }
    } else {
        //*
        //*        code for unequal increments or equal increments
        //*          not equal to 1
        //*
        (*IX) = 1
        (*IY) = 1
        if (*(INCX)) < 0 {
            (*IX) = (-(*(N))+1)*(*(INCX)) + 1
        }
        if (*(INCY)) < 0 {
            (*IY) = (-(*(N))+1)*(*(INCY)) + 1
        }
        for (*I) = 1; (*I) <= (*(N)); (*I)++ {
            (*(CY))[(*IY)-(1)] = (*(CY))[(*IY)-(1)] + (*(CA))*(*(CX))[(*IX)-(1)]
            (*IX) = (*IX) + (*(INCX))
            (*IY) = (*IY) + (*(INCY))
        }
    }
    //*
    return
}

Example of simplification Go code(comments removed for short view):

package main

func CAXPY(N int, CA *complex128, CX []complex128, INCX int, CY []complex128, INCY int) {
    var I int
    var IX int
    var IY int

    if N <= 0 {
        return
    }
    if (*SCABS1((CA))) == 0.0e+0 {
        return
    }
    if INCX == 1 && INCY == 1 {

        for I = 1; I <= N; I++ {
            CY[I-1] = CY[I-1] + CA*CX[I-1]
        }
    } else {

        IX = 1
        IY = 1
        if INCX < 0 {
            IX = (-N+1)*INCX + 1
        }
        if INCY < 0 {
            IY = (-N+1)*INCY + 1
        }
        for I = 1; I <= N; I++ {
            CY[IY-1] = CY[IY-1] + CA*CX[IX-1]
            IX = IX + INCX
            IY = IY + INCY
        }
    }

    return
}